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_STM32F7/device/stm32f7xx_hal_lptim.c@165:e614a9f1c9e2, 2017-05-26 (annotated)

Committer:: AnnaBridge
Date:: Fri May 26 12:39:01 2017 +0100
Revision:: 165:e614a9f1c9e2
Parent:: 161:2cc1468da177
Child:: 168:9672193075cf

This updates the lib to the mbed lib v 143

Who changed what in which revision?

User	Revision	Line number	New contents of line
<>	144:ef7eb2e8f9f7	1	/**
<>	144:ef7eb2e8f9f7	2	******************************************************************************
<>	144:ef7eb2e8f9f7	3	* @file stm32f7xx_hal_lptim.c
<>	144:ef7eb2e8f9f7	4	* @author MCD Application Team
<>	161:2cc1468da177	5	* @version V1.2.0
<>	161:2cc1468da177	6	* @date 30-December-2016
<>	144:ef7eb2e8f9f7	7	* @brief LPTIM HAL module driver.
<>	144:ef7eb2e8f9f7	8	* This file provides firmware functions to manage the following
<>	144:ef7eb2e8f9f7	9	* functionalities of the Low Power Timer (LPTIM) peripheral:
<>	144:ef7eb2e8f9f7	10	* + Initialization and de-initialization functions.
<>	144:ef7eb2e8f9f7	11	* + Start/Stop operation functions in polling mode.
<>	144:ef7eb2e8f9f7	12	* + Start/Stop operation functions in interrupt mode.
<>	144:ef7eb2e8f9f7	13	* + Reading operation functions.
<>	144:ef7eb2e8f9f7	14	* + Peripheral State functions.
<>	144:ef7eb2e8f9f7	15	*
<>	144:ef7eb2e8f9f7	16	@verbatim
<>	144:ef7eb2e8f9f7	17	==============================================================================
<>	144:ef7eb2e8f9f7	18	##### How to use this driver #####
<>	144:ef7eb2e8f9f7	19	==============================================================================
<>	144:ef7eb2e8f9f7	20	[..]
<>	144:ef7eb2e8f9f7	21	The LPTIM HAL driver can be used as follows:
<>	144:ef7eb2e8f9f7	22
<>	144:ef7eb2e8f9f7	23	(#)Initialize the LPTIM low level resources by implementing the
<>	144:ef7eb2e8f9f7	24	HAL_LPTIM_MspInit():
<>	144:ef7eb2e8f9f7	25	(##) Enable the LPTIM interface clock using __LPTIMx_CLK_ENABLE().
<>	144:ef7eb2e8f9f7	26	(##) In case of using interrupts (e.g. HAL_LPTIM_PWM_Start_IT()):
<>	157:ff67d9f36b67	27	(+++) Configure the LPTIM interrupt priority using HAL_NVIC_SetPriority().
<>	157:ff67d9f36b67	28	(+++) Enable the LPTIM IRQ handler using HAL_NVIC_EnableIRQ().
<>	157:ff67d9f36b67	29	(+++) In LPTIM IRQ handler, call HAL_LPTIM_IRQHandler().
<>	144:ef7eb2e8f9f7	30
<>	144:ef7eb2e8f9f7	31	(#)Initialize the LPTIM HAL using HAL_LPTIM_Init(). This function
<>	144:ef7eb2e8f9f7	32	configures mainly:
<>	144:ef7eb2e8f9f7	33	(##) The instance: LPTIM1.
<>	144:ef7eb2e8f9f7	34	(##) Clock: the counter clock.
<>	157:ff67d9f36b67	35	(+++) Source: it can be either the ULPTIM input (IN1) or one of
<>	144:ef7eb2e8f9f7	36	the internal clock; (APB, LSE, LSI or MSI).
<>	157:ff67d9f36b67	37	(+++) Prescaler: select the clock divider.
<>	144:ef7eb2e8f9f7	38	(##) UltraLowPowerClock : To be used only if the ULPTIM is selected
<>	144:ef7eb2e8f9f7	39	as counter clock source.
<>	157:ff67d9f36b67	40	(+++) Polarity: polarity of the active edge for the counter unit
<>	144:ef7eb2e8f9f7	41	if the ULPTIM input is selected.
<>	157:ff67d9f36b67	42	(+++) SampleTime: clock sampling time to configure the clock glitch
<>	144:ef7eb2e8f9f7	43	filter.
<>	144:ef7eb2e8f9f7	44	(##) Trigger: How the counter start.
<>	157:ff67d9f36b67	45	(+++) Source: trigger can be software or one of the hardware triggers.
<>	157:ff67d9f36b67	46	(+++) ActiveEdge: only for hardware trigger.
<>	157:ff67d9f36b67	47	(+++) SampleTime: trigger sampling time to configure the trigger
<>	144:ef7eb2e8f9f7	48	glitch filter.
<>	157:ff67d9f36b67	49	(##) OutputPolarity: 2 opposite polarities are possibles.
<>	144:ef7eb2e8f9f7	50	(##) UpdateMode: specifies whether the update of the autoreload and
<>	144:ef7eb2e8f9f7	51	the compare values is done immediately or after the end of current
<>	144:ef7eb2e8f9f7	52	period.
<>	144:ef7eb2e8f9f7	53
<>	144:ef7eb2e8f9f7	54	(#)Six modes are available:
<>	144:ef7eb2e8f9f7	55
<>	144:ef7eb2e8f9f7	56	(##) PWM Mode: To generate a PWM signal with specified period and pulse,
<>	144:ef7eb2e8f9f7	57	call HAL_LPTIM_PWM_Start() or HAL_LPTIM_PWM_Start_IT() for interruption
<>	144:ef7eb2e8f9f7	58	mode.
<>	144:ef7eb2e8f9f7	59
<>	144:ef7eb2e8f9f7	60	(##) One Pulse Mode: To generate pulse with specified width in response
<>	144:ef7eb2e8f9f7	61	to a stimulus, call HAL_LPTIM_OnePulse_Start() or
<>	144:ef7eb2e8f9f7	62	HAL_LPTIM_OnePulse_Start_IT() for interruption mode.
<>	144:ef7eb2e8f9f7	63
<>	144:ef7eb2e8f9f7	64	(##) Set once Mode: In this mode, the output changes the level (from
<>	144:ef7eb2e8f9f7	65	low level to high level if the output polarity is configured high, else
<>	144:ef7eb2e8f9f7	66	the opposite) when a compare match occurs. To start this mode, call
<>	144:ef7eb2e8f9f7	67	HAL_LPTIM_SetOnce_Start() or HAL_LPTIM_SetOnce_Start_IT() for
<>	144:ef7eb2e8f9f7	68	interruption mode.
<>	144:ef7eb2e8f9f7	69
<>	144:ef7eb2e8f9f7	70	(##) Encoder Mode: To use the encoder interface call
<>	144:ef7eb2e8f9f7	71	HAL_LPTIM_Encoder_Start() or HAL_LPTIM_Encoder_Start_IT() for
<>	144:ef7eb2e8f9f7	72	interruption mode.
<>	144:ef7eb2e8f9f7	73
<>	144:ef7eb2e8f9f7	74	(##) Time out Mode: an active edge on one selected trigger input rests
<>	144:ef7eb2e8f9f7	75	the counter. The first trigger event will start the timer, any
<>	144:ef7eb2e8f9f7	76	successive trigger event will reset the counter and the timer will
<>	144:ef7eb2e8f9f7	77	restart. To start this mode call HAL_LPTIM_TimeOut_Start_IT() or
<>	144:ef7eb2e8f9f7	78	HAL_LPTIM_TimeOut_Start_IT() for interruption mode.
<>	144:ef7eb2e8f9f7	79
<>	144:ef7eb2e8f9f7	80	(##) Counter Mode: counter can be used to count external events on
<>	144:ef7eb2e8f9f7	81	the LPTIM Input1 or it can be used to count internal clock cycles.
<>	144:ef7eb2e8f9f7	82	To start this mode, call HAL_LPTIM_Counter_Start() or
<>	144:ef7eb2e8f9f7	83	HAL_LPTIM_Counter_Start_IT() for interruption mode.
<>	144:ef7eb2e8f9f7	84
<>	144:ef7eb2e8f9f7	85
<>	144:ef7eb2e8f9f7	86	(#) User can stop any process by calling the corresponding API:
<>	144:ef7eb2e8f9f7	87	HAL_LPTIM_Xxx_Stop() or HAL_LPTIM_Xxx_Stop_IT() if the process is
<>	144:ef7eb2e8f9f7	88	already started in interruption mode.
<>	144:ef7eb2e8f9f7	89
<>	157:ff67d9f36b67	90	(#) Call HAL_LPTIM_DeInit() to deinitialize the LPTIM peripheral.
<>	144:ef7eb2e8f9f7	91
<>	144:ef7eb2e8f9f7	92	@endverbatim
<>	144:ef7eb2e8f9f7	93	******************************************************************************
<>	144:ef7eb2e8f9f7	94	* @attention
<>	144:ef7eb2e8f9f7	95	*
<>	144:ef7eb2e8f9f7	96	* <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
<>	144:ef7eb2e8f9f7	97	*
<>	144:ef7eb2e8f9f7	98	* Redistribution and use in source and binary forms, with or without modification,
<>	144:ef7eb2e8f9f7	99	* are permitted provided that the following conditions are met:
<>	144:ef7eb2e8f9f7	100	* 1. Redistributions of source code must retain the above copyright notice,
<>	144:ef7eb2e8f9f7	101	* this list of conditions and the following disclaimer.
<>	144:ef7eb2e8f9f7	102	* 2. Redistributions in binary form must reproduce the above copyright notice,
<>	144:ef7eb2e8f9f7	103	* this list of conditions and the following disclaimer in the documentation
<>	144:ef7eb2e8f9f7	104	* and/or other materials provided with the distribution.
<>	144:ef7eb2e8f9f7	105	* 3. Neither the name of STMicroelectronics nor the names of its contributors
<>	144:ef7eb2e8f9f7	106	* may be used to endorse or promote products derived from this software
<>	144:ef7eb2e8f9f7	107	* without specific prior written permission.
<>	144:ef7eb2e8f9f7	108	*
<>	144:ef7eb2e8f9f7	109	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<>	144:ef7eb2e8f9f7	110	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<>	144:ef7eb2e8f9f7	111	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<>	144:ef7eb2e8f9f7	112	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<>	144:ef7eb2e8f9f7	113	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<>	144:ef7eb2e8f9f7	114	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<>	144:ef7eb2e8f9f7	115	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<>	144:ef7eb2e8f9f7	116	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<>	144:ef7eb2e8f9f7	117	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<>	144:ef7eb2e8f9f7	118	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<>	144:ef7eb2e8f9f7	119	*
<>	144:ef7eb2e8f9f7	120	******************************************************************************
<>	144:ef7eb2e8f9f7	121	*/
<>	144:ef7eb2e8f9f7	122
<>	144:ef7eb2e8f9f7	123	/* Includes ------------------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	124	#include "stm32f7xx_hal.h"
<>	144:ef7eb2e8f9f7	125
<>	144:ef7eb2e8f9f7	126	/** @addtogroup STM32F7xx_HAL_Driver
<>	144:ef7eb2e8f9f7	127	* @{
<>	144:ef7eb2e8f9f7	128	*/
<>	144:ef7eb2e8f9f7	129
<>	144:ef7eb2e8f9f7	130	/** @defgroup LPTIM LPTIM
<>	144:ef7eb2e8f9f7	131	* @brief LPTIM HAL module driver.
<>	144:ef7eb2e8f9f7	132	* @{
<>	144:ef7eb2e8f9f7	133	*/
<>	144:ef7eb2e8f9f7	134
<>	144:ef7eb2e8f9f7	135	#ifdef HAL_LPTIM_MODULE_ENABLED
<>	144:ef7eb2e8f9f7	136	/* Private types -------------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	137	/** @defgroup LPTIM_Private_Types LPTIM Private Types
<>	144:ef7eb2e8f9f7	138	* @{
<>	144:ef7eb2e8f9f7	139	*/
<>	144:ef7eb2e8f9f7	140
<>	144:ef7eb2e8f9f7	141	/**
<>	144:ef7eb2e8f9f7	142	* @}
<>	144:ef7eb2e8f9f7	143	*/
<>	144:ef7eb2e8f9f7	144
<>	144:ef7eb2e8f9f7	145	/* Private defines -----------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	146	/** @defgroup LPTIM_Private_Defines LPTIM Private Defines
<>	144:ef7eb2e8f9f7	147	* @{
<>	144:ef7eb2e8f9f7	148	*/
<>	144:ef7eb2e8f9f7	149
<>	144:ef7eb2e8f9f7	150	/**
<>	144:ef7eb2e8f9f7	151	* @}
<>	144:ef7eb2e8f9f7	152	*/
<>	144:ef7eb2e8f9f7	153
<>	144:ef7eb2e8f9f7	154	/* Private variables ---------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	155	/** @addtogroup LPTIM_Private_Variables LPTIM Private Variables
<>	144:ef7eb2e8f9f7	156	* @{
<>	144:ef7eb2e8f9f7	157	*/
<>	144:ef7eb2e8f9f7	158
<>	144:ef7eb2e8f9f7	159	/**
<>	144:ef7eb2e8f9f7	160	* @}
<>	144:ef7eb2e8f9f7	161	*/
<>	144:ef7eb2e8f9f7	162
<>	144:ef7eb2e8f9f7	163	/* Private constants ---------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	164	/** @addtogroup LPTIM_Private_Constants LPTIM Private Constants
<>	144:ef7eb2e8f9f7	165	* @{
<>	144:ef7eb2e8f9f7	166	*/
<>	144:ef7eb2e8f9f7	167
<>	144:ef7eb2e8f9f7	168	/**
<>	144:ef7eb2e8f9f7	169	* @}
<>	144:ef7eb2e8f9f7	170	*/
<>	144:ef7eb2e8f9f7	171
<>	144:ef7eb2e8f9f7	172	/* Private macros ------------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	173	/** @addtogroup LPTIM_Private_Macros LPTIM Private Macros
<>	144:ef7eb2e8f9f7	174	* @{
<>	144:ef7eb2e8f9f7	175	*/
<>	144:ef7eb2e8f9f7	176
<>	144:ef7eb2e8f9f7	177	/**
<>	144:ef7eb2e8f9f7	178	* @}
<>	144:ef7eb2e8f9f7	179	*/
<>	144:ef7eb2e8f9f7	180
<>	144:ef7eb2e8f9f7	181	/* Private function prototypes -----------------------------------------------*/
<>	144:ef7eb2e8f9f7	182	/** @addtogroup LPTIM_Private_Functions_Prototypes LPTIM Private Functions Prototypes
<>	144:ef7eb2e8f9f7	183	* @{
<>	144:ef7eb2e8f9f7	184	*/
<>	144:ef7eb2e8f9f7	185
<>	144:ef7eb2e8f9f7	186	/**
<>	144:ef7eb2e8f9f7	187	* @}
<>	144:ef7eb2e8f9f7	188	*/
<>	144:ef7eb2e8f9f7	189
<>	144:ef7eb2e8f9f7	190	/* Private functions ---------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	191	/** @addtogroup LPTIM_Private_Functions LPTIM Private Functions
<>	144:ef7eb2e8f9f7	192	* @{
<>	144:ef7eb2e8f9f7	193	*/
<>	144:ef7eb2e8f9f7	194
<>	144:ef7eb2e8f9f7	195	/**
<>	144:ef7eb2e8f9f7	196	* @}
<>	144:ef7eb2e8f9f7	197	*/
<>	144:ef7eb2e8f9f7	198
<>	144:ef7eb2e8f9f7	199	/* Exported functions ---------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	200	/** @defgroup LPTIM_Exported_Functions LPTIM Exported Functions
<>	144:ef7eb2e8f9f7	201	* @{
<>	144:ef7eb2e8f9f7	202	*/
<>	144:ef7eb2e8f9f7	203
<>	144:ef7eb2e8f9f7	204	/** @defgroup LPTIM_Group1 Initialization/de-initialization functions
<>	144:ef7eb2e8f9f7	205	* @brief Initialization and Configuration functions.
<>	144:ef7eb2e8f9f7	206	*
<>	144:ef7eb2e8f9f7	207	@verbatim
<>	144:ef7eb2e8f9f7	208	==============================================================================
<>	144:ef7eb2e8f9f7	209	##### Initialization and de-initialization functions #####
<>	144:ef7eb2e8f9f7	210	==============================================================================
<>	144:ef7eb2e8f9f7	211	[..] This section provides functions allowing to:
<>	144:ef7eb2e8f9f7	212	(+) Initialize the LPTIM according to the specified parameters in the
<>	144:ef7eb2e8f9f7	213	LPTIM_InitTypeDef and creates the associated handle.
<>	144:ef7eb2e8f9f7	214	(+) DeInitialize the LPTIM peripheral.
<>	144:ef7eb2e8f9f7	215	(+) Initialize the LPTIM MSP.
<>	144:ef7eb2e8f9f7	216	(+) DeInitialize LPTIM MSP.
<>	144:ef7eb2e8f9f7	217
<>	144:ef7eb2e8f9f7	218	@endverbatim
<>	144:ef7eb2e8f9f7	219	* @{
<>	144:ef7eb2e8f9f7	220	*/
<>	144:ef7eb2e8f9f7	221
<>	144:ef7eb2e8f9f7	222	/**
<>	144:ef7eb2e8f9f7	223	* @brief Initializes the LPTIM according to the specified parameters in the
<>	144:ef7eb2e8f9f7	224	* LPTIM_InitTypeDef and creates the associated handle.
<>	144:ef7eb2e8f9f7	225	* @param hlptim: LPTIM handle
<>	144:ef7eb2e8f9f7	226	* @retval HAL status
<>	144:ef7eb2e8f9f7	227	*/
<>	144:ef7eb2e8f9f7	228	HAL_StatusTypeDef HAL_LPTIM_Init(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	229	{
<>	144:ef7eb2e8f9f7	230	uint32_t tmpcfgr = 0;
<>	144:ef7eb2e8f9f7	231
<>	144:ef7eb2e8f9f7	232	/* Check the LPTIM handle allocation */
<>	144:ef7eb2e8f9f7	233	if(hlptim == NULL)
<>	144:ef7eb2e8f9f7	234	{
<>	144:ef7eb2e8f9f7	235	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	236	}
<>	144:ef7eb2e8f9f7	237
<>	144:ef7eb2e8f9f7	238	/* Check the parameters */
<>	144:ef7eb2e8f9f7	239	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	240
<>	144:ef7eb2e8f9f7	241	assert_param(IS_LPTIM_CLOCK_SOURCE(hlptim->Init.Clock.Source));
<>	144:ef7eb2e8f9f7	242	assert_param(IS_LPTIM_CLOCK_PRESCALER(hlptim->Init.Clock.Prescaler));
<>	144:ef7eb2e8f9f7	243	if ((hlptim->Init.Clock.Source) == LPTIM_CLOCKSOURCE_ULPTIM)
<>	144:ef7eb2e8f9f7	244	{
<>	144:ef7eb2e8f9f7	245	assert_param(IS_LPTIM_CLOCK_POLARITY(hlptim->Init.UltraLowPowerClock.Polarity));
<>	144:ef7eb2e8f9f7	246	assert_param(IS_LPTIM_CLOCK_SAMPLE_TIME(hlptim->Init.UltraLowPowerClock.SampleTime));
<>	144:ef7eb2e8f9f7	247	}
<>	144:ef7eb2e8f9f7	248	assert_param(IS_LPTIM_TRG_SOURCE(hlptim->Init.Trigger.Source));
<>	144:ef7eb2e8f9f7	249	if ((hlptim->Init.Trigger.Source) != LPTIM_TRIGSOURCE_SOFTWARE)
<>	144:ef7eb2e8f9f7	250	{
<>	144:ef7eb2e8f9f7	251	assert_param(IS_LPTIM_TRIG_SAMPLE_TIME(hlptim->Init.Trigger.SampleTime));
<>	144:ef7eb2e8f9f7	252	assert_param(IS_LPTIM_EXT_TRG_POLARITY(hlptim->Init.Trigger.ActiveEdge));
<>	144:ef7eb2e8f9f7	253	}
<>	144:ef7eb2e8f9f7	254	assert_param(IS_LPTIM_OUTPUT_POLARITY(hlptim->Init.OutputPolarity));
<>	144:ef7eb2e8f9f7	255	assert_param(IS_LPTIM_UPDATE_MODE(hlptim->Init.UpdateMode));
<>	144:ef7eb2e8f9f7	256	assert_param(IS_LPTIM_COUNTER_SOURCE(hlptim->Init.CounterSource));
<>	144:ef7eb2e8f9f7	257
<>	144:ef7eb2e8f9f7	258	if(hlptim->State == HAL_LPTIM_STATE_RESET)
<>	144:ef7eb2e8f9f7	259	{
<>	144:ef7eb2e8f9f7	260	/* Allocate lock resource and initialize it */
<>	144:ef7eb2e8f9f7	261	hlptim->Lock = HAL_UNLOCKED;
<>	144:ef7eb2e8f9f7	262	/* Init the low level hardware */
<>	144:ef7eb2e8f9f7	263	HAL_LPTIM_MspInit(hlptim);
<>	144:ef7eb2e8f9f7	264	}
<>	144:ef7eb2e8f9f7	265
<>	144:ef7eb2e8f9f7	266	/* Change the LPTIM state */
<>	144:ef7eb2e8f9f7	267	hlptim->State = HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	268
<>	144:ef7eb2e8f9f7	269	/* Get the LPTIMx CFGR value */
<>	144:ef7eb2e8f9f7	270	tmpcfgr = hlptim->Instance->CFGR;
<>	144:ef7eb2e8f9f7	271
<>	144:ef7eb2e8f9f7	272	if ((hlptim->Init.Clock.Source) == LPTIM_CLOCKSOURCE_ULPTIM)
<>	144:ef7eb2e8f9f7	273	{
<>	144:ef7eb2e8f9f7	274	tmpcfgr &= (uint32_t)(~(LPTIM_CFGR_CKPOL \| LPTIM_CFGR_CKFLT));
<>	144:ef7eb2e8f9f7	275	}
<>	144:ef7eb2e8f9f7	276	if ((hlptim->Init.Trigger.Source) != LPTIM_TRIGSOURCE_SOFTWARE)
<>	144:ef7eb2e8f9f7	277	{
<>	144:ef7eb2e8f9f7	278	tmpcfgr &= (uint32_t)(~ (LPTIM_CFGR_TRGFLT \| LPTIM_CFGR_TRIGSEL));
<>	144:ef7eb2e8f9f7	279	}
<>	144:ef7eb2e8f9f7	280
<>	144:ef7eb2e8f9f7	281	/* Clear CKSEL, PRESC, TRIGEN, TRGFLT, WAVPOL, PRELOAD & COUNTMODE bits */
<>	144:ef7eb2e8f9f7	282	tmpcfgr &= (uint32_t)(~(LPTIM_CFGR_CKSEL \| LPTIM_CFGR_TRIGEN \| LPTIM_CFGR_PRELOAD \|
<>	144:ef7eb2e8f9f7	283	LPTIM_CFGR_WAVPOL \| LPTIM_CFGR_PRESC \| LPTIM_CFGR_COUNTMODE ));
<>	144:ef7eb2e8f9f7	284
<>	144:ef7eb2e8f9f7	285	/* Set initialization parameters */
<>	144:ef7eb2e8f9f7	286	tmpcfgr \|= (hlptim->Init.Clock.Source \|
<>	144:ef7eb2e8f9f7	287	hlptim->Init.Clock.Prescaler \|
<>	144:ef7eb2e8f9f7	288	hlptim->Init.OutputPolarity \|
<>	144:ef7eb2e8f9f7	289	hlptim->Init.UpdateMode \|
<>	144:ef7eb2e8f9f7	290	hlptim->Init.CounterSource);
<>	144:ef7eb2e8f9f7	291
<>	144:ef7eb2e8f9f7	292	if ((hlptim->Init.Clock.Source) == LPTIM_CLOCKSOURCE_ULPTIM)
<>	144:ef7eb2e8f9f7	293	{
<>	144:ef7eb2e8f9f7	294	tmpcfgr \|= (hlptim->Init.UltraLowPowerClock.Polarity \|
<>	144:ef7eb2e8f9f7	295	hlptim->Init.UltraLowPowerClock.SampleTime);
<>	144:ef7eb2e8f9f7	296	}
<>	144:ef7eb2e8f9f7	297
<>	144:ef7eb2e8f9f7	298	if ((hlptim->Init.Trigger.Source) != LPTIM_TRIGSOURCE_SOFTWARE)
<>	144:ef7eb2e8f9f7	299	{
<>	144:ef7eb2e8f9f7	300	/* Enable External trigger and set the trigger source */
<>	144:ef7eb2e8f9f7	301	tmpcfgr \|= (hlptim->Init.Trigger.Source \|
<>	144:ef7eb2e8f9f7	302	hlptim->Init.Trigger.ActiveEdge \|
<>	144:ef7eb2e8f9f7	303	hlptim->Init.Trigger.SampleTime);
<>	144:ef7eb2e8f9f7	304	}
<>	144:ef7eb2e8f9f7	305
<>	144:ef7eb2e8f9f7	306	/* Write to LPTIMx CFGR */
<>	144:ef7eb2e8f9f7	307	hlptim->Instance->CFGR = tmpcfgr;
<>	144:ef7eb2e8f9f7	308
<>	144:ef7eb2e8f9f7	309	/* Change the LPTIM state */
<>	144:ef7eb2e8f9f7	310	hlptim->State = HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	311
<>	144:ef7eb2e8f9f7	312	/* Return function status */
<>	144:ef7eb2e8f9f7	313	return HAL_OK;
<>	144:ef7eb2e8f9f7	314	}
<>	144:ef7eb2e8f9f7	315
<>	144:ef7eb2e8f9f7	316	/**
<>	144:ef7eb2e8f9f7	317	* @brief DeInitializes the LPTIM peripheral.
<>	144:ef7eb2e8f9f7	318	* @param hlptim: LPTIM handle
<>	144:ef7eb2e8f9f7	319	* @retval HAL status
<>	144:ef7eb2e8f9f7	320	*/
<>	144:ef7eb2e8f9f7	321	HAL_StatusTypeDef HAL_LPTIM_DeInit(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	322	{
<>	144:ef7eb2e8f9f7	323	/* Check the LPTIM handle allocation */
<>	144:ef7eb2e8f9f7	324	if(hlptim == NULL)
<>	144:ef7eb2e8f9f7	325	{
<>	144:ef7eb2e8f9f7	326	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	327	}
<>	144:ef7eb2e8f9f7	328
<>	144:ef7eb2e8f9f7	329	/* Change the LPTIM state */
<>	144:ef7eb2e8f9f7	330	hlptim->State = HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	331
<>	144:ef7eb2e8f9f7	332	/* Disable the LPTIM Peripheral Clock */
<>	144:ef7eb2e8f9f7	333	__HAL_LPTIM_DISABLE(hlptim);
<>	144:ef7eb2e8f9f7	334
<>	144:ef7eb2e8f9f7	335	/* DeInit the low level hardware: CLOCK, NVIC.*/
<>	144:ef7eb2e8f9f7	336	HAL_LPTIM_MspDeInit(hlptim);
<>	144:ef7eb2e8f9f7	337
<>	144:ef7eb2e8f9f7	338	/* Change the LPTIM state */
<>	144:ef7eb2e8f9f7	339	hlptim->State = HAL_LPTIM_STATE_RESET;
<>	144:ef7eb2e8f9f7	340
<>	144:ef7eb2e8f9f7	341	/* Release Lock */
<>	144:ef7eb2e8f9f7	342	__HAL_UNLOCK(hlptim);
<>	144:ef7eb2e8f9f7	343
<>	144:ef7eb2e8f9f7	344	/* Return function status */
<>	144:ef7eb2e8f9f7	345	return HAL_OK;
<>	144:ef7eb2e8f9f7	346	}
<>	144:ef7eb2e8f9f7	347
<>	144:ef7eb2e8f9f7	348	/**
<>	144:ef7eb2e8f9f7	349	* @brief Initializes the LPTIM MSP.
<>	144:ef7eb2e8f9f7	350	* @param hlptim: LPTIM handle
<>	144:ef7eb2e8f9f7	351	* @retval None
<>	144:ef7eb2e8f9f7	352	*/
<>	144:ef7eb2e8f9f7	353	__weak void HAL_LPTIM_MspInit(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	354	{
<>	144:ef7eb2e8f9f7	355	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	356	UNUSED(hlptim);
<>	144:ef7eb2e8f9f7	357
<>	144:ef7eb2e8f9f7	358	/* NOTE : This function Should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	359	the HAL_LPTIM_MspInit could be implemented in the user file
<>	144:ef7eb2e8f9f7	360	*/
<>	144:ef7eb2e8f9f7	361	}
<>	144:ef7eb2e8f9f7	362
<>	144:ef7eb2e8f9f7	363	/**
<>	144:ef7eb2e8f9f7	364	* @brief DeInitializes LPTIM MSP.
<>	144:ef7eb2e8f9f7	365	* @param hlptim: LPTIM handle
<>	144:ef7eb2e8f9f7	366	* @retval None
<>	144:ef7eb2e8f9f7	367	*/
<>	144:ef7eb2e8f9f7	368	__weak void HAL_LPTIM_MspDeInit(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	369	{
<>	144:ef7eb2e8f9f7	370	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	371	UNUSED(hlptim);
<>	144:ef7eb2e8f9f7	372
<>	144:ef7eb2e8f9f7	373	/* NOTE : This function Should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	374	the HAL_LPTIM_MspDeInit could be implemented in the user file
<>	144:ef7eb2e8f9f7	375	*/
<>	144:ef7eb2e8f9f7	376	}
<>	144:ef7eb2e8f9f7	377
<>	144:ef7eb2e8f9f7	378	/**
<>	144:ef7eb2e8f9f7	379	* @}
<>	144:ef7eb2e8f9f7	380	*/
<>	144:ef7eb2e8f9f7	381
<>	144:ef7eb2e8f9f7	382	/** @defgroup LPTIM_Group2 LPTIM Start-Stop operation functions
<>	144:ef7eb2e8f9f7	383	* @brief Start-Stop operation functions.
<>	144:ef7eb2e8f9f7	384	*
<>	144:ef7eb2e8f9f7	385	@verbatim
<>	144:ef7eb2e8f9f7	386	==============================================================================
<>	144:ef7eb2e8f9f7	387	##### LPTIM Start Stop operation functions #####
<>	144:ef7eb2e8f9f7	388	==============================================================================
<>	144:ef7eb2e8f9f7	389	[..] This section provides functions allowing to:
<>	144:ef7eb2e8f9f7	390	(+) Start the PWM mode.
<>	144:ef7eb2e8f9f7	391	(+) Stop the PWM mode.
<>	144:ef7eb2e8f9f7	392	(+) Start the One pulse mode.
<>	144:ef7eb2e8f9f7	393	(+) Stop the One pulse mode.
<>	144:ef7eb2e8f9f7	394	(+) Start the Set once mode.
<>	144:ef7eb2e8f9f7	395	(+) Stop the Set once mode.
<>	144:ef7eb2e8f9f7	396	(+) Start the Encoder mode.
<>	144:ef7eb2e8f9f7	397	(+) Stop the Encoder mode.
<>	144:ef7eb2e8f9f7	398	(+) Start the Timeout mode.
<>	144:ef7eb2e8f9f7	399	(+) Stop the Timeout mode.
<>	144:ef7eb2e8f9f7	400	(+) Start the Counter mode.
<>	144:ef7eb2e8f9f7	401	(+) Stop the Counter mode.
<>	144:ef7eb2e8f9f7	402
<>	144:ef7eb2e8f9f7	403
<>	144:ef7eb2e8f9f7	404	@endverbatim
<>	144:ef7eb2e8f9f7	405	* @{
<>	144:ef7eb2e8f9f7	406	*/
<>	144:ef7eb2e8f9f7	407
<>	144:ef7eb2e8f9f7	408	/**
<>	144:ef7eb2e8f9f7	409	* @brief Starts the LPTIM PWM generation.
<>	144:ef7eb2e8f9f7	410	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	411	* @param Period : Specifies the Autoreload value.
<>	144:ef7eb2e8f9f7	412	* This parameter must be a value between 0x0000 and 0xFFFF.
<>	144:ef7eb2e8f9f7	413	* @param Pulse : Specifies the compare value.
<>	144:ef7eb2e8f9f7	414	* This parameter must be a value between 0x0000 and 0xFFFF.
<>	144:ef7eb2e8f9f7	415	* @retval HAL status
<>	144:ef7eb2e8f9f7	416	*/
<>	144:ef7eb2e8f9f7	417	HAL_StatusTypeDef HAL_LPTIM_PWM_Start(LPTIM_HandleTypeDef *hlptim, uint32_t Period, uint32_t Pulse)
<>	144:ef7eb2e8f9f7	418	{
<>	144:ef7eb2e8f9f7	419	/* Check the parameters */
<>	144:ef7eb2e8f9f7	420	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	421	assert_param(IS_LPTIM_PERIOD(Period));
<>	144:ef7eb2e8f9f7	422	assert_param(IS_LPTIM_PULSE(Pulse));
<>	144:ef7eb2e8f9f7	423
<>	144:ef7eb2e8f9f7	424	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	425	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	426
<>	144:ef7eb2e8f9f7	427	/* Reset WAVE bit to set PWM mode */
<>	144:ef7eb2e8f9f7	428	hlptim->Instance->CFGR &= ~LPTIM_CFGR_WAVE;
<>	144:ef7eb2e8f9f7	429
<>	144:ef7eb2e8f9f7	430	/* Enable the Peripheral */
<>	144:ef7eb2e8f9f7	431	__HAL_LPTIM_ENABLE(hlptim);
<>	144:ef7eb2e8f9f7	432
<>	144:ef7eb2e8f9f7	433	/* Load the period value in the autoreload register */
<>	144:ef7eb2e8f9f7	434	__HAL_LPTIM_AUTORELOAD_SET(hlptim, Period);
<>	144:ef7eb2e8f9f7	435
<>	144:ef7eb2e8f9f7	436	/* Load the pulse value in the compare register */
<>	144:ef7eb2e8f9f7	437	__HAL_LPTIM_COMPARE_SET(hlptim, Pulse);
<>	144:ef7eb2e8f9f7	438
<>	144:ef7eb2e8f9f7	439	/* Start timer in continuous mode */
<>	144:ef7eb2e8f9f7	440	__HAL_LPTIM_START_CONTINUOUS(hlptim);
<>	144:ef7eb2e8f9f7	441
<>	144:ef7eb2e8f9f7	442	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	443	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	444
<>	144:ef7eb2e8f9f7	445	/* Return function status */
<>	144:ef7eb2e8f9f7	446	return HAL_OK;
<>	144:ef7eb2e8f9f7	447	}
<>	144:ef7eb2e8f9f7	448
<>	144:ef7eb2e8f9f7	449	/**
<>	144:ef7eb2e8f9f7	450	* @brief Stops the LPTIM PWM generation.
<>	144:ef7eb2e8f9f7	451	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	452	* @retval HAL status
<>	144:ef7eb2e8f9f7	453	*/
<>	144:ef7eb2e8f9f7	454	HAL_StatusTypeDef HAL_LPTIM_PWM_Stop(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	455	{
<>	144:ef7eb2e8f9f7	456	/* Check the parameters */
<>	144:ef7eb2e8f9f7	457	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	458
<>	144:ef7eb2e8f9f7	459	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	460	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	461
<>	144:ef7eb2e8f9f7	462	/* Disable the Peripheral */
<>	144:ef7eb2e8f9f7	463	__HAL_LPTIM_DISABLE(hlptim);
<>	144:ef7eb2e8f9f7	464
<>	144:ef7eb2e8f9f7	465	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	466	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	467
<>	144:ef7eb2e8f9f7	468	/* Return function status */
<>	144:ef7eb2e8f9f7	469	return HAL_OK;
<>	144:ef7eb2e8f9f7	470	}
<>	144:ef7eb2e8f9f7	471
<>	144:ef7eb2e8f9f7	472	/**
<>	144:ef7eb2e8f9f7	473	* @brief Starts the LPTIM PWM generation in interrupt mode.
<>	144:ef7eb2e8f9f7	474	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	475	* @param Period : Specifies the Autoreload value.
<>	144:ef7eb2e8f9f7	476	* This parameter must be a value between 0x0000 and 0xFFFF
<>	144:ef7eb2e8f9f7	477	* @param Pulse : Specifies the compare value.
<>	144:ef7eb2e8f9f7	478	* This parameter must be a value between 0x0000 and 0xFFFF
<>	144:ef7eb2e8f9f7	479	* @retval HAL status
<>	144:ef7eb2e8f9f7	480	*/
<>	144:ef7eb2e8f9f7	481	HAL_StatusTypeDef HAL_LPTIM_PWM_Start_IT(LPTIM_HandleTypeDef *hlptim, uint32_t Period, uint32_t Pulse)
<>	144:ef7eb2e8f9f7	482	{
<>	144:ef7eb2e8f9f7	483	/* Check the parameters */
<>	144:ef7eb2e8f9f7	484	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	485	assert_param(IS_LPTIM_PERIOD(Period));
<>	144:ef7eb2e8f9f7	486	assert_param(IS_LPTIM_PULSE(Pulse));
<>	144:ef7eb2e8f9f7	487
<>	144:ef7eb2e8f9f7	488	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	489	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	490
<>	144:ef7eb2e8f9f7	491	/* Reset WAVE bit to set PWM mode */
<>	144:ef7eb2e8f9f7	492	hlptim->Instance->CFGR &= ~LPTIM_CFGR_WAVE;
<>	144:ef7eb2e8f9f7	493
<>	144:ef7eb2e8f9f7	494	/* Enable Autoreload write complete interrupt */
<>	144:ef7eb2e8f9f7	495	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_ARROK);
<>	144:ef7eb2e8f9f7	496
<>	144:ef7eb2e8f9f7	497	/* Enable Compare write complete interrupt */
<>	144:ef7eb2e8f9f7	498	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_CMPOK);
<>	144:ef7eb2e8f9f7	499
<>	144:ef7eb2e8f9f7	500	/* Enable Autoreload match interrupt */
<>	144:ef7eb2e8f9f7	501	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_ARRM);
<>	144:ef7eb2e8f9f7	502
<>	144:ef7eb2e8f9f7	503	/* Enable Compare match interrupt */
<>	144:ef7eb2e8f9f7	504	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_CMPM);
<>	144:ef7eb2e8f9f7	505
<>	144:ef7eb2e8f9f7	506	/* If external trigger source is used, then enable external trigger interrupt */
<>	144:ef7eb2e8f9f7	507	if ((hlptim->Init.Trigger.Source) != LPTIM_TRIGSOURCE_SOFTWARE)
<>	144:ef7eb2e8f9f7	508	{
<>	144:ef7eb2e8f9f7	509	/* Enable external trigger interrupt */
<>	144:ef7eb2e8f9f7	510	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_EXTTRIG);
<>	144:ef7eb2e8f9f7	511	}
<>	144:ef7eb2e8f9f7	512
<>	144:ef7eb2e8f9f7	513	/* Enable the Peripheral */
<>	144:ef7eb2e8f9f7	514	__HAL_LPTIM_ENABLE(hlptim);
<>	144:ef7eb2e8f9f7	515
<>	144:ef7eb2e8f9f7	516	/* Load the period value in the autoreload register */
<>	144:ef7eb2e8f9f7	517	__HAL_LPTIM_AUTORELOAD_SET(hlptim, Period);
<>	144:ef7eb2e8f9f7	518
<>	144:ef7eb2e8f9f7	519	/* Load the pulse value in the compare register */
<>	144:ef7eb2e8f9f7	520	__HAL_LPTIM_COMPARE_SET(hlptim, Pulse);
<>	144:ef7eb2e8f9f7	521
<>	144:ef7eb2e8f9f7	522	/* Start timer in continuous mode */
<>	144:ef7eb2e8f9f7	523	__HAL_LPTIM_START_CONTINUOUS(hlptim);
<>	144:ef7eb2e8f9f7	524
<>	144:ef7eb2e8f9f7	525	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	526	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	527
<>	144:ef7eb2e8f9f7	528	/* Return function status */
<>	144:ef7eb2e8f9f7	529	return HAL_OK;
<>	144:ef7eb2e8f9f7	530	}
<>	144:ef7eb2e8f9f7	531
<>	144:ef7eb2e8f9f7	532	/**
<>	144:ef7eb2e8f9f7	533	* @brief Stops the LPTIM PWM generation in interrupt mode.
<>	144:ef7eb2e8f9f7	534	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	535	* @retval HAL status
<>	144:ef7eb2e8f9f7	536	*/
<>	144:ef7eb2e8f9f7	537	HAL_StatusTypeDef HAL_LPTIM_PWM_Stop_IT(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	538	{
<>	144:ef7eb2e8f9f7	539	/* Check the parameters */
<>	144:ef7eb2e8f9f7	540	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	541
<>	144:ef7eb2e8f9f7	542	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	543	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	544
<>	144:ef7eb2e8f9f7	545	/* Disable the Peripheral */
<>	144:ef7eb2e8f9f7	546	__HAL_LPTIM_DISABLE(hlptim);
<>	144:ef7eb2e8f9f7	547
<>	144:ef7eb2e8f9f7	548	/* Disable Autoreload write complete interrupt */
<>	144:ef7eb2e8f9f7	549	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_ARROK);
<>	144:ef7eb2e8f9f7	550
<>	144:ef7eb2e8f9f7	551	/* Disable Compare write complete interrupt */
<>	144:ef7eb2e8f9f7	552	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_CMPOK);
<>	144:ef7eb2e8f9f7	553
<>	144:ef7eb2e8f9f7	554	/* Disable Autoreload match interrupt */
<>	144:ef7eb2e8f9f7	555	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_ARRM);
<>	144:ef7eb2e8f9f7	556
<>	144:ef7eb2e8f9f7	557	/* Disable Compare match interrupt */
<>	144:ef7eb2e8f9f7	558	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_CMPM);
<>	144:ef7eb2e8f9f7	559
<>	144:ef7eb2e8f9f7	560	/* If external trigger source is used, then disable external trigger interrupt */
<>	144:ef7eb2e8f9f7	561	if ((hlptim->Init.Trigger.Source) != LPTIM_TRIGSOURCE_SOFTWARE)
<>	144:ef7eb2e8f9f7	562	{
<>	144:ef7eb2e8f9f7	563	/* Disable external trigger interrupt */
<>	144:ef7eb2e8f9f7	564	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_EXTTRIG);
<>	144:ef7eb2e8f9f7	565	}
<>	144:ef7eb2e8f9f7	566
<>	144:ef7eb2e8f9f7	567	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	568	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	569
<>	144:ef7eb2e8f9f7	570	/* Return function status */
<>	144:ef7eb2e8f9f7	571	return HAL_OK;
<>	144:ef7eb2e8f9f7	572	}
<>	144:ef7eb2e8f9f7	573
<>	144:ef7eb2e8f9f7	574	/**
<>	144:ef7eb2e8f9f7	575	* @brief Starts the LPTIM One pulse generation.
<>	144:ef7eb2e8f9f7	576	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	577	* @param Period : Specifies the Autoreload value.
<>	144:ef7eb2e8f9f7	578	* This parameter must be a value between 0x0000 and 0xFFFF.
<>	144:ef7eb2e8f9f7	579	* @param Pulse : Specifies the compare value.
<>	144:ef7eb2e8f9f7	580	* This parameter must be a value between 0x0000 and 0xFFFF.
<>	144:ef7eb2e8f9f7	581	* @retval HAL status
<>	144:ef7eb2e8f9f7	582	*/
<>	144:ef7eb2e8f9f7	583	HAL_StatusTypeDef HAL_LPTIM_OnePulse_Start(LPTIM_HandleTypeDef *hlptim, uint32_t Period, uint32_t Pulse)
<>	144:ef7eb2e8f9f7	584	{
<>	144:ef7eb2e8f9f7	585	/* Check the parameters */
<>	144:ef7eb2e8f9f7	586	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	587	assert_param(IS_LPTIM_PERIOD(Period));
<>	144:ef7eb2e8f9f7	588	assert_param(IS_LPTIM_PULSE(Pulse));
<>	144:ef7eb2e8f9f7	589
<>	144:ef7eb2e8f9f7	590	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	591	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	592
<>	144:ef7eb2e8f9f7	593	/* Reset WAVE bit to set one pulse mode */
<>	144:ef7eb2e8f9f7	594	hlptim->Instance->CFGR &= ~LPTIM_CFGR_WAVE;
<>	144:ef7eb2e8f9f7	595
<>	144:ef7eb2e8f9f7	596	/* Enable the Peripheral */
<>	144:ef7eb2e8f9f7	597	__HAL_LPTIM_ENABLE(hlptim);
<>	144:ef7eb2e8f9f7	598
<>	144:ef7eb2e8f9f7	599	/* Load the period value in the autoreload register */
<>	144:ef7eb2e8f9f7	600	__HAL_LPTIM_AUTORELOAD_SET(hlptim, Period);
<>	144:ef7eb2e8f9f7	601
<>	144:ef7eb2e8f9f7	602	/* Load the pulse value in the compare register */
<>	144:ef7eb2e8f9f7	603	__HAL_LPTIM_COMPARE_SET(hlptim, Pulse);
<>	144:ef7eb2e8f9f7	604
<>	144:ef7eb2e8f9f7	605	/* Start timer in continuous mode */
<>	144:ef7eb2e8f9f7	606	__HAL_LPTIM_START_SINGLE(hlptim);
<>	144:ef7eb2e8f9f7	607
<>	144:ef7eb2e8f9f7	608	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	609	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	610
<>	144:ef7eb2e8f9f7	611	/* Return function status */
<>	144:ef7eb2e8f9f7	612	return HAL_OK;
<>	144:ef7eb2e8f9f7	613	}
<>	144:ef7eb2e8f9f7	614
<>	144:ef7eb2e8f9f7	615	/**
<>	144:ef7eb2e8f9f7	616	* @brief Stops the LPTIM One pulse generation.
<>	144:ef7eb2e8f9f7	617	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	618	* @retval HAL status
<>	144:ef7eb2e8f9f7	619	*/
<>	144:ef7eb2e8f9f7	620	HAL_StatusTypeDef HAL_LPTIM_OnePulse_Stop(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	621	{
<>	144:ef7eb2e8f9f7	622	/* Check the parameters */
<>	144:ef7eb2e8f9f7	623	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	624
<>	144:ef7eb2e8f9f7	625	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	626	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	627
<>	144:ef7eb2e8f9f7	628	/* Disable the Peripheral */
<>	144:ef7eb2e8f9f7	629	__HAL_LPTIM_DISABLE(hlptim);
<>	144:ef7eb2e8f9f7	630
<>	144:ef7eb2e8f9f7	631	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	632	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	633
<>	144:ef7eb2e8f9f7	634	/* Return function status */
<>	144:ef7eb2e8f9f7	635	return HAL_OK;
<>	144:ef7eb2e8f9f7	636	}
<>	144:ef7eb2e8f9f7	637
<>	144:ef7eb2e8f9f7	638	/**
<>	144:ef7eb2e8f9f7	639	* @brief Starts the LPTIM One pulse generation in interrupt mode.
<>	144:ef7eb2e8f9f7	640	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	641	* @param Period : Specifies the Autoreload value.
<>	144:ef7eb2e8f9f7	642	* This parameter must be a value between 0x0000 and 0xFFFF.
<>	144:ef7eb2e8f9f7	643	* @param Pulse : Specifies the compare value.
<>	144:ef7eb2e8f9f7	644	* This parameter must be a value between 0x0000 and 0xFFFF.
<>	144:ef7eb2e8f9f7	645	* @retval HAL status
<>	144:ef7eb2e8f9f7	646	*/
<>	144:ef7eb2e8f9f7	647	HAL_StatusTypeDef HAL_LPTIM_OnePulse_Start_IT(LPTIM_HandleTypeDef *hlptim, uint32_t Period, uint32_t Pulse)
<>	144:ef7eb2e8f9f7	648	{
<>	144:ef7eb2e8f9f7	649	/* Check the parameters */
<>	144:ef7eb2e8f9f7	650	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	651	assert_param(IS_LPTIM_PERIOD(Period));
<>	144:ef7eb2e8f9f7	652	assert_param(IS_LPTIM_PULSE(Pulse));
<>	144:ef7eb2e8f9f7	653
<>	144:ef7eb2e8f9f7	654	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	655	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	656
<>	144:ef7eb2e8f9f7	657	/* Reset WAVE bit to set one pulse mode */
<>	144:ef7eb2e8f9f7	658	hlptim->Instance->CFGR &= ~LPTIM_CFGR_WAVE;
<>	144:ef7eb2e8f9f7	659
<>	144:ef7eb2e8f9f7	660	/* Enable Autoreload write complete interrupt */
<>	144:ef7eb2e8f9f7	661	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_ARROK);
<>	144:ef7eb2e8f9f7	662
<>	144:ef7eb2e8f9f7	663	/* Enable Compare write complete interrupt */
<>	144:ef7eb2e8f9f7	664	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_CMPOK);
<>	144:ef7eb2e8f9f7	665
<>	144:ef7eb2e8f9f7	666	/* Enable Autoreload match interrupt */
<>	144:ef7eb2e8f9f7	667	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_ARRM);
<>	144:ef7eb2e8f9f7	668
<>	144:ef7eb2e8f9f7	669	/* Enable Compare match interrupt */
<>	144:ef7eb2e8f9f7	670	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_CMPM);
<>	144:ef7eb2e8f9f7	671
<>	144:ef7eb2e8f9f7	672	/* If external trigger source is used, then enable external trigger interrupt */
<>	144:ef7eb2e8f9f7	673	if ((hlptim->Init.Trigger.Source) != LPTIM_TRIGSOURCE_SOFTWARE)
<>	144:ef7eb2e8f9f7	674	{
<>	144:ef7eb2e8f9f7	675	/* Enable external trigger interrupt */
<>	144:ef7eb2e8f9f7	676	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_EXTTRIG);
<>	144:ef7eb2e8f9f7	677	}
<>	144:ef7eb2e8f9f7	678
<>	144:ef7eb2e8f9f7	679	/* Enable the Peripheral */
<>	144:ef7eb2e8f9f7	680	__HAL_LPTIM_ENABLE(hlptim);
<>	144:ef7eb2e8f9f7	681
<>	144:ef7eb2e8f9f7	682	/* Load the period value in the autoreload register */
<>	144:ef7eb2e8f9f7	683	__HAL_LPTIM_AUTORELOAD_SET(hlptim, Period);
<>	144:ef7eb2e8f9f7	684
<>	144:ef7eb2e8f9f7	685	/* Load the pulse value in the compare register */
<>	144:ef7eb2e8f9f7	686	__HAL_LPTIM_COMPARE_SET(hlptim, Pulse);
<>	144:ef7eb2e8f9f7	687
<>	144:ef7eb2e8f9f7	688	/* Start timer in continuous mode */
<>	144:ef7eb2e8f9f7	689	__HAL_LPTIM_START_SINGLE(hlptim);
<>	144:ef7eb2e8f9f7	690
<>	144:ef7eb2e8f9f7	691	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	692	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	693
<>	144:ef7eb2e8f9f7	694	/* Return function status */
<>	144:ef7eb2e8f9f7	695	return HAL_OK;
<>	144:ef7eb2e8f9f7	696	}
<>	144:ef7eb2e8f9f7	697
<>	144:ef7eb2e8f9f7	698	/**
<>	144:ef7eb2e8f9f7	699	* @brief Stops the LPTIM One pulse generation in interrupt mode.
<>	144:ef7eb2e8f9f7	700	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	701	* @retval HAL status
<>	144:ef7eb2e8f9f7	702	*/
<>	144:ef7eb2e8f9f7	703	HAL_StatusTypeDef HAL_LPTIM_OnePulse_Stop_IT(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	704	{
<>	144:ef7eb2e8f9f7	705	/* Check the parameters */
<>	144:ef7eb2e8f9f7	706	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	707
<>	144:ef7eb2e8f9f7	708	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	709	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	710
<>	144:ef7eb2e8f9f7	711	/* Disable the Peripheral */
<>	144:ef7eb2e8f9f7	712	__HAL_LPTIM_DISABLE(hlptim);
<>	144:ef7eb2e8f9f7	713
<>	144:ef7eb2e8f9f7	714	/* Disable Autoreload write complete interrupt */
<>	144:ef7eb2e8f9f7	715	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_ARROK);
<>	144:ef7eb2e8f9f7	716
<>	144:ef7eb2e8f9f7	717	/* Disable Compare write complete interrupt */
<>	144:ef7eb2e8f9f7	718	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_CMPOK);
<>	144:ef7eb2e8f9f7	719
<>	144:ef7eb2e8f9f7	720	/* Disable Autoreload match interrupt */
<>	144:ef7eb2e8f9f7	721	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_ARRM);
<>	144:ef7eb2e8f9f7	722
<>	144:ef7eb2e8f9f7	723	/* Disable Compare match interrupt */
<>	144:ef7eb2e8f9f7	724	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_CMPM);
<>	144:ef7eb2e8f9f7	725
<>	144:ef7eb2e8f9f7	726	/* If external trigger source is used, then disable external trigger interrupt */
<>	144:ef7eb2e8f9f7	727	if ((hlptim->Init.Trigger.Source) != LPTIM_TRIGSOURCE_SOFTWARE)
<>	144:ef7eb2e8f9f7	728	{
<>	144:ef7eb2e8f9f7	729	/* Disable external trigger interrupt */
<>	144:ef7eb2e8f9f7	730	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_EXTTRIG);
<>	144:ef7eb2e8f9f7	731	}
<>	144:ef7eb2e8f9f7	732
<>	144:ef7eb2e8f9f7	733	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	734	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	735
<>	144:ef7eb2e8f9f7	736	/* Return function status */
<>	144:ef7eb2e8f9f7	737	return HAL_OK;
<>	144:ef7eb2e8f9f7	738	}
<>	144:ef7eb2e8f9f7	739
<>	144:ef7eb2e8f9f7	740	/**
<>	144:ef7eb2e8f9f7	741	* @brief Starts the LPTIM in Set once mode.
<>	144:ef7eb2e8f9f7	742	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	743	* @param Period : Specifies the Autoreload value.
<>	144:ef7eb2e8f9f7	744	* This parameter must be a value between 0x0000 and 0xFFFF.
<>	144:ef7eb2e8f9f7	745	* @param Pulse : Specifies the compare value.
<>	144:ef7eb2e8f9f7	746	* This parameter must be a value between 0x0000 and 0xFFFF.
<>	144:ef7eb2e8f9f7	747	* @retval HAL status
<>	144:ef7eb2e8f9f7	748	*/
<>	144:ef7eb2e8f9f7	749	HAL_StatusTypeDef HAL_LPTIM_SetOnce_Start(LPTIM_HandleTypeDef *hlptim, uint32_t Period, uint32_t Pulse)
<>	144:ef7eb2e8f9f7	750	{
<>	144:ef7eb2e8f9f7	751	/* Check the parameters */
<>	144:ef7eb2e8f9f7	752	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	753	assert_param(IS_LPTIM_PERIOD(Period));
<>	144:ef7eb2e8f9f7	754	assert_param(IS_LPTIM_PULSE(Pulse));
<>	144:ef7eb2e8f9f7	755
<>	144:ef7eb2e8f9f7	756	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	757	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	758
<>	144:ef7eb2e8f9f7	759	/* Set WAVE bit to enable the set once mode */
<>	144:ef7eb2e8f9f7	760	hlptim->Instance->CFGR \|= LPTIM_CFGR_WAVE;
<>	144:ef7eb2e8f9f7	761
<>	144:ef7eb2e8f9f7	762	/* Enable the Peripheral */
<>	144:ef7eb2e8f9f7	763	__HAL_LPTIM_ENABLE(hlptim);
<>	144:ef7eb2e8f9f7	764
<>	144:ef7eb2e8f9f7	765	/* Load the period value in the autoreload register */
<>	144:ef7eb2e8f9f7	766	__HAL_LPTIM_AUTORELOAD_SET(hlptim, Period);
<>	144:ef7eb2e8f9f7	767
<>	144:ef7eb2e8f9f7	768	/* Load the pulse value in the compare register */
<>	144:ef7eb2e8f9f7	769	__HAL_LPTIM_COMPARE_SET(hlptim, Pulse);
<>	144:ef7eb2e8f9f7	770
<>	144:ef7eb2e8f9f7	771	/* Start timer in continuous mode */
<>	144:ef7eb2e8f9f7	772	__HAL_LPTIM_START_SINGLE(hlptim);
<>	144:ef7eb2e8f9f7	773
<>	144:ef7eb2e8f9f7	774	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	775	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	776
<>	144:ef7eb2e8f9f7	777	/* Return function status */
<>	144:ef7eb2e8f9f7	778	return HAL_OK;
<>	144:ef7eb2e8f9f7	779	}
<>	144:ef7eb2e8f9f7	780
<>	144:ef7eb2e8f9f7	781	/**
<>	144:ef7eb2e8f9f7	782	* @brief Stops the LPTIM Set once mode.
<>	144:ef7eb2e8f9f7	783	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	784	* @retval HAL status
<>	144:ef7eb2e8f9f7	785	*/
<>	144:ef7eb2e8f9f7	786	HAL_StatusTypeDef HAL_LPTIM_SetOnce_Stop(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	787	{
<>	144:ef7eb2e8f9f7	788	/* Check the parameters */
<>	144:ef7eb2e8f9f7	789	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	790
<>	144:ef7eb2e8f9f7	791	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	792	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	793
<>	144:ef7eb2e8f9f7	794	/* Disable the Peripheral */
<>	144:ef7eb2e8f9f7	795	__HAL_LPTIM_DISABLE(hlptim);
<>	144:ef7eb2e8f9f7	796
<>	144:ef7eb2e8f9f7	797	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	798	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	799
<>	144:ef7eb2e8f9f7	800	/* Return function status */
<>	144:ef7eb2e8f9f7	801	return HAL_OK;
<>	144:ef7eb2e8f9f7	802	}
<>	144:ef7eb2e8f9f7	803
<>	144:ef7eb2e8f9f7	804	/**
<>	144:ef7eb2e8f9f7	805	* @brief Starts the LPTIM Set once mode in interrupt mode.
<>	144:ef7eb2e8f9f7	806	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	807	* @param Period : Specifies the Autoreload value.
<>	144:ef7eb2e8f9f7	808	* This parameter must be a value between 0x0000 and 0xFFFF.
<>	144:ef7eb2e8f9f7	809	* @param Pulse : Specifies the compare value.
<>	144:ef7eb2e8f9f7	810	* This parameter must be a value between 0x0000 and 0xFFFF.
<>	144:ef7eb2e8f9f7	811	* @retval HAL status
<>	144:ef7eb2e8f9f7	812	*/
<>	144:ef7eb2e8f9f7	813	HAL_StatusTypeDef HAL_LPTIM_SetOnce_Start_IT(LPTIM_HandleTypeDef *hlptim, uint32_t Period, uint32_t Pulse)
<>	144:ef7eb2e8f9f7	814	{
<>	144:ef7eb2e8f9f7	815	/* Check the parameters */
<>	144:ef7eb2e8f9f7	816	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	817	assert_param(IS_LPTIM_PERIOD(Period));
<>	144:ef7eb2e8f9f7	818	assert_param(IS_LPTIM_PULSE(Pulse));
<>	144:ef7eb2e8f9f7	819
<>	144:ef7eb2e8f9f7	820	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	821	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	822
<>	144:ef7eb2e8f9f7	823	/* Set WAVE bit to enable the set once mode */
<>	144:ef7eb2e8f9f7	824	hlptim->Instance->CFGR \|= LPTIM_CFGR_WAVE;
<>	144:ef7eb2e8f9f7	825
<>	144:ef7eb2e8f9f7	826	/* Enable Autoreload write complete interrupt */
<>	144:ef7eb2e8f9f7	827	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_ARROK);
<>	144:ef7eb2e8f9f7	828
<>	144:ef7eb2e8f9f7	829	/* Enable Compare write complete interrupt */
<>	144:ef7eb2e8f9f7	830	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_CMPOK);
<>	144:ef7eb2e8f9f7	831
<>	144:ef7eb2e8f9f7	832	/* Enable Autoreload match interrupt */
<>	144:ef7eb2e8f9f7	833	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_ARRM);
<>	144:ef7eb2e8f9f7	834
<>	144:ef7eb2e8f9f7	835	/* Enable Compare match interrupt */
<>	144:ef7eb2e8f9f7	836	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_CMPM);
<>	144:ef7eb2e8f9f7	837
<>	144:ef7eb2e8f9f7	838	/* If external trigger source is used, then enable external trigger interrupt */
<>	144:ef7eb2e8f9f7	839	if ((hlptim->Init.Trigger.Source) != LPTIM_TRIGSOURCE_SOFTWARE)
<>	144:ef7eb2e8f9f7	840	{
<>	144:ef7eb2e8f9f7	841	/* Enable external trigger interrupt */
<>	144:ef7eb2e8f9f7	842	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_EXTTRIG);
<>	144:ef7eb2e8f9f7	843	}
<>	144:ef7eb2e8f9f7	844
<>	144:ef7eb2e8f9f7	845	/* Enable the Peripheral */
<>	144:ef7eb2e8f9f7	846	__HAL_LPTIM_ENABLE(hlptim);
<>	144:ef7eb2e8f9f7	847
<>	144:ef7eb2e8f9f7	848	/* Load the period value in the autoreload register */
<>	144:ef7eb2e8f9f7	849	__HAL_LPTIM_AUTORELOAD_SET(hlptim, Period);
<>	144:ef7eb2e8f9f7	850
<>	144:ef7eb2e8f9f7	851	/* Load the pulse value in the compare register */
<>	144:ef7eb2e8f9f7	852	__HAL_LPTIM_COMPARE_SET(hlptim, Pulse);
<>	144:ef7eb2e8f9f7	853
<>	144:ef7eb2e8f9f7	854	/* Start timer in continuous mode */
<>	144:ef7eb2e8f9f7	855	__HAL_LPTIM_START_SINGLE(hlptim);
<>	144:ef7eb2e8f9f7	856
<>	144:ef7eb2e8f9f7	857	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	858	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	859
<>	144:ef7eb2e8f9f7	860	/* Return function status */
<>	144:ef7eb2e8f9f7	861	return HAL_OK;
<>	144:ef7eb2e8f9f7	862	}
<>	144:ef7eb2e8f9f7	863
<>	144:ef7eb2e8f9f7	864	/**
<>	144:ef7eb2e8f9f7	865	* @brief Stops the LPTIM Set once mode in interrupt mode.
<>	144:ef7eb2e8f9f7	866	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	867	* @retval HAL status
<>	144:ef7eb2e8f9f7	868	*/
<>	144:ef7eb2e8f9f7	869	HAL_StatusTypeDef HAL_LPTIM_SetOnce_Stop_IT(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	870	{
<>	144:ef7eb2e8f9f7	871	/* Check the parameters */
<>	144:ef7eb2e8f9f7	872	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	873
<>	144:ef7eb2e8f9f7	874	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	875	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	876
<>	144:ef7eb2e8f9f7	877	/* Disable the Peripheral */
<>	144:ef7eb2e8f9f7	878	__HAL_LPTIM_DISABLE(hlptim);
<>	144:ef7eb2e8f9f7	879
<>	144:ef7eb2e8f9f7	880	/* Disable Autoreload write complete interrupt */
<>	144:ef7eb2e8f9f7	881	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_ARROK);
<>	144:ef7eb2e8f9f7	882
<>	144:ef7eb2e8f9f7	883	/* Disable Compare write complete interrupt */
<>	144:ef7eb2e8f9f7	884	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_CMPOK);
<>	144:ef7eb2e8f9f7	885
<>	144:ef7eb2e8f9f7	886	/* Disable Autoreload match interrupt */
<>	144:ef7eb2e8f9f7	887	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_ARRM);
<>	144:ef7eb2e8f9f7	888
<>	144:ef7eb2e8f9f7	889	/* Disable Compare match interrupt */
<>	144:ef7eb2e8f9f7	890	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_CMPM);
<>	144:ef7eb2e8f9f7	891
<>	144:ef7eb2e8f9f7	892	/* If external trigger source is used, then disable external trigger interrupt */
<>	144:ef7eb2e8f9f7	893	if ((hlptim->Init.Trigger.Source) != LPTIM_TRIGSOURCE_SOFTWARE)
<>	144:ef7eb2e8f9f7	894	{
<>	144:ef7eb2e8f9f7	895	/* Disable external trigger interrupt */
<>	144:ef7eb2e8f9f7	896	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_EXTTRIG);
<>	144:ef7eb2e8f9f7	897	}
<>	144:ef7eb2e8f9f7	898
<>	144:ef7eb2e8f9f7	899	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	900	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	901
<>	144:ef7eb2e8f9f7	902	/* Return function status */
<>	144:ef7eb2e8f9f7	903	return HAL_OK;
<>	144:ef7eb2e8f9f7	904	}
<>	144:ef7eb2e8f9f7	905
<>	144:ef7eb2e8f9f7	906	/**
<>	144:ef7eb2e8f9f7	907	* @brief Starts the Encoder interface.
<>	144:ef7eb2e8f9f7	908	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	909	* @param Period : Specifies the Autoreload value.
<>	144:ef7eb2e8f9f7	910	* This parameter must be a value between 0x0000 and 0xFFFF.
<>	144:ef7eb2e8f9f7	911	* @retval HAL status
<>	144:ef7eb2e8f9f7	912	*/
<>	144:ef7eb2e8f9f7	913	HAL_StatusTypeDef HAL_LPTIM_Encoder_Start(LPTIM_HandleTypeDef *hlptim, uint32_t Period)
<>	144:ef7eb2e8f9f7	914	{
<>	144:ef7eb2e8f9f7	915	uint32_t tmpcfgr = 0;
<>	144:ef7eb2e8f9f7	916
<>	144:ef7eb2e8f9f7	917	/* Check the parameters */
<>	144:ef7eb2e8f9f7	918	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	919	assert_param(IS_LPTIM_PERIOD(Period));
<>	144:ef7eb2e8f9f7	920	assert_param(hlptim->Init.Clock.Source == LPTIM_CLOCKSOURCE_APBCLOCK_LPOSC);
<>	144:ef7eb2e8f9f7	921	assert_param(hlptim->Init.Clock.Prescaler == LPTIM_PRESCALER_DIV1);
<>	144:ef7eb2e8f9f7	922	assert_param(IS_LPTIM_CLOCK_POLARITY(hlptim->Init.UltraLowPowerClock.Polarity));
<>	144:ef7eb2e8f9f7	923
<>	144:ef7eb2e8f9f7	924	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	925	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	926
<>	144:ef7eb2e8f9f7	927	/* Get the LPTIMx CFGR value */
<>	144:ef7eb2e8f9f7	928	tmpcfgr = hlptim->Instance->CFGR;
<>	144:ef7eb2e8f9f7	929
<>	144:ef7eb2e8f9f7	930	/* Clear CKPOL bits */
<>	144:ef7eb2e8f9f7	931	tmpcfgr &= (uint32_t)(~LPTIM_CFGR_CKPOL);
<>	144:ef7eb2e8f9f7	932
<>	144:ef7eb2e8f9f7	933	/* Set Input polarity */
<>	144:ef7eb2e8f9f7	934	tmpcfgr \|= hlptim->Init.UltraLowPowerClock.Polarity;
<>	144:ef7eb2e8f9f7	935
<>	144:ef7eb2e8f9f7	936	/* Write to LPTIMx CFGR */
<>	144:ef7eb2e8f9f7	937	hlptim->Instance->CFGR = tmpcfgr;
<>	144:ef7eb2e8f9f7	938
<>	144:ef7eb2e8f9f7	939	/* Set ENC bit to enable the encoder interface */
<>	144:ef7eb2e8f9f7	940	hlptim->Instance->CFGR \|= LPTIM_CFGR_ENC;
<>	144:ef7eb2e8f9f7	941
<>	144:ef7eb2e8f9f7	942	/* Enable the Peripheral */
<>	144:ef7eb2e8f9f7	943	__HAL_LPTIM_ENABLE(hlptim);
<>	144:ef7eb2e8f9f7	944
<>	144:ef7eb2e8f9f7	945	/* Load the period value in the autoreload register */
<>	144:ef7eb2e8f9f7	946	__HAL_LPTIM_AUTORELOAD_SET(hlptim, Period);
<>	144:ef7eb2e8f9f7	947
<>	144:ef7eb2e8f9f7	948	/* Start timer in continuous mode */
<>	144:ef7eb2e8f9f7	949	__HAL_LPTIM_START_CONTINUOUS(hlptim);
<>	144:ef7eb2e8f9f7	950
<>	144:ef7eb2e8f9f7	951	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	952	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	953
<>	144:ef7eb2e8f9f7	954	/* Return function status */
<>	144:ef7eb2e8f9f7	955	return HAL_OK;
<>	144:ef7eb2e8f9f7	956	}
<>	144:ef7eb2e8f9f7	957
<>	144:ef7eb2e8f9f7	958	/**
<>	144:ef7eb2e8f9f7	959	* @brief Stops the Encoder interface.
<>	144:ef7eb2e8f9f7	960	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	961	* @retval HAL status
<>	144:ef7eb2e8f9f7	962	*/
<>	144:ef7eb2e8f9f7	963	HAL_StatusTypeDef HAL_LPTIM_Encoder_Stop(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	964	{
<>	144:ef7eb2e8f9f7	965	/* Check the parameters */
<>	144:ef7eb2e8f9f7	966	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	967
<>	144:ef7eb2e8f9f7	968	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	969	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	970
<>	144:ef7eb2e8f9f7	971	/* Disable the Peripheral */
<>	144:ef7eb2e8f9f7	972	__HAL_LPTIM_DISABLE(hlptim);
<>	144:ef7eb2e8f9f7	973
<>	144:ef7eb2e8f9f7	974	/* Reset ENC bit to disable the encoder interface */
<>	144:ef7eb2e8f9f7	975	hlptim->Instance->CFGR &= ~LPTIM_CFGR_ENC;
<>	144:ef7eb2e8f9f7	976
<>	144:ef7eb2e8f9f7	977	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	978	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	979
<>	144:ef7eb2e8f9f7	980	/* Return function status */
<>	144:ef7eb2e8f9f7	981	return HAL_OK;
<>	144:ef7eb2e8f9f7	982	}
<>	144:ef7eb2e8f9f7	983
<>	144:ef7eb2e8f9f7	984	/**
<>	144:ef7eb2e8f9f7	985	* @brief Starts the Encoder interface in interrupt mode.
<>	144:ef7eb2e8f9f7	986	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	987	* @param Period : Specifies the Autoreload value.
<>	144:ef7eb2e8f9f7	988	* This parameter must be a value between 0x0000 and 0xFFFF.
<>	144:ef7eb2e8f9f7	989	* @retval HAL status
<>	144:ef7eb2e8f9f7	990	*/
<>	144:ef7eb2e8f9f7	991	HAL_StatusTypeDef HAL_LPTIM_Encoder_Start_IT(LPTIM_HandleTypeDef *hlptim, uint32_t Period)
<>	144:ef7eb2e8f9f7	992	{
<>	144:ef7eb2e8f9f7	993	uint32_t tmpcfgr = 0;
<>	144:ef7eb2e8f9f7	994
<>	144:ef7eb2e8f9f7	995	/* Check the parameters */
<>	144:ef7eb2e8f9f7	996	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	997	assert_param(IS_LPTIM_PERIOD(Period));
<>	144:ef7eb2e8f9f7	998	assert_param(hlptim->Init.Clock.Source == LPTIM_CLOCKSOURCE_APBCLOCK_LPOSC);
<>	144:ef7eb2e8f9f7	999	assert_param(hlptim->Init.Clock.Prescaler == LPTIM_PRESCALER_DIV1);
<>	144:ef7eb2e8f9f7	1000	assert_param(IS_LPTIM_CLOCK_POLARITY(hlptim->Init.UltraLowPowerClock.Polarity));
<>	144:ef7eb2e8f9f7	1001
<>	144:ef7eb2e8f9f7	1002	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	1003	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	1004
<>	144:ef7eb2e8f9f7	1005	/* Configure edge sensitivity for encoder mode */
<>	144:ef7eb2e8f9f7	1006	/* Get the LPTIMx CFGR value */
<>	144:ef7eb2e8f9f7	1007	tmpcfgr = hlptim->Instance->CFGR;
<>	144:ef7eb2e8f9f7	1008
<>	144:ef7eb2e8f9f7	1009	/* Clear CKPOL bits */
<>	144:ef7eb2e8f9f7	1010	tmpcfgr &= (uint32_t)(~LPTIM_CFGR_CKPOL);
<>	144:ef7eb2e8f9f7	1011
<>	144:ef7eb2e8f9f7	1012	/* Set Input polarity */
<>	144:ef7eb2e8f9f7	1013	tmpcfgr \|= hlptim->Init.UltraLowPowerClock.Polarity;
<>	144:ef7eb2e8f9f7	1014
<>	144:ef7eb2e8f9f7	1015	/* Write to LPTIMx CFGR */
<>	144:ef7eb2e8f9f7	1016	hlptim->Instance->CFGR = tmpcfgr;
<>	144:ef7eb2e8f9f7	1017
<>	144:ef7eb2e8f9f7	1018	/* Set ENC bit to enable the encoder interface */
<>	144:ef7eb2e8f9f7	1019	hlptim->Instance->CFGR \|= LPTIM_CFGR_ENC;
<>	144:ef7eb2e8f9f7	1020
<>	144:ef7eb2e8f9f7	1021	/* Enable "switch to down direction" interrupt */
<>	144:ef7eb2e8f9f7	1022	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_DOWN);
<>	144:ef7eb2e8f9f7	1023
<>	144:ef7eb2e8f9f7	1024	/* Enable "switch to up direction" interrupt */
<>	144:ef7eb2e8f9f7	1025	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_UP);
<>	144:ef7eb2e8f9f7	1026
<>	144:ef7eb2e8f9f7	1027	/* Enable the Peripheral */
<>	144:ef7eb2e8f9f7	1028	__HAL_LPTIM_ENABLE(hlptim);
<>	144:ef7eb2e8f9f7	1029
<>	144:ef7eb2e8f9f7	1030	/* Load the period value in the autoreload register */
<>	144:ef7eb2e8f9f7	1031	__HAL_LPTIM_AUTORELOAD_SET(hlptim, Period);
<>	144:ef7eb2e8f9f7	1032
<>	144:ef7eb2e8f9f7	1033	/* Start timer in continuous mode */
<>	144:ef7eb2e8f9f7	1034	__HAL_LPTIM_START_CONTINUOUS(hlptim);
<>	144:ef7eb2e8f9f7	1035
<>	144:ef7eb2e8f9f7	1036	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	1037	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	1038
<>	144:ef7eb2e8f9f7	1039	/* Return function status */
<>	144:ef7eb2e8f9f7	1040	return HAL_OK;
<>	144:ef7eb2e8f9f7	1041	}
<>	144:ef7eb2e8f9f7	1042
<>	144:ef7eb2e8f9f7	1043	/**
<>	144:ef7eb2e8f9f7	1044	* @brief Stops the Encoder interface in interrupt mode.
<>	144:ef7eb2e8f9f7	1045	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	1046	* @retval HAL status
<>	144:ef7eb2e8f9f7	1047	*/
<>	144:ef7eb2e8f9f7	1048	HAL_StatusTypeDef HAL_LPTIM_Encoder_Stop_IT(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	1049	{
<>	144:ef7eb2e8f9f7	1050	/* Check the parameters */
<>	144:ef7eb2e8f9f7	1051	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	1052
<>	144:ef7eb2e8f9f7	1053	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	1054	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	1055
<>	144:ef7eb2e8f9f7	1056	/* Disable the Peripheral */
<>	144:ef7eb2e8f9f7	1057	__HAL_LPTIM_DISABLE(hlptim);
<>	144:ef7eb2e8f9f7	1058
<>	144:ef7eb2e8f9f7	1059	/* Reset ENC bit to disable the encoder interface */
<>	144:ef7eb2e8f9f7	1060	hlptim->Instance->CFGR &= ~LPTIM_CFGR_ENC;
<>	144:ef7eb2e8f9f7	1061
<>	144:ef7eb2e8f9f7	1062	/* Disable "switch to down direction" interrupt */
<>	144:ef7eb2e8f9f7	1063	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_DOWN);
<>	144:ef7eb2e8f9f7	1064
<>	144:ef7eb2e8f9f7	1065	/* Disable "switch to up direction" interrupt */
<>	144:ef7eb2e8f9f7	1066	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_UP);
<>	144:ef7eb2e8f9f7	1067
<>	144:ef7eb2e8f9f7	1068	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	1069	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	1070
<>	144:ef7eb2e8f9f7	1071	/* Return function status */
<>	144:ef7eb2e8f9f7	1072	return HAL_OK;
<>	144:ef7eb2e8f9f7	1073	}
<>	144:ef7eb2e8f9f7	1074
<>	144:ef7eb2e8f9f7	1075	/**
<>	144:ef7eb2e8f9f7	1076	* @brief Starts the Timeout function. The first trigger event will start the
<>	144:ef7eb2e8f9f7	1077	* timer, any successive trigger event will reset the counter and
<>	144:ef7eb2e8f9f7	1078	* the timer restarts.
<>	144:ef7eb2e8f9f7	1079	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	1080	* @param Period : Specifies the Autoreload value.
<>	144:ef7eb2e8f9f7	1081	* This parameter must be a value between 0x0000 and 0xFFFF.
<>	144:ef7eb2e8f9f7	1082	* @param Timeout : Specifies the TimeOut value to rest the counter.
<>	144:ef7eb2e8f9f7	1083	* This parameter must be a value between 0x0000 and 0xFFFF.
<>	144:ef7eb2e8f9f7	1084	* @retval HAL status
<>	144:ef7eb2e8f9f7	1085	*/
<>	144:ef7eb2e8f9f7	1086	HAL_StatusTypeDef HAL_LPTIM_TimeOut_Start(LPTIM_HandleTypeDef *hlptim, uint32_t Period, uint32_t Timeout)
<>	144:ef7eb2e8f9f7	1087	{
<>	144:ef7eb2e8f9f7	1088	/* Check the parameters */
<>	144:ef7eb2e8f9f7	1089	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	1090	assert_param(IS_LPTIM_PERIOD(Period));
<>	144:ef7eb2e8f9f7	1091	assert_param(IS_LPTIM_PULSE(Timeout));
<>	144:ef7eb2e8f9f7	1092
<>	144:ef7eb2e8f9f7	1093	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	1094	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	1095
<>	144:ef7eb2e8f9f7	1096	/* Set TIMOUT bit to enable the timeout function */
<>	144:ef7eb2e8f9f7	1097	hlptim->Instance->CFGR \|= LPTIM_CFGR_TIMOUT;
<>	144:ef7eb2e8f9f7	1098
<>	144:ef7eb2e8f9f7	1099	/* Enable the Peripheral */
<>	144:ef7eb2e8f9f7	1100	__HAL_LPTIM_ENABLE(hlptim);
<>	144:ef7eb2e8f9f7	1101
<>	144:ef7eb2e8f9f7	1102	/* Load the period value in the autoreload register */
<>	144:ef7eb2e8f9f7	1103	__HAL_LPTIM_AUTORELOAD_SET(hlptim, Period);
<>	144:ef7eb2e8f9f7	1104
<>	144:ef7eb2e8f9f7	1105	/* Load the Timeout value in the compare register */
<>	144:ef7eb2e8f9f7	1106	__HAL_LPTIM_COMPARE_SET(hlptim, Timeout);
<>	144:ef7eb2e8f9f7	1107
<>	144:ef7eb2e8f9f7	1108	/* Start timer in continuous mode */
<>	144:ef7eb2e8f9f7	1109	__HAL_LPTIM_START_CONTINUOUS(hlptim);
<>	144:ef7eb2e8f9f7	1110
<>	144:ef7eb2e8f9f7	1111	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	1112	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	1113
<>	144:ef7eb2e8f9f7	1114	/* Return function status */
<>	144:ef7eb2e8f9f7	1115	return HAL_OK;
<>	144:ef7eb2e8f9f7	1116	}
<>	144:ef7eb2e8f9f7	1117
<>	144:ef7eb2e8f9f7	1118	/**
<>	144:ef7eb2e8f9f7	1119	* @brief Stops the Timeout function.
<>	144:ef7eb2e8f9f7	1120	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	1121	* @retval HAL status
<>	144:ef7eb2e8f9f7	1122	*/
<>	144:ef7eb2e8f9f7	1123	HAL_StatusTypeDef HAL_LPTIM_TimeOut_Stop(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	1124	{
<>	144:ef7eb2e8f9f7	1125	/* Check the parameters */
<>	144:ef7eb2e8f9f7	1126	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	1127
<>	144:ef7eb2e8f9f7	1128	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	1129	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	1130
<>	144:ef7eb2e8f9f7	1131	/* Disable the Peripheral */
<>	144:ef7eb2e8f9f7	1132	__HAL_LPTIM_DISABLE(hlptim);
<>	144:ef7eb2e8f9f7	1133
<>	144:ef7eb2e8f9f7	1134	/* Reset TIMOUT bit to enable the timeout function */
<>	144:ef7eb2e8f9f7	1135	hlptim->Instance->CFGR &= ~LPTIM_CFGR_TIMOUT;
<>	144:ef7eb2e8f9f7	1136
<>	144:ef7eb2e8f9f7	1137	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	1138	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	1139
<>	144:ef7eb2e8f9f7	1140	/* Return function status */
<>	144:ef7eb2e8f9f7	1141	return HAL_OK;
<>	144:ef7eb2e8f9f7	1142	}
<>	144:ef7eb2e8f9f7	1143
<>	144:ef7eb2e8f9f7	1144	/**
<>	144:ef7eb2e8f9f7	1145	* @brief Starts the Timeout function in interrupt mode. The first trigger
<>	144:ef7eb2e8f9f7	1146	* event will start the timer, any successive trigger event will reset
<>	144:ef7eb2e8f9f7	1147	* the counter and the timer restarts.
<>	144:ef7eb2e8f9f7	1148	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	1149	* @param Period : Specifies the Autoreload value.
<>	144:ef7eb2e8f9f7	1150	* This parameter must be a value between 0x0000 and 0xFFFF.
<>	144:ef7eb2e8f9f7	1151	* @param Timeout : Specifies the TimeOut value to rest the counter.
<>	144:ef7eb2e8f9f7	1152	* This parameter must be a value between 0x0000 and 0xFFFF.
<>	144:ef7eb2e8f9f7	1153	* @retval HAL status
<>	144:ef7eb2e8f9f7	1154	*/
<>	144:ef7eb2e8f9f7	1155	HAL_StatusTypeDef HAL_LPTIM_TimeOut_Start_IT(LPTIM_HandleTypeDef *hlptim, uint32_t Period, uint32_t Timeout)
<>	144:ef7eb2e8f9f7	1156	{
<>	144:ef7eb2e8f9f7	1157	/* Check the parameters */
<>	144:ef7eb2e8f9f7	1158	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	1159	assert_param(IS_LPTIM_PERIOD(Period));
<>	144:ef7eb2e8f9f7	1160	assert_param(IS_LPTIM_PULSE(Timeout));
<>	144:ef7eb2e8f9f7	1161
<>	144:ef7eb2e8f9f7	1162	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	1163	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	1164
<>	144:ef7eb2e8f9f7	1165	/* Enable EXTI Line interrupt on the LPTIM Wake-up Timer */
<>	144:ef7eb2e8f9f7	1166	__HAL_LPTIM_WAKEUPTIMER_EXTI_ENABLE_IT();
<>	144:ef7eb2e8f9f7	1167
<>	144:ef7eb2e8f9f7	1168	/* Enable rising edge trigger on the LPTIM Wake-up Timer Exti line */
<>	144:ef7eb2e8f9f7	1169	__HAL_LPTIM_WAKEUPTIMER_EXTI_ENABLE_RISING_EDGE();
<>	144:ef7eb2e8f9f7	1170
<>	144:ef7eb2e8f9f7	1171	/* Set TIMOUT bit to enable the timeout function */
<>	144:ef7eb2e8f9f7	1172	hlptim->Instance->CFGR \|= LPTIM_CFGR_TIMOUT;
<>	144:ef7eb2e8f9f7	1173
<>	144:ef7eb2e8f9f7	1174	/* Enable Compare match interrupt */
<>	144:ef7eb2e8f9f7	1175	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_CMPM);
<>	144:ef7eb2e8f9f7	1176
<>	144:ef7eb2e8f9f7	1177	/* Enable the Peripheral */
<>	144:ef7eb2e8f9f7	1178	__HAL_LPTIM_ENABLE(hlptim);
<>	144:ef7eb2e8f9f7	1179
<>	144:ef7eb2e8f9f7	1180	/* Load the period value in the autoreload register */
<>	144:ef7eb2e8f9f7	1181	__HAL_LPTIM_AUTORELOAD_SET(hlptim, Period);
<>	144:ef7eb2e8f9f7	1182
<>	144:ef7eb2e8f9f7	1183	/* Load the Timeout value in the compare register */
<>	144:ef7eb2e8f9f7	1184	__HAL_LPTIM_COMPARE_SET(hlptim, Timeout);
<>	144:ef7eb2e8f9f7	1185
<>	144:ef7eb2e8f9f7	1186	/* Start timer in continuous mode */
<>	144:ef7eb2e8f9f7	1187	__HAL_LPTIM_START_CONTINUOUS(hlptim);
<>	144:ef7eb2e8f9f7	1188
<>	144:ef7eb2e8f9f7	1189	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	1190	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	1191
<>	144:ef7eb2e8f9f7	1192	/* Return function status */
<>	144:ef7eb2e8f9f7	1193	return HAL_OK;
<>	144:ef7eb2e8f9f7	1194	}
<>	144:ef7eb2e8f9f7	1195
<>	144:ef7eb2e8f9f7	1196	/**
<>	144:ef7eb2e8f9f7	1197	* @brief Stops the Timeout function in interrupt mode.
<>	144:ef7eb2e8f9f7	1198	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	1199	* @retval HAL status
<>	144:ef7eb2e8f9f7	1200	*/
<>	144:ef7eb2e8f9f7	1201	HAL_StatusTypeDef HAL_LPTIM_TimeOut_Stop_IT(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	1202	{
<>	144:ef7eb2e8f9f7	1203	/* Check the parameters */
<>	144:ef7eb2e8f9f7	1204	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	1205
<>	144:ef7eb2e8f9f7	1206	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	1207	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	1208
<>	144:ef7eb2e8f9f7	1209	/* Disable rising edge trigger on the LPTIM Wake-up Timer Exti line */
<>	144:ef7eb2e8f9f7	1210	__HAL_LPTIM_WAKEUPTIMER_EXTI_DISABLE_RISING_EDGE();
<>	144:ef7eb2e8f9f7	1211
<>	144:ef7eb2e8f9f7	1212	/* Disable EXTI Line interrupt on the LPTIM Wake-up Timer */
<>	144:ef7eb2e8f9f7	1213	__HAL_LPTIM_WAKEUPTIMER_EXTI_DISABLE_IT();
<>	144:ef7eb2e8f9f7	1214
<>	144:ef7eb2e8f9f7	1215	/* Disable the Peripheral */
<>	144:ef7eb2e8f9f7	1216	__HAL_LPTIM_DISABLE(hlptim);
<>	144:ef7eb2e8f9f7	1217
<>	144:ef7eb2e8f9f7	1218	/* Reset TIMOUT bit to enable the timeout function */
<>	144:ef7eb2e8f9f7	1219	hlptim->Instance->CFGR &= ~LPTIM_CFGR_TIMOUT;
<>	144:ef7eb2e8f9f7	1220
<>	144:ef7eb2e8f9f7	1221	/* Disable Compare match interrupt */
<>	144:ef7eb2e8f9f7	1222	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_CMPM);
<>	144:ef7eb2e8f9f7	1223
<>	144:ef7eb2e8f9f7	1224	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	1225	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	1226
<>	144:ef7eb2e8f9f7	1227	/* Return function status */
<>	144:ef7eb2e8f9f7	1228	return HAL_OK;
<>	144:ef7eb2e8f9f7	1229	}
<>	144:ef7eb2e8f9f7	1230
<>	144:ef7eb2e8f9f7	1231	/**
<>	144:ef7eb2e8f9f7	1232	* @brief Starts the Counter mode.
<>	144:ef7eb2e8f9f7	1233	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	1234	* @param Period : Specifies the Autoreload value.
<>	144:ef7eb2e8f9f7	1235	* This parameter must be a value between 0x0000 and 0xFFFF.
<>	144:ef7eb2e8f9f7	1236	* @retval HAL status
<>	144:ef7eb2e8f9f7	1237	*/
<>	144:ef7eb2e8f9f7	1238	HAL_StatusTypeDef HAL_LPTIM_Counter_Start(LPTIM_HandleTypeDef *hlptim, uint32_t Period)
<>	144:ef7eb2e8f9f7	1239	{
<>	144:ef7eb2e8f9f7	1240	/* Check the parameters */
<>	144:ef7eb2e8f9f7	1241	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	1242	assert_param(IS_LPTIM_PERIOD(Period));
<>	144:ef7eb2e8f9f7	1243
<>	144:ef7eb2e8f9f7	1244	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	1245	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	1246
<>	144:ef7eb2e8f9f7	1247	/* If clock source is not ULPTIM clock and counter source is external, then it must not be prescaled */
<>	144:ef7eb2e8f9f7	1248	if((hlptim->Init.Clock.Source != LPTIM_CLOCKSOURCE_ULPTIM) && (hlptim->Init.CounterSource == LPTIM_COUNTERSOURCE_EXTERNAL))
<>	144:ef7eb2e8f9f7	1249	{
<>	144:ef7eb2e8f9f7	1250	/* Check if clock is prescaled */
<>	144:ef7eb2e8f9f7	1251	assert_param(IS_LPTIM_CLOCK_PRESCALERDIV1(hlptim->Init.Clock.Prescaler));
<>	144:ef7eb2e8f9f7	1252	/* Set clock prescaler to 0 */
<>	144:ef7eb2e8f9f7	1253	hlptim->Instance->CFGR &= ~LPTIM_CFGR_PRESC;
<>	144:ef7eb2e8f9f7	1254	}
<>	144:ef7eb2e8f9f7	1255
<>	144:ef7eb2e8f9f7	1256	/* Enable the Peripheral */
<>	144:ef7eb2e8f9f7	1257	__HAL_LPTIM_ENABLE(hlptim);
<>	144:ef7eb2e8f9f7	1258
<>	144:ef7eb2e8f9f7	1259	/* Load the period value in the autoreload register */
<>	144:ef7eb2e8f9f7	1260	__HAL_LPTIM_AUTORELOAD_SET(hlptim, Period);
<>	144:ef7eb2e8f9f7	1261
<>	144:ef7eb2e8f9f7	1262	/* Start timer in continuous mode */
<>	144:ef7eb2e8f9f7	1263	__HAL_LPTIM_START_CONTINUOUS(hlptim);
<>	144:ef7eb2e8f9f7	1264
<>	144:ef7eb2e8f9f7	1265	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	1266	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	1267
<>	144:ef7eb2e8f9f7	1268	/* Return function status */
<>	144:ef7eb2e8f9f7	1269	return HAL_OK;
<>	144:ef7eb2e8f9f7	1270	}
<>	144:ef7eb2e8f9f7	1271
<>	144:ef7eb2e8f9f7	1272	/**
<>	144:ef7eb2e8f9f7	1273	* @brief Stops the Counter mode.
<>	144:ef7eb2e8f9f7	1274	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	1275	* @retval HAL status
<>	144:ef7eb2e8f9f7	1276	*/
<>	144:ef7eb2e8f9f7	1277	HAL_StatusTypeDef HAL_LPTIM_Counter_Stop(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	1278	{
<>	144:ef7eb2e8f9f7	1279	/* Check the parameters */
<>	144:ef7eb2e8f9f7	1280	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	1281
<>	144:ef7eb2e8f9f7	1282	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	1283	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	1284
<>	144:ef7eb2e8f9f7	1285	/* Disable the Peripheral */
<>	144:ef7eb2e8f9f7	1286	__HAL_LPTIM_DISABLE(hlptim);
<>	144:ef7eb2e8f9f7	1287
<>	144:ef7eb2e8f9f7	1288	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	1289	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	1290
<>	144:ef7eb2e8f9f7	1291	/* Return function status */
<>	144:ef7eb2e8f9f7	1292	return HAL_OK;
<>	144:ef7eb2e8f9f7	1293	}
<>	144:ef7eb2e8f9f7	1294
<>	144:ef7eb2e8f9f7	1295	/**
<>	144:ef7eb2e8f9f7	1296	* @brief Starts the Counter mode in interrupt mode.
<>	144:ef7eb2e8f9f7	1297	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	1298	* @param Period : Specifies the Autoreload value.
<>	144:ef7eb2e8f9f7	1299	* This parameter must be a value between 0x0000 and 0xFFFF.
<>	144:ef7eb2e8f9f7	1300	* @retval HAL status
<>	144:ef7eb2e8f9f7	1301	*/
<>	144:ef7eb2e8f9f7	1302	HAL_StatusTypeDef HAL_LPTIM_Counter_Start_IT(LPTIM_HandleTypeDef *hlptim, uint32_t Period)
<>	144:ef7eb2e8f9f7	1303	{
<>	144:ef7eb2e8f9f7	1304	/* Check the parameters */
<>	144:ef7eb2e8f9f7	1305	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	1306	assert_param(IS_LPTIM_PERIOD(Period));
<>	144:ef7eb2e8f9f7	1307
<>	144:ef7eb2e8f9f7	1308	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	1309	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	1310
<>	144:ef7eb2e8f9f7	1311	/* Enable EXTI Line interrupt on the LPTIM Wake-up Timer */
<>	144:ef7eb2e8f9f7	1312	__HAL_LPTIM_WAKEUPTIMER_EXTI_ENABLE_IT();
<>	144:ef7eb2e8f9f7	1313
<>	144:ef7eb2e8f9f7	1314	/* Enable rising edge trigger on the LPTIM Wake-up Timer Exti line */
<>	144:ef7eb2e8f9f7	1315	__HAL_LPTIM_WAKEUPTIMER_EXTI_ENABLE_RISING_EDGE();
<>	144:ef7eb2e8f9f7	1316
<>	144:ef7eb2e8f9f7	1317	/* If clock source is not ULPTIM clock and counter source is external, then it must not be prescaled */
<>	144:ef7eb2e8f9f7	1318	if((hlptim->Init.Clock.Source != LPTIM_CLOCKSOURCE_ULPTIM) && (hlptim->Init.CounterSource == LPTIM_COUNTERSOURCE_EXTERNAL))
<>	144:ef7eb2e8f9f7	1319	{
<>	144:ef7eb2e8f9f7	1320	/* Check if clock is prescaled */
<>	144:ef7eb2e8f9f7	1321	assert_param(IS_LPTIM_CLOCK_PRESCALERDIV1(hlptim->Init.Clock.Prescaler));
<>	144:ef7eb2e8f9f7	1322	/* Set clock prescaler to 0 */
<>	144:ef7eb2e8f9f7	1323	hlptim->Instance->CFGR &= ~LPTIM_CFGR_PRESC;
<>	144:ef7eb2e8f9f7	1324	}
<>	144:ef7eb2e8f9f7	1325
<>	144:ef7eb2e8f9f7	1326	/* Enable Autoreload write complete interrupt */
<>	144:ef7eb2e8f9f7	1327	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_ARROK);
<>	144:ef7eb2e8f9f7	1328
<>	144:ef7eb2e8f9f7	1329	/* Enable Autoreload match interrupt */
<>	144:ef7eb2e8f9f7	1330	__HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_ARRM);
<>	144:ef7eb2e8f9f7	1331
<>	144:ef7eb2e8f9f7	1332	/* Enable the Peripheral */
<>	144:ef7eb2e8f9f7	1333	__HAL_LPTIM_ENABLE(hlptim);
<>	144:ef7eb2e8f9f7	1334
<>	144:ef7eb2e8f9f7	1335	/* Load the period value in the autoreload register */
<>	144:ef7eb2e8f9f7	1336	__HAL_LPTIM_AUTORELOAD_SET(hlptim, Period);
<>	144:ef7eb2e8f9f7	1337
<>	144:ef7eb2e8f9f7	1338	/* Start timer in continuous mode */
<>	144:ef7eb2e8f9f7	1339	__HAL_LPTIM_START_CONTINUOUS(hlptim);
<>	144:ef7eb2e8f9f7	1340
<>	144:ef7eb2e8f9f7	1341	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	1342	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	1343
<>	144:ef7eb2e8f9f7	1344	/* Return function status */
<>	144:ef7eb2e8f9f7	1345	return HAL_OK;
<>	144:ef7eb2e8f9f7	1346	}
<>	144:ef7eb2e8f9f7	1347
<>	144:ef7eb2e8f9f7	1348	/**
<>	144:ef7eb2e8f9f7	1349	* @brief Stops the Counter mode in interrupt mode.
<>	144:ef7eb2e8f9f7	1350	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	1351	* @retval HAL status
<>	144:ef7eb2e8f9f7	1352	*/
<>	144:ef7eb2e8f9f7	1353	HAL_StatusTypeDef HAL_LPTIM_Counter_Stop_IT(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	1354	{
<>	144:ef7eb2e8f9f7	1355	/* Check the parameters */
<>	144:ef7eb2e8f9f7	1356	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	1357
<>	144:ef7eb2e8f9f7	1358	/* Set the LPTIM state */
<>	144:ef7eb2e8f9f7	1359	hlptim->State= HAL_LPTIM_STATE_BUSY;
<>	144:ef7eb2e8f9f7	1360
<>	144:ef7eb2e8f9f7	1361	/* Disable rising edge trigger on the LPTIM Wake-up Timer Exti line */
<>	144:ef7eb2e8f9f7	1362	__HAL_LPTIM_WAKEUPTIMER_EXTI_DISABLE_RISING_EDGE();
<>	144:ef7eb2e8f9f7	1363
<>	144:ef7eb2e8f9f7	1364	/* Disable EXTI Line interrupt on the LPTIM Wake-up Timer */
<>	144:ef7eb2e8f9f7	1365	__HAL_LPTIM_WAKEUPTIMER_EXTI_DISABLE_IT();
<>	144:ef7eb2e8f9f7	1366
<>	144:ef7eb2e8f9f7	1367	/* Disable the Peripheral */
<>	144:ef7eb2e8f9f7	1368	__HAL_LPTIM_DISABLE(hlptim);
<>	144:ef7eb2e8f9f7	1369
<>	144:ef7eb2e8f9f7	1370	/* Disable Autoreload write complete interrupt */
<>	144:ef7eb2e8f9f7	1371	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_ARROK);
<>	144:ef7eb2e8f9f7	1372
<>	144:ef7eb2e8f9f7	1373	/* Disable Autoreload match interrupt */
<>	144:ef7eb2e8f9f7	1374	__HAL_LPTIM_DISABLE_IT(hlptim, LPTIM_IT_ARRM);
<>	144:ef7eb2e8f9f7	1375
<>	144:ef7eb2e8f9f7	1376	/* Change the TIM state*/
<>	144:ef7eb2e8f9f7	1377	hlptim->State= HAL_LPTIM_STATE_READY;
<>	144:ef7eb2e8f9f7	1378
<>	144:ef7eb2e8f9f7	1379	/* Return function status */
<>	144:ef7eb2e8f9f7	1380	return HAL_OK;
<>	144:ef7eb2e8f9f7	1381	}
<>	144:ef7eb2e8f9f7	1382
<>	144:ef7eb2e8f9f7	1383	/**
<>	144:ef7eb2e8f9f7	1384	* @}
<>	144:ef7eb2e8f9f7	1385	*/
<>	144:ef7eb2e8f9f7	1386
<>	144:ef7eb2e8f9f7	1387	/** @defgroup LPTIM_Group3 LPTIM Read operation functions
<>	144:ef7eb2e8f9f7	1388	* @brief Read operation functions.
<>	144:ef7eb2e8f9f7	1389	*
<>	144:ef7eb2e8f9f7	1390	@verbatim
<>	144:ef7eb2e8f9f7	1391	==============================================================================
<>	144:ef7eb2e8f9f7	1392	##### LPTIM Read operation functions #####
<>	144:ef7eb2e8f9f7	1393	==============================================================================
<>	144:ef7eb2e8f9f7	1394	[..] This section provides LPTIM Reading functions.
<>	144:ef7eb2e8f9f7	1395	(+) Read the counter value.
<>	144:ef7eb2e8f9f7	1396	(+) Read the period (Auto-reload) value.
<>	144:ef7eb2e8f9f7	1397	(+) Read the pulse (Compare)value.
<>	144:ef7eb2e8f9f7	1398	@endverbatim
<>	144:ef7eb2e8f9f7	1399	* @{
<>	144:ef7eb2e8f9f7	1400	*/
<>	144:ef7eb2e8f9f7	1401
<>	144:ef7eb2e8f9f7	1402	/**
<>	144:ef7eb2e8f9f7	1403	* @brief This function returns the current counter value.
<>	144:ef7eb2e8f9f7	1404	* @param hlptim: LPTIM handle
<>	144:ef7eb2e8f9f7	1405	* @retval Counter value.
<>	144:ef7eb2e8f9f7	1406	*/
<>	144:ef7eb2e8f9f7	1407	uint32_t HAL_LPTIM_ReadCounter(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	1408	{
<>	144:ef7eb2e8f9f7	1409	/* Check the parameters */
<>	144:ef7eb2e8f9f7	1410	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	1411
<>	144:ef7eb2e8f9f7	1412	return (hlptim->Instance->CNT);
<>	144:ef7eb2e8f9f7	1413	}
<>	144:ef7eb2e8f9f7	1414
<>	144:ef7eb2e8f9f7	1415	/**
<>	144:ef7eb2e8f9f7	1416	* @brief This function return the current Autoreload (Period) value.
<>	144:ef7eb2e8f9f7	1417	* @param hlptim: LPTIM handle
<>	144:ef7eb2e8f9f7	1418	* @retval Autoreload value.
<>	144:ef7eb2e8f9f7	1419	*/
<>	144:ef7eb2e8f9f7	1420	uint32_t HAL_LPTIM_ReadAutoReload(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	1421	{
<>	144:ef7eb2e8f9f7	1422	/* Check the parameters */
<>	144:ef7eb2e8f9f7	1423	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	1424
<>	144:ef7eb2e8f9f7	1425	return (hlptim->Instance->ARR);
<>	144:ef7eb2e8f9f7	1426	}
<>	144:ef7eb2e8f9f7	1427
<>	144:ef7eb2e8f9f7	1428	/**
<>	144:ef7eb2e8f9f7	1429	* @brief This function return the current Compare (Pulse) value.
<>	144:ef7eb2e8f9f7	1430	* @param hlptim: LPTIM handle
<>	144:ef7eb2e8f9f7	1431	* @retval Compare value.
<>	144:ef7eb2e8f9f7	1432	*/
<>	144:ef7eb2e8f9f7	1433	uint32_t HAL_LPTIM_ReadCompare(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	1434	{
<>	144:ef7eb2e8f9f7	1435	/* Check the parameters */
<>	144:ef7eb2e8f9f7	1436	assert_param(IS_LPTIM_INSTANCE(hlptim->Instance));
<>	144:ef7eb2e8f9f7	1437
<>	144:ef7eb2e8f9f7	1438	return (hlptim->Instance->CMP);
<>	144:ef7eb2e8f9f7	1439	}
<>	144:ef7eb2e8f9f7	1440
<>	144:ef7eb2e8f9f7	1441	/**
<>	144:ef7eb2e8f9f7	1442	* @}
<>	144:ef7eb2e8f9f7	1443	*/
<>	144:ef7eb2e8f9f7	1444
<>	144:ef7eb2e8f9f7	1445
<>	144:ef7eb2e8f9f7	1446
<>	144:ef7eb2e8f9f7	1447	/** @defgroup LPTIM_Group4 LPTIM IRQ handler
<>	144:ef7eb2e8f9f7	1448	* @brief LPTIM IRQ handler.
<>	144:ef7eb2e8f9f7	1449	*
<>	144:ef7eb2e8f9f7	1450	@verbatim
<>	144:ef7eb2e8f9f7	1451	==============================================================================
<>	144:ef7eb2e8f9f7	1452	##### LPTIM IRQ handler #####
<>	144:ef7eb2e8f9f7	1453	==============================================================================
<>	144:ef7eb2e8f9f7	1454	[..] This section provides LPTIM IRQ handler function.
<>	144:ef7eb2e8f9f7	1455
<>	144:ef7eb2e8f9f7	1456	@endverbatim
<>	144:ef7eb2e8f9f7	1457	* @{
<>	144:ef7eb2e8f9f7	1458	*/
<>	144:ef7eb2e8f9f7	1459
<>	144:ef7eb2e8f9f7	1460	/**
<>	144:ef7eb2e8f9f7	1461	* @brief This function handles LPTIM interrupt request.
<>	144:ef7eb2e8f9f7	1462	* @param hlptim: LPTIM handle
<>	144:ef7eb2e8f9f7	1463	* @retval None
<>	144:ef7eb2e8f9f7	1464	*/
<>	144:ef7eb2e8f9f7	1465	void HAL_LPTIM_IRQHandler(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	1466	{
<>	144:ef7eb2e8f9f7	1467	/* Compare match interrupt */
<>	144:ef7eb2e8f9f7	1468	if(__HAL_LPTIM_GET_FLAG(hlptim, LPTIM_FLAG_CMPM) != RESET)
<>	144:ef7eb2e8f9f7	1469	{
<>	144:ef7eb2e8f9f7	1470	if(__HAL_LPTIM_GET_IT_SOURCE(hlptim, LPTIM_IT_CMPM) !=RESET)
<>	144:ef7eb2e8f9f7	1471	{
<>	144:ef7eb2e8f9f7	1472	/* Clear Compare match flag */
<>	144:ef7eb2e8f9f7	1473	__HAL_LPTIM_CLEAR_FLAG(hlptim, LPTIM_FLAG_CMPM);
<>	144:ef7eb2e8f9f7	1474	/* Compare match Callback */
<>	144:ef7eb2e8f9f7	1475	HAL_LPTIM_CompareMatchCallback(hlptim);
<>	144:ef7eb2e8f9f7	1476	}
<>	144:ef7eb2e8f9f7	1477	}
<>	144:ef7eb2e8f9f7	1478
<>	144:ef7eb2e8f9f7	1479	/* Autoreload match interrupt */
<>	144:ef7eb2e8f9f7	1480	if(__HAL_LPTIM_GET_FLAG(hlptim, LPTIM_FLAG_ARRM) != RESET)
<>	144:ef7eb2e8f9f7	1481	{
<>	144:ef7eb2e8f9f7	1482	if(__HAL_LPTIM_GET_IT_SOURCE(hlptim, LPTIM_IT_ARRM) !=RESET)
<>	144:ef7eb2e8f9f7	1483	{
<>	144:ef7eb2e8f9f7	1484	/* Clear Autoreload match flag */
<>	144:ef7eb2e8f9f7	1485	__HAL_LPTIM_CLEAR_FLAG(hlptim, LPTIM_FLAG_ARRM);
<>	144:ef7eb2e8f9f7	1486	/* Autoreload match Callback */
<>	144:ef7eb2e8f9f7	1487	HAL_LPTIM_AutoReloadMatchCallback(hlptim);
<>	144:ef7eb2e8f9f7	1488	}
<>	144:ef7eb2e8f9f7	1489	}
<>	144:ef7eb2e8f9f7	1490
<>	144:ef7eb2e8f9f7	1491	/* Trigger detected interrupt */
<>	144:ef7eb2e8f9f7	1492	if(__HAL_LPTIM_GET_FLAG(hlptim, LPTIM_FLAG_EXTTRIG) != RESET)
<>	144:ef7eb2e8f9f7	1493	{
<>	144:ef7eb2e8f9f7	1494	if(__HAL_LPTIM_GET_IT_SOURCE(hlptim, LPTIM_IT_EXTTRIG) !=RESET)
<>	144:ef7eb2e8f9f7	1495	{
<>	144:ef7eb2e8f9f7	1496	/* Clear Trigger detected flag */
<>	144:ef7eb2e8f9f7	1497	__HAL_LPTIM_CLEAR_FLAG(hlptim, LPTIM_FLAG_EXTTRIG);
<>	144:ef7eb2e8f9f7	1498	/* Trigger detected callback */
<>	144:ef7eb2e8f9f7	1499	HAL_LPTIM_TriggerCallback(hlptim);
<>	144:ef7eb2e8f9f7	1500	}
<>	144:ef7eb2e8f9f7	1501	}
<>	144:ef7eb2e8f9f7	1502
<>	144:ef7eb2e8f9f7	1503	/* Compare write interrupt */
<>	144:ef7eb2e8f9f7	1504	if(__HAL_LPTIM_GET_FLAG(hlptim, LPTIM_FLAG_CMPOK) != RESET)
<>	144:ef7eb2e8f9f7	1505	{
<>	144:ef7eb2e8f9f7	1506	if(__HAL_LPTIM_GET_IT_SOURCE(hlptim, LPTIM_FLAG_CMPM) !=RESET)
<>	144:ef7eb2e8f9f7	1507	{
<>	144:ef7eb2e8f9f7	1508	/* Clear Compare write flag */
<>	144:ef7eb2e8f9f7	1509	__HAL_LPTIM_CLEAR_FLAG(hlptim, LPTIM_FLAG_CMPOK);
<>	144:ef7eb2e8f9f7	1510	/* Compare write Callback */
<>	144:ef7eb2e8f9f7	1511	HAL_LPTIM_CompareWriteCallback(hlptim);
<>	144:ef7eb2e8f9f7	1512	}
<>	144:ef7eb2e8f9f7	1513	}
<>	144:ef7eb2e8f9f7	1514
<>	144:ef7eb2e8f9f7	1515	/* Autoreload write interrupt */
<>	144:ef7eb2e8f9f7	1516	if(__HAL_LPTIM_GET_FLAG(hlptim, LPTIM_FLAG_ARROK) != RESET)
<>	144:ef7eb2e8f9f7	1517	{
<>	144:ef7eb2e8f9f7	1518	if(__HAL_LPTIM_GET_IT_SOURCE(hlptim, LPTIM_IT_ARROK) !=RESET)
<>	144:ef7eb2e8f9f7	1519	{
<>	144:ef7eb2e8f9f7	1520	/* Clear Autoreload write flag */
<>	144:ef7eb2e8f9f7	1521	__HAL_LPTIM_CLEAR_FLAG(hlptim, LPTIM_FLAG_ARROK);
<>	144:ef7eb2e8f9f7	1522	/* Autoreload write Callback */
<>	144:ef7eb2e8f9f7	1523	HAL_LPTIM_AutoReloadWriteCallback(hlptim);
<>	144:ef7eb2e8f9f7	1524	}
<>	144:ef7eb2e8f9f7	1525	}
<>	144:ef7eb2e8f9f7	1526
<>	144:ef7eb2e8f9f7	1527	/* Direction counter changed from Down to Up interrupt */
<>	144:ef7eb2e8f9f7	1528	if(__HAL_LPTIM_GET_FLAG(hlptim, LPTIM_FLAG_UP) != RESET)
<>	144:ef7eb2e8f9f7	1529	{
<>	144:ef7eb2e8f9f7	1530	if(__HAL_LPTIM_GET_IT_SOURCE(hlptim, LPTIM_IT_UP) !=RESET)
<>	144:ef7eb2e8f9f7	1531	{
<>	144:ef7eb2e8f9f7	1532	/* Clear Direction counter changed from Down to Up flag */
<>	144:ef7eb2e8f9f7	1533	__HAL_LPTIM_CLEAR_FLAG(hlptim, LPTIM_FLAG_UP);
<>	144:ef7eb2e8f9f7	1534	/* Direction counter changed from Down to Up Callback */
<>	144:ef7eb2e8f9f7	1535	HAL_LPTIM_DirectionUpCallback(hlptim);
<>	144:ef7eb2e8f9f7	1536	}
<>	144:ef7eb2e8f9f7	1537	}
<>	144:ef7eb2e8f9f7	1538
<>	144:ef7eb2e8f9f7	1539	/* Direction counter changed from Up to Down interrupt */
<>	144:ef7eb2e8f9f7	1540	if(__HAL_LPTIM_GET_FLAG(hlptim, LPTIM_FLAG_DOWN) != RESET)
<>	144:ef7eb2e8f9f7	1541	{
<>	144:ef7eb2e8f9f7	1542	if(__HAL_LPTIM_GET_IT_SOURCE(hlptim, LPTIM_IT_DOWN) !=RESET)
<>	144:ef7eb2e8f9f7	1543	{
<>	144:ef7eb2e8f9f7	1544	/* Clear Direction counter changed from Up to Down flag */
<>	144:ef7eb2e8f9f7	1545	__HAL_LPTIM_CLEAR_FLAG(hlptim, LPTIM_FLAG_DOWN);
<>	144:ef7eb2e8f9f7	1546	/* Direction counter changed from Up to Down Callback */
<>	144:ef7eb2e8f9f7	1547	HAL_LPTIM_DirectionDownCallback(hlptim);
<>	144:ef7eb2e8f9f7	1548	}
<>	144:ef7eb2e8f9f7	1549	}
<>	144:ef7eb2e8f9f7	1550
<>	144:ef7eb2e8f9f7	1551	__HAL_LPTIM_WAKEUPTIMER_EXTI_CLEAR_FLAG();
<>	144:ef7eb2e8f9f7	1552	}
<>	144:ef7eb2e8f9f7	1553
<>	144:ef7eb2e8f9f7	1554	/**
<>	144:ef7eb2e8f9f7	1555	* @brief Compare match callback in non blocking mode
<>	144:ef7eb2e8f9f7	1556	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	1557	* @retval None
<>	144:ef7eb2e8f9f7	1558	*/
<>	144:ef7eb2e8f9f7	1559	__weak void HAL_LPTIM_CompareMatchCallback(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	1560	{
<>	144:ef7eb2e8f9f7	1561	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	1562	UNUSED(hlptim);
<>	144:ef7eb2e8f9f7	1563
<>	144:ef7eb2e8f9f7	1564	/* NOTE : This function Should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	1565	the HAL_LPTIM_CompareMatchCallback could be implemented in the user file
<>	144:ef7eb2e8f9f7	1566	*/
<>	144:ef7eb2e8f9f7	1567	}
<>	144:ef7eb2e8f9f7	1568
<>	144:ef7eb2e8f9f7	1569	/**
<>	144:ef7eb2e8f9f7	1570	* @brief Autoreload match callback in non blocking mode
<>	144:ef7eb2e8f9f7	1571	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	1572	* @retval None
<>	144:ef7eb2e8f9f7	1573	*/
<>	144:ef7eb2e8f9f7	1574	__weak void HAL_LPTIM_AutoReloadMatchCallback(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	1575	{
<>	144:ef7eb2e8f9f7	1576	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	1577	UNUSED(hlptim);
<>	144:ef7eb2e8f9f7	1578
<>	144:ef7eb2e8f9f7	1579	/* NOTE : This function Should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	1580	the HAL_LPTIM_AutoReloadMatchCallback could be implemented in the user file
<>	144:ef7eb2e8f9f7	1581	*/
<>	144:ef7eb2e8f9f7	1582	}
<>	144:ef7eb2e8f9f7	1583
<>	144:ef7eb2e8f9f7	1584	/**
<>	144:ef7eb2e8f9f7	1585	* @brief Trigger detected callback in non blocking mode
<>	144:ef7eb2e8f9f7	1586	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	1587	* @retval None
<>	144:ef7eb2e8f9f7	1588	*/
<>	144:ef7eb2e8f9f7	1589	__weak void HAL_LPTIM_TriggerCallback(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	1590	{
<>	144:ef7eb2e8f9f7	1591	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	1592	UNUSED(hlptim);
<>	144:ef7eb2e8f9f7	1593
<>	144:ef7eb2e8f9f7	1594	/* NOTE : This function Should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	1595	the HAL_LPTIM_TriggerCallback could be implemented in the user file
<>	144:ef7eb2e8f9f7	1596	*/
<>	144:ef7eb2e8f9f7	1597	}
<>	144:ef7eb2e8f9f7	1598
<>	144:ef7eb2e8f9f7	1599	/**
<>	144:ef7eb2e8f9f7	1600	* @brief Compare write callback in non blocking mode
<>	144:ef7eb2e8f9f7	1601	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	1602	* @retval None
<>	144:ef7eb2e8f9f7	1603	*/
<>	144:ef7eb2e8f9f7	1604	__weak void HAL_LPTIM_CompareWriteCallback(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	1605	{
<>	144:ef7eb2e8f9f7	1606	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	1607	UNUSED(hlptim);
<>	144:ef7eb2e8f9f7	1608
<>	144:ef7eb2e8f9f7	1609	/* NOTE : This function Should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	1610	the HAL_LPTIM_CompareWriteCallback could be implemented in the user file
<>	144:ef7eb2e8f9f7	1611	*/
<>	144:ef7eb2e8f9f7	1612	}
<>	144:ef7eb2e8f9f7	1613
<>	144:ef7eb2e8f9f7	1614	/**
<>	144:ef7eb2e8f9f7	1615	* @brief Autoreload write callback in non blocking mode
<>	144:ef7eb2e8f9f7	1616	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	1617	* @retval None
<>	144:ef7eb2e8f9f7	1618	*/
<>	144:ef7eb2e8f9f7	1619	__weak void HAL_LPTIM_AutoReloadWriteCallback(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	1620	{
<>	144:ef7eb2e8f9f7	1621	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	1622	UNUSED(hlptim);
<>	144:ef7eb2e8f9f7	1623
<>	144:ef7eb2e8f9f7	1624	/* NOTE : This function Should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	1625	the HAL_LPTIM_AutoReloadWriteCallback could be implemented in the user file
<>	144:ef7eb2e8f9f7	1626	*/
<>	144:ef7eb2e8f9f7	1627	}
<>	144:ef7eb2e8f9f7	1628
<>	144:ef7eb2e8f9f7	1629	/**
<>	144:ef7eb2e8f9f7	1630	* @brief Direction counter changed from Down to Up callback in non blocking mode
<>	144:ef7eb2e8f9f7	1631	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	1632	* @retval None
<>	144:ef7eb2e8f9f7	1633	*/
<>	144:ef7eb2e8f9f7	1634	__weak void HAL_LPTIM_DirectionUpCallback(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	1635	{
<>	144:ef7eb2e8f9f7	1636	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	1637	UNUSED(hlptim);
<>	144:ef7eb2e8f9f7	1638
<>	144:ef7eb2e8f9f7	1639	/* NOTE : This function Should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	1640	the HAL_LPTIM_DirectionUpCallback could be implemented in the user file
<>	144:ef7eb2e8f9f7	1641	*/
<>	144:ef7eb2e8f9f7	1642	}
<>	144:ef7eb2e8f9f7	1643
<>	144:ef7eb2e8f9f7	1644	/**
<>	144:ef7eb2e8f9f7	1645	* @brief Direction counter changed from Up to Down callback in non blocking mode
<>	144:ef7eb2e8f9f7	1646	* @param hlptim : LPTIM handle
<>	144:ef7eb2e8f9f7	1647	* @retval None
<>	144:ef7eb2e8f9f7	1648	*/
<>	144:ef7eb2e8f9f7	1649	__weak void HAL_LPTIM_DirectionDownCallback(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	1650	{
<>	144:ef7eb2e8f9f7	1651	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	1652	UNUSED(hlptim);
<>	144:ef7eb2e8f9f7	1653
<>	144:ef7eb2e8f9f7	1654	/* NOTE : This function Should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	1655	the HAL_LPTIM_DirectionDownCallback could be implemented in the user file
<>	144:ef7eb2e8f9f7	1656	*/
<>	144:ef7eb2e8f9f7	1657	}
<>	144:ef7eb2e8f9f7	1658
<>	144:ef7eb2e8f9f7	1659	/**
<>	144:ef7eb2e8f9f7	1660	* @}
<>	144:ef7eb2e8f9f7	1661	*/
<>	144:ef7eb2e8f9f7	1662
<>	144:ef7eb2e8f9f7	1663	/** @defgroup LPTIM_Group5 Peripheral State functions
<>	144:ef7eb2e8f9f7	1664	* @brief Peripheral State functions.
<>	144:ef7eb2e8f9f7	1665	*
<>	144:ef7eb2e8f9f7	1666	@verbatim
<>	144:ef7eb2e8f9f7	1667	==============================================================================
<>	144:ef7eb2e8f9f7	1668	##### Peripheral State functions #####
<>	144:ef7eb2e8f9f7	1669	==============================================================================
<>	144:ef7eb2e8f9f7	1670	[..]
<>	144:ef7eb2e8f9f7	1671	This subsection permits to get in run-time the status of the peripheral.
<>	144:ef7eb2e8f9f7	1672
<>	144:ef7eb2e8f9f7	1673	@endverbatim
<>	144:ef7eb2e8f9f7	1674	* @{
<>	144:ef7eb2e8f9f7	1675	*/
<>	144:ef7eb2e8f9f7	1676
<>	144:ef7eb2e8f9f7	1677	/**
<>	144:ef7eb2e8f9f7	1678	* @brief Returns the LPTIM state.
<>	144:ef7eb2e8f9f7	1679	* @param hlptim: LPTIM handle
<>	144:ef7eb2e8f9f7	1680	* @retval HAL state
<>	144:ef7eb2e8f9f7	1681	*/
<>	144:ef7eb2e8f9f7	1682	HAL_LPTIM_StateTypeDef HAL_LPTIM_GetState(LPTIM_HandleTypeDef *hlptim)
<>	144:ef7eb2e8f9f7	1683	{
<>	144:ef7eb2e8f9f7	1684	return hlptim->State;
<>	144:ef7eb2e8f9f7	1685	}
<>	144:ef7eb2e8f9f7	1686
<>	144:ef7eb2e8f9f7	1687	/**
<>	144:ef7eb2e8f9f7	1688	* @}
<>	144:ef7eb2e8f9f7	1689	*/
<>	144:ef7eb2e8f9f7	1690
<>	144:ef7eb2e8f9f7	1691
<>	144:ef7eb2e8f9f7	1692	/**
<>	144:ef7eb2e8f9f7	1693	* @}
<>	144:ef7eb2e8f9f7	1694	*/
<>	144:ef7eb2e8f9f7	1695
<>	144:ef7eb2e8f9f7	1696	#endif /* HAL_LPTIM_MODULE_ENABLED */
<>	144:ef7eb2e8f9f7	1697	/**
<>	144:ef7eb2e8f9f7	1698	* @}
<>	144:ef7eb2e8f9f7	1699	*/
<>	144:ef7eb2e8f9f7	1700
<>	144:ef7eb2e8f9f7	1701	/**
<>	144:ef7eb2e8f9f7	1702	* @}
<>	144:ef7eb2e8f9f7	1703	*/
<>	144:ef7eb2e8f9f7	1704
<>	144:ef7eb2e8f9f7	1705	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/