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_STM32F0/device/stm32f0xx_ll_usart.h@156:95d6b41a828b, 2017-01-16 (annotated)

Committer:: <>
Date:: Mon Jan 16 15:03:32 2017 +0000
Revision:: 156:95d6b41a828b
Child:: 180:96ed750bd169

This updates the lib to the mbed lib v134

Who changed what in which revision?

User	Revision	Line number	New contents of line
<>	156:95d6b41a828b	1	/**
<>	156:95d6b41a828b	2	******************************************************************************
<>	156:95d6b41a828b	3	* @file stm32f0xx_ll_usart.h
<>	156:95d6b41a828b	4	* @author MCD Application Team
<>	156:95d6b41a828b	5	* @version V1.4.0
<>	156:95d6b41a828b	6	* @date 27-May-2016
<>	156:95d6b41a828b	7	* @brief Header file of USART LL module.
<>	156:95d6b41a828b	8	******************************************************************************
<>	156:95d6b41a828b	9	* @attention
<>	156:95d6b41a828b	10	*
<>	156:95d6b41a828b	11	* <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
<>	156:95d6b41a828b	12	*
<>	156:95d6b41a828b	13	* Redistribution and use in source and binary forms, with or without modification,
<>	156:95d6b41a828b	14	* are permitted provided that the following conditions are met:
<>	156:95d6b41a828b	15	* 1. Redistributions of source code must retain the above copyright notice,
<>	156:95d6b41a828b	16	* this list of conditions and the following disclaimer.
<>	156:95d6b41a828b	17	* 2. Redistributions in binary form must reproduce the above copyright notice,
<>	156:95d6b41a828b	18	* this list of conditions and the following disclaimer in the documentation
<>	156:95d6b41a828b	19	* and/or other materials provided with the distribution.
<>	156:95d6b41a828b	20	* 3. Neither the name of STMicroelectronics nor the names of its contributors
<>	156:95d6b41a828b	21	* may be used to endorse or promote products derived from this software
<>	156:95d6b41a828b	22	* without specific prior written permission.
<>	156:95d6b41a828b	23	*
<>	156:95d6b41a828b	24	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<>	156:95d6b41a828b	25	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<>	156:95d6b41a828b	26	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<>	156:95d6b41a828b	27	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<>	156:95d6b41a828b	28	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<>	156:95d6b41a828b	29	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<>	156:95d6b41a828b	30	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<>	156:95d6b41a828b	31	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<>	156:95d6b41a828b	32	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<>	156:95d6b41a828b	33	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<>	156:95d6b41a828b	34	*
<>	156:95d6b41a828b	35	******************************************************************************
<>	156:95d6b41a828b	36	*/
<>	156:95d6b41a828b	37
<>	156:95d6b41a828b	38	/* Define to prevent recursive inclusion -------------------------------------*/
<>	156:95d6b41a828b	39	#ifndef __STM32F0xx_LL_USART_H
<>	156:95d6b41a828b	40	#define __STM32F0xx_LL_USART_H
<>	156:95d6b41a828b	41
<>	156:95d6b41a828b	42	#ifdef __cplusplus
<>	156:95d6b41a828b	43	extern "C" {
<>	156:95d6b41a828b	44	#endif
<>	156:95d6b41a828b	45
<>	156:95d6b41a828b	46	/* Includes ------------------------------------------------------------------*/
<>	156:95d6b41a828b	47	#include "stm32f0xx.h"
<>	156:95d6b41a828b	48
<>	156:95d6b41a828b	49	/** @addtogroup STM32F0xx_LL_Driver
<>	156:95d6b41a828b	50	* @{
<>	156:95d6b41a828b	51	*/
<>	156:95d6b41a828b	52
<>	156:95d6b41a828b	53	#if defined (USART1) \|\| defined (USART2) \|\| defined (USART3) \|\| defined (USART4) \|\| defined (USART5) \|\| defined (USART6) \|\| defined (USART7) \|\| defined (USART8)
<>	156:95d6b41a828b	54
<>	156:95d6b41a828b	55	/** @defgroup USART_LL USART
<>	156:95d6b41a828b	56	* @{
<>	156:95d6b41a828b	57	*/
<>	156:95d6b41a828b	58
<>	156:95d6b41a828b	59	/* Private types -------------------------------------------------------------*/
<>	156:95d6b41a828b	60	/* Private variables ---------------------------------------------------------*/
<>	156:95d6b41a828b	61
<>	156:95d6b41a828b	62	/* Private constants ---------------------------------------------------------*/
<>	156:95d6b41a828b	63	/** @defgroup USART_LL_Private_Constants USART Private Constants
<>	156:95d6b41a828b	64	* @{
<>	156:95d6b41a828b	65	*/
<>	156:95d6b41a828b	66
<>	156:95d6b41a828b	67	/* Defines used for the bit position in the register and perform offsets*/
<>	156:95d6b41a828b	68	#define USART_POSITION_CR1_DEDT (uint32_t)16
<>	156:95d6b41a828b	69	#define USART_POSITION_CR1_DEAT (uint32_t)21
<>	156:95d6b41a828b	70	#define USART_POSITION_CR2_ADD (uint32_t)24
<>	156:95d6b41a828b	71	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	72	#define USART_POSITION_CR3_SCARCNT (uint32_t)17
<>	156:95d6b41a828b	73	#define USART_POSITION_RTOR_BLEN (uint32_t)24
<>	156:95d6b41a828b	74	#define USART_POSITION_GTPR_GT (uint32_t)8
<>	156:95d6b41a828b	75	#endif
<>	156:95d6b41a828b	76	/**
<>	156:95d6b41a828b	77	* @}
<>	156:95d6b41a828b	78	*/
<>	156:95d6b41a828b	79
<>	156:95d6b41a828b	80	/* Private macros ------------------------------------------------------------*/
<>	156:95d6b41a828b	81	#if defined(USE_FULL_LL_DRIVER)
<>	156:95d6b41a828b	82	/** @defgroup USART_LL_Private_Macros USART Private Macros
<>	156:95d6b41a828b	83	* @{
<>	156:95d6b41a828b	84	*/
<>	156:95d6b41a828b	85	/**
<>	156:95d6b41a828b	86	* @}
<>	156:95d6b41a828b	87	*/
<>	156:95d6b41a828b	88	#endif /USE_FULL_LL_DRIVER/
<>	156:95d6b41a828b	89
<>	156:95d6b41a828b	90	/* Exported types ------------------------------------------------------------*/
<>	156:95d6b41a828b	91	#if defined(USE_FULL_LL_DRIVER)
<>	156:95d6b41a828b	92	/** @defgroup USART_LL_ES_INIT USART Exported Init structures
<>	156:95d6b41a828b	93	* @{
<>	156:95d6b41a828b	94	*/
<>	156:95d6b41a828b	95
<>	156:95d6b41a828b	96	/**
<>	156:95d6b41a828b	97	* @brief LL USART Init Structure definition
<>	156:95d6b41a828b	98	*/
<>	156:95d6b41a828b	99	typedef struct
<>	156:95d6b41a828b	100	{
<>	156:95d6b41a828b	101	uint32_t BaudRate; /*!< This field defines expected Usart communication baud rate.
<>	156:95d6b41a828b	102
<>	156:95d6b41a828b	103	This feature can be modified afterwards using unitary function @ref LL_USART_SetBaudRate().*/
<>	156:95d6b41a828b	104
<>	156:95d6b41a828b	105	uint32_t DataWidth; /*!< Specifies the number of data bits transmitted or received in a frame.
<>	156:95d6b41a828b	106	This parameter can be a value of @ref USART_LL_EC_DATAWIDTH.
<>	156:95d6b41a828b	107
<>	156:95d6b41a828b	108	This feature can be modified afterwards using unitary function @ref LL_USART_SetDataWidth().*/
<>	156:95d6b41a828b	109
<>	156:95d6b41a828b	110	uint32_t StopBits; /*!< Specifies the number of stop bits transmitted.
<>	156:95d6b41a828b	111	This parameter can be a value of @ref USART_LL_EC_STOPBITS.
<>	156:95d6b41a828b	112
<>	156:95d6b41a828b	113	This feature can be modified afterwards using unitary function @ref LL_USART_SetStopBitsLength().*/
<>	156:95d6b41a828b	114
<>	156:95d6b41a828b	115	uint32_t Parity; /*!< Specifies the parity mode.
<>	156:95d6b41a828b	116	This parameter can be a value of @ref USART_LL_EC_PARITY.
<>	156:95d6b41a828b	117
<>	156:95d6b41a828b	118	This feature can be modified afterwards using unitary function @ref LL_USART_SetParity().*/
<>	156:95d6b41a828b	119
<>	156:95d6b41a828b	120	uint32_t TransferDirection; /*!< Specifies whether the Receive and/or Transmit mode is enabled or disabled.
<>	156:95d6b41a828b	121	This parameter can be a value of @ref USART_LL_EC_DIRECTION.
<>	156:95d6b41a828b	122
<>	156:95d6b41a828b	123	This feature can be modified afterwards using unitary function @ref LL_USART_SetTransferDirection().*/
<>	156:95d6b41a828b	124
<>	156:95d6b41a828b	125	uint32_t HardwareFlowControl; /*!< Specifies whether the hardware flow control mode is enabled or disabled.
<>	156:95d6b41a828b	126	This parameter can be a value of @ref USART_LL_EC_HWCONTROL.
<>	156:95d6b41a828b	127
<>	156:95d6b41a828b	128	This feature can be modified afterwards using unitary function @ref LL_USART_SetHWFlowCtrl().*/
<>	156:95d6b41a828b	129
<>	156:95d6b41a828b	130	uint32_t OverSampling; /*!< Specifies whether USART oversampling mode is 16 or 8.
<>	156:95d6b41a828b	131	This parameter can be a value of @ref USART_LL_EC_OVERSAMPLING.
<>	156:95d6b41a828b	132
<>	156:95d6b41a828b	133	This feature can be modified afterwards using unitary function @ref LL_USART_SetOverSampling().*/
<>	156:95d6b41a828b	134
<>	156:95d6b41a828b	135	} LL_USART_InitTypeDef;
<>	156:95d6b41a828b	136
<>	156:95d6b41a828b	137	/**
<>	156:95d6b41a828b	138	* @brief LL USART Clock Init Structure definition
<>	156:95d6b41a828b	139	*/
<>	156:95d6b41a828b	140	typedef struct
<>	156:95d6b41a828b	141	{
<>	156:95d6b41a828b	142	uint32_t ClockOutput; /*!< Specifies whether the USART clock is enabled or disabled.
<>	156:95d6b41a828b	143	This parameter can be a value of @ref USART_LL_EC_CLOCK.
<>	156:95d6b41a828b	144
<>	156:95d6b41a828b	145	USART HW configuration can be modified afterwards using unitary functions
<>	156:95d6b41a828b	146	@ref LL_USART_EnableSCLKOutput() or @ref LL_USART_DisableSCLKOutput().
<>	156:95d6b41a828b	147	For more details, refer to description of this function. */
<>	156:95d6b41a828b	148
<>	156:95d6b41a828b	149	uint32_t ClockPolarity; /*!< Specifies the steady state of the serial clock.
<>	156:95d6b41a828b	150	This parameter can be a value of @ref USART_LL_EC_POLARITY.
<>	156:95d6b41a828b	151
<>	156:95d6b41a828b	152	USART HW configuration can be modified afterwards using unitary functions @ref LL_USART_SetClockPolarity().
<>	156:95d6b41a828b	153	For more details, refer to description of this function. */
<>	156:95d6b41a828b	154
<>	156:95d6b41a828b	155	uint32_t ClockPhase; /*!< Specifies the clock transition on which the bit capture is made.
<>	156:95d6b41a828b	156	This parameter can be a value of @ref USART_LL_EC_PHASE.
<>	156:95d6b41a828b	157
<>	156:95d6b41a828b	158	USART HW configuration can be modified afterwards using unitary functions @ref LL_USART_SetClockPhase().
<>	156:95d6b41a828b	159	For more details, refer to description of this function. */
<>	156:95d6b41a828b	160
<>	156:95d6b41a828b	161	uint32_t LastBitClockPulse; /*!< Specifies whether the clock pulse corresponding to the last transmitted
<>	156:95d6b41a828b	162	data bit (MSB) has to be output on the SCLK pin in synchronous mode.
<>	156:95d6b41a828b	163	This parameter can be a value of @ref USART_LL_EC_LASTCLKPULSE.
<>	156:95d6b41a828b	164
<>	156:95d6b41a828b	165	USART HW configuration can be modified afterwards using unitary functions @ref LL_USART_SetLastClkPulseOutput().
<>	156:95d6b41a828b	166	For more details, refer to description of this function. */
<>	156:95d6b41a828b	167
<>	156:95d6b41a828b	168	} LL_USART_ClockInitTypeDef;
<>	156:95d6b41a828b	169
<>	156:95d6b41a828b	170	/**
<>	156:95d6b41a828b	171	* @}
<>	156:95d6b41a828b	172	*/
<>	156:95d6b41a828b	173	#endif /* USE_FULL_LL_DRIVER */
<>	156:95d6b41a828b	174
<>	156:95d6b41a828b	175	/* Exported constants --------------------------------------------------------*/
<>	156:95d6b41a828b	176	/** @defgroup USART_LL_Exported_Constants USART Exported Constants
<>	156:95d6b41a828b	177	* @{
<>	156:95d6b41a828b	178	*/
<>	156:95d6b41a828b	179
<>	156:95d6b41a828b	180	/** @defgroup USART_LL_EC_CLEAR_FLAG Clear Flags Defines
<>	156:95d6b41a828b	181	* @brief Flags defines which can be used with LL_USART_WriteReg function
<>	156:95d6b41a828b	182	* @{
<>	156:95d6b41a828b	183	*/
<>	156:95d6b41a828b	184	#define LL_USART_ICR_PECF USART_ICR_PECF /!< Parity error flag /
<>	156:95d6b41a828b	185	#define LL_USART_ICR_FECF USART_ICR_FECF /!< Framing error flag /
<>	156:95d6b41a828b	186	#define LL_USART_ICR_NCF USART_ICR_NCF /!< Noise detected flag /
<>	156:95d6b41a828b	187	#define LL_USART_ICR_ORECF USART_ICR_ORECF /!< Overrun error flag /
<>	156:95d6b41a828b	188	#define LL_USART_ICR_IDLECF USART_ICR_IDLECF /!< Idle line detected flag /
<>	156:95d6b41a828b	189	#define LL_USART_ICR_TCCF USART_ICR_TCCF /!< Transmission complete flag /
<>	156:95d6b41a828b	190	#if defined(USART_LIN_SUPPORT)
<>	156:95d6b41a828b	191	#define LL_USART_ICR_LBDCF USART_ICR_LBDCF /!< LIN break detection flag /
<>	156:95d6b41a828b	192	#endif
<>	156:95d6b41a828b	193	#define LL_USART_ICR_CTSCF USART_ICR_CTSCF /!< CTS flag /
<>	156:95d6b41a828b	194	#define LL_USART_ICR_RTOCF USART_ICR_RTOCF /!< Receiver timeout flag /
<>	156:95d6b41a828b	195	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	196	#define LL_USART_ICR_EOBCF USART_ICR_EOBCF /!< End of block flag /
<>	156:95d6b41a828b	197	#endif
<>	156:95d6b41a828b	198	#define LL_USART_ICR_CMCF USART_ICR_CMCF /!< Character match flag /
<>	156:95d6b41a828b	199	#if defined(USART_WUSM_SUPPORT)
<>	156:95d6b41a828b	200	#define LL_USART_ICR_WUCF USART_ICR_WUCF /!< Wakeup from Stop mode flag /
<>	156:95d6b41a828b	201	#endif
<>	156:95d6b41a828b	202	/**
<>	156:95d6b41a828b	203	* @}
<>	156:95d6b41a828b	204	*/
<>	156:95d6b41a828b	205
<>	156:95d6b41a828b	206	/** @defgroup USART_LL_EC_GET_FLAG Get Flags Defines
<>	156:95d6b41a828b	207	* @brief Flags defines which can be used with LL_USART_ReadReg function
<>	156:95d6b41a828b	208	* @{
<>	156:95d6b41a828b	209	*/
<>	156:95d6b41a828b	210	#define LL_USART_ISR_PE USART_ISR_PE /!< Parity error flag /
<>	156:95d6b41a828b	211	#define LL_USART_ISR_FE USART_ISR_FE /!< Framing error flag /
<>	156:95d6b41a828b	212	#define LL_USART_ISR_NE USART_ISR_NE /!< Noise detected flag /
<>	156:95d6b41a828b	213	#define LL_USART_ISR_ORE USART_ISR_ORE /!< Overrun error flag /
<>	156:95d6b41a828b	214	#define LL_USART_ISR_IDLE USART_ISR_IDLE /!< Idle line detected flag /
<>	156:95d6b41a828b	215	#define LL_USART_ISR_RXNE USART_ISR_RXNE /!< Read data register not empty flag /
<>	156:95d6b41a828b	216	#define LL_USART_ISR_TC USART_ISR_TC /!< Transmission complete flag /
<>	156:95d6b41a828b	217	#define LL_USART_ISR_TXE USART_ISR_TXE /!< Transmit data register empty flag /
<>	156:95d6b41a828b	218	#if defined(USART_LIN_SUPPORT)
<>	156:95d6b41a828b	219	#define LL_USART_ISR_LBDF USART_ISR_LBDF /!< LIN break detection flag /
<>	156:95d6b41a828b	220	#endif
<>	156:95d6b41a828b	221	#define LL_USART_ISR_CTSIF USART_ISR_CTSIF /!< CTS interrupt flag /
<>	156:95d6b41a828b	222	#define LL_USART_ISR_CTS USART_ISR_CTS /!< CTS flag /
<>	156:95d6b41a828b	223	#define LL_USART_ISR_RTOF USART_ISR_RTOF /!< Receiver timeout flag /
<>	156:95d6b41a828b	224	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	225	#define LL_USART_ISR_EOBF USART_ISR_EOBF /!< End of block flag /
<>	156:95d6b41a828b	226	#endif
<>	156:95d6b41a828b	227	#define LL_USART_ISR_ABRE USART_ISR_ABRE /!< Auto baud rate error flag /
<>	156:95d6b41a828b	228	#define LL_USART_ISR_ABRF USART_ISR_ABRF /!< Auto baud rate flag /
<>	156:95d6b41a828b	229	#define LL_USART_ISR_BUSY USART_ISR_BUSY /!< Busy flag /
<>	156:95d6b41a828b	230	#define LL_USART_ISR_CMF USART_ISR_CMF /!< Character match flag /
<>	156:95d6b41a828b	231	#define LL_USART_ISR_SBKF USART_ISR_SBKF /!< Send break flag /
<>	156:95d6b41a828b	232	#define LL_USART_ISR_RWU USART_ISR_RWU /!< Receiver wakeup from Mute mode flag /
<>	156:95d6b41a828b	233	#if defined(USART_WUSM_SUPPORT)
<>	156:95d6b41a828b	234	#define LL_USART_ISR_WUF USART_ISR_WUF /!< Wakeup from Stop mode flag /
<>	156:95d6b41a828b	235	#define LL_USART_ISR_TEACK USART_ISR_TEACK /!< Transmit enable acknowledge flag /
<>	156:95d6b41a828b	236	#define LL_USART_ISR_REACK USART_ISR_REACK /!< Receive enable acknowledge flag /
<>	156:95d6b41a828b	237	#endif
<>	156:95d6b41a828b	238	/**
<>	156:95d6b41a828b	239	* @}
<>	156:95d6b41a828b	240	*/
<>	156:95d6b41a828b	241
<>	156:95d6b41a828b	242	/** @defgroup USART_LL_EC_IT IT Defines
<>	156:95d6b41a828b	243	* @brief IT defines which can be used with LL_USART_ReadReg and LL_USART_WriteReg functions
<>	156:95d6b41a828b	244	* @{
<>	156:95d6b41a828b	245	*/
<>	156:95d6b41a828b	246	#define LL_USART_CR1_IDLEIE USART_CR1_IDLEIE /!< IDLE interrupt enable /
<>	156:95d6b41a828b	247	#define LL_USART_CR1_RXNEIE USART_CR1_RXNEIE /!< Read data register not empty interrupt enable /
<>	156:95d6b41a828b	248	#define LL_USART_CR1_TCIE USART_CR1_TCIE /!< Transmission complete interrupt enable /
<>	156:95d6b41a828b	249	#define LL_USART_CR1_TXEIE USART_CR1_TXEIE /!< Transmit data register empty interrupt enable /
<>	156:95d6b41a828b	250	#define LL_USART_CR1_PEIE USART_CR1_PEIE /!< Parity error /
<>	156:95d6b41a828b	251	#define LL_USART_CR1_CMIE USART_CR1_CMIE /!< Character match interrupt enable /
<>	156:95d6b41a828b	252	#define LL_USART_CR1_RTOIE USART_CR1_RTOIE /!< Receiver timeout interrupt enable /
<>	156:95d6b41a828b	253	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	254	#define LL_USART_CR1_EOBIE USART_CR1_EOBIE /!< End of Block interrupt enable /
<>	156:95d6b41a828b	255	#endif
<>	156:95d6b41a828b	256	#if defined(USART_LIN_SUPPORT)
<>	156:95d6b41a828b	257	#define LL_USART_CR2_LBDIE USART_CR2_LBDIE /!< LIN break detection interrupt enable /
<>	156:95d6b41a828b	258	#endif
<>	156:95d6b41a828b	259	#define LL_USART_CR3_EIE USART_CR3_EIE /!< Error interrupt enable /
<>	156:95d6b41a828b	260	#define LL_USART_CR3_CTSIE USART_CR3_CTSIE /!< CTS interrupt enable /
<>	156:95d6b41a828b	261	#if defined(USART_WUSM_SUPPORT)
<>	156:95d6b41a828b	262	#define LL_USART_CR3_WUFIE USART_CR3_WUFIE /!< Wakeup from Stop mode interrupt enable /
<>	156:95d6b41a828b	263	#endif
<>	156:95d6b41a828b	264	/**
<>	156:95d6b41a828b	265	* @}
<>	156:95d6b41a828b	266	*/
<>	156:95d6b41a828b	267
<>	156:95d6b41a828b	268	/** @defgroup USART_LL_EC_DIRECTION Communication Direction
<>	156:95d6b41a828b	269	* @{
<>	156:95d6b41a828b	270	*/
<>	156:95d6b41a828b	271	#define LL_USART_DIRECTION_NONE (uint32_t)0x00000000U /!< Transmitter and Receiver are disabled /
<>	156:95d6b41a828b	272	#define LL_USART_DIRECTION_RX USART_CR1_RE /!< Transmitter is disabled and Receiver is enabled /
<>	156:95d6b41a828b	273	#define LL_USART_DIRECTION_TX USART_CR1_TE /!< Transmitter is enabled and Receiver is disabled /
<>	156:95d6b41a828b	274	#define LL_USART_DIRECTION_TX_RX (USART_CR1_TE \|USART_CR1_RE) /!< Transmitter and Receiver are enabled /
<>	156:95d6b41a828b	275	/**
<>	156:95d6b41a828b	276	* @}
<>	156:95d6b41a828b	277	*/
<>	156:95d6b41a828b	278
<>	156:95d6b41a828b	279	/** @defgroup USART_LL_EC_PARITY Parity Control
<>	156:95d6b41a828b	280	* @{
<>	156:95d6b41a828b	281	*/
<>	156:95d6b41a828b	282	#define LL_USART_PARITY_NONE (uint32_t)0x00000000U /!< Parity control disabled /
<>	156:95d6b41a828b	283	#define LL_USART_PARITY_EVEN USART_CR1_PCE /!< Parity control enabled and Even Parity is selected /
<>	156:95d6b41a828b	284	#define LL_USART_PARITY_ODD (USART_CR1_PCE \| USART_CR1_PS) /!< Parity control enabled and Odd Parity is selected /
<>	156:95d6b41a828b	285	/**
<>	156:95d6b41a828b	286	* @}
<>	156:95d6b41a828b	287	*/
<>	156:95d6b41a828b	288
<>	156:95d6b41a828b	289	/** @defgroup USART_LL_EC_WAKEUP Wakeup
<>	156:95d6b41a828b	290	* @{
<>	156:95d6b41a828b	291	*/
<>	156:95d6b41a828b	292	#define LL_USART_WAKEUP_IDLELINE (uint32_t)0x00000000U /!< USART wake up from Mute mode on Idle Line /
<>	156:95d6b41a828b	293	#define LL_USART_WAKEUP_ADDRESSMARK USART_CR1_WAKE /!< USART wake up from Mute mode on Address Mark /
<>	156:95d6b41a828b	294	/**
<>	156:95d6b41a828b	295	* @}
<>	156:95d6b41a828b	296	*/
<>	156:95d6b41a828b	297
<>	156:95d6b41a828b	298	/** @defgroup USART_LL_EC_DATAWIDTH Datawidth
<>	156:95d6b41a828b	299	* @{
<>	156:95d6b41a828b	300	*/
<>	156:95d6b41a828b	301	#if defined(USART_7BITS_SUPPORT)
<>	156:95d6b41a828b	302	#define LL_USART_DATAWIDTH_7B USART_CR1_M1 /!< 7 bits word length : Start bit, 7 data bits, n stop bits /
<>	156:95d6b41a828b	303	#define LL_USART_DATAWIDTH_8B (uint32_t)0x00000000U /!< 8 bits word length : Start bit, 8 data bits, n stop bits /
<>	156:95d6b41a828b	304	#define LL_USART_DATAWIDTH_9B USART_CR1_M0 /!< 9 bits word length : Start bit, 9 data bits, n stop bits /
<>	156:95d6b41a828b	305	#else
<>	156:95d6b41a828b	306	#define LL_USART_DATAWIDTH_8B (uint32_t)0x00000000U /!< 8 bits word length : Start bit, 8 data bits, n stop bits /
<>	156:95d6b41a828b	307	#define LL_USART_DATAWIDTH_9B USART_CR1_M /!< 9 bits word length : Start bit, 9 data bits, n stop bits /
<>	156:95d6b41a828b	308	#endif
<>	156:95d6b41a828b	309	/**
<>	156:95d6b41a828b	310	* @}
<>	156:95d6b41a828b	311	*/
<>	156:95d6b41a828b	312
<>	156:95d6b41a828b	313	/** @defgroup USART_LL_EC_OVERSAMPLING Oversampling
<>	156:95d6b41a828b	314	* @{
<>	156:95d6b41a828b	315	*/
<>	156:95d6b41a828b	316	#define LL_USART_OVERSAMPLING_16 (uint32_t)0x00000000U /!< Oversampling by 16 /
<>	156:95d6b41a828b	317	#define LL_USART_OVERSAMPLING_8 USART_CR1_OVER8 /!< Oversampling by 8 /
<>	156:95d6b41a828b	318	/**
<>	156:95d6b41a828b	319	* @}
<>	156:95d6b41a828b	320	*/
<>	156:95d6b41a828b	321
<>	156:95d6b41a828b	322	#if defined(USE_FULL_LL_DRIVER)
<>	156:95d6b41a828b	323	/** @defgroup USART_LL_EC_CLOCK Clock Signal
<>	156:95d6b41a828b	324	* @{
<>	156:95d6b41a828b	325	*/
<>	156:95d6b41a828b	326
<>	156:95d6b41a828b	327	#define LL_USART_CLOCK_DISABLE (uint32_t)0x00000000U /!< Clock signal not provided /
<>	156:95d6b41a828b	328	#define LL_USART_CLOCK_ENABLE USART_CR2_CLKEN /!< Clock signal provided /
<>	156:95d6b41a828b	329	/**
<>	156:95d6b41a828b	330	* @}
<>	156:95d6b41a828b	331	*/
<>	156:95d6b41a828b	332	#endif /USE_FULL_LL_DRIVER/
<>	156:95d6b41a828b	333
<>	156:95d6b41a828b	334	/** @defgroup USART_LL_EC_LASTCLKPULSE Last Clock Pulse
<>	156:95d6b41a828b	335	* @{
<>	156:95d6b41a828b	336	*/
<>	156:95d6b41a828b	337	#define LL_USART_LASTCLKPULSE_NO_OUTPUT (uint32_t)0x00000000U /!< The clock pulse of the last data bit is not output to the SCLK pin /
<>	156:95d6b41a828b	338	#define LL_USART_LASTCLKPULSE_OUTPUT USART_CR2_LBCL /!< The clock pulse of the last data bit is output to the SCLK pin /
<>	156:95d6b41a828b	339	/**
<>	156:95d6b41a828b	340	* @}
<>	156:95d6b41a828b	341	*/
<>	156:95d6b41a828b	342
<>	156:95d6b41a828b	343	/** @defgroup USART_LL_EC_PHASE Clock Phase
<>	156:95d6b41a828b	344	* @{
<>	156:95d6b41a828b	345	*/
<>	156:95d6b41a828b	346	#define LL_USART_PHASE_1EDGE (uint32_t)0x00000000U /!< The first clock transition is the first data capture edge /
<>	156:95d6b41a828b	347	#define LL_USART_PHASE_2EDGE USART_CR2_CPHA /!< The second clock transition is the first data capture edge /
<>	156:95d6b41a828b	348	/**
<>	156:95d6b41a828b	349	* @}
<>	156:95d6b41a828b	350	*/
<>	156:95d6b41a828b	351
<>	156:95d6b41a828b	352	/** @defgroup USART_LL_EC_POLARITY Clock Polarity
<>	156:95d6b41a828b	353	* @{
<>	156:95d6b41a828b	354	*/
<>	156:95d6b41a828b	355	#define LL_USART_POLARITY_LOW (uint32_t)0x00000000U /!< Steady low value on SCLK pin outside transmission window/
<>	156:95d6b41a828b	356	#define LL_USART_POLARITY_HIGH USART_CR2_CPOL /!< Steady high value on SCLK pin outside transmission window /
<>	156:95d6b41a828b	357	/**
<>	156:95d6b41a828b	358	* @}
<>	156:95d6b41a828b	359	*/
<>	156:95d6b41a828b	360
<>	156:95d6b41a828b	361	/** @defgroup USART_LL_EC_STOPBITS Stop Bits
<>	156:95d6b41a828b	362	* @{
<>	156:95d6b41a828b	363	*/
<>	156:95d6b41a828b	364	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	365	#define LL_USART_STOPBITS_0_5 USART_CR2_STOP_0 /!< 0.5 stop bit /
<>	156:95d6b41a828b	366	#endif
<>	156:95d6b41a828b	367	#define LL_USART_STOPBITS_1 (uint32_t)0x00000000U /!< 1 stop bit /
<>	156:95d6b41a828b	368	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	369	#define LL_USART_STOPBITS_1_5 (USART_CR2_STOP_0 \| USART_CR2_STOP_1) /!< 1.5 stop bits /
<>	156:95d6b41a828b	370	#endif
<>	156:95d6b41a828b	371	#define LL_USART_STOPBITS_2 USART_CR2_STOP_1 /!< 2 stop bits /
<>	156:95d6b41a828b	372	/**
<>	156:95d6b41a828b	373	* @}
<>	156:95d6b41a828b	374	*/
<>	156:95d6b41a828b	375
<>	156:95d6b41a828b	376	/** @defgroup USART_LL_EC_TXRX TX RX Pins Swap
<>	156:95d6b41a828b	377	* @{
<>	156:95d6b41a828b	378	*/
<>	156:95d6b41a828b	379	#define LL_USART_TXRX_STANDARD (uint32_t)0x00000000U /!< TX/RX pins are used as defined in standard pinout /
<>	156:95d6b41a828b	380	#define LL_USART_TXRX_SWAPPED (USART_CR2_SWAP) /!< TX and RX pins functions are swapped. /
<>	156:95d6b41a828b	381	/**
<>	156:95d6b41a828b	382	* @}
<>	156:95d6b41a828b	383	*/
<>	156:95d6b41a828b	384
<>	156:95d6b41a828b	385	/** @defgroup USART_LL_EC_RXPIN_LEVEL RX Pin Active Level Inversion
<>	156:95d6b41a828b	386	* @{
<>	156:95d6b41a828b	387	*/
<>	156:95d6b41a828b	388	#define LL_USART_RXPIN_LEVEL_STANDARD (uint32_t)0x00000000U /!< RX pin signal works using the standard logic levels /
<>	156:95d6b41a828b	389	#define LL_USART_RXPIN_LEVEL_INVERTED (USART_CR2_RXINV) /!< RX pin signal values are inverted. /
<>	156:95d6b41a828b	390	/**
<>	156:95d6b41a828b	391	* @}
<>	156:95d6b41a828b	392	*/
<>	156:95d6b41a828b	393
<>	156:95d6b41a828b	394	/** @defgroup USART_LL_EC_TXPIN_LEVEL TX Pin Active Level Inversion
<>	156:95d6b41a828b	395	* @{
<>	156:95d6b41a828b	396	*/
<>	156:95d6b41a828b	397	#define LL_USART_TXPIN_LEVEL_STANDARD (uint32_t)0x00000000U /!< TX pin signal works using the standard logic levels /
<>	156:95d6b41a828b	398	#define LL_USART_TXPIN_LEVEL_INVERTED (USART_CR2_TXINV) /!< TX pin signal values are inverted. /
<>	156:95d6b41a828b	399	/**
<>	156:95d6b41a828b	400	* @}
<>	156:95d6b41a828b	401	*/
<>	156:95d6b41a828b	402
<>	156:95d6b41a828b	403	/** @defgroup USART_LL_EC_BINARY_LOGIC Binary Data Inversion
<>	156:95d6b41a828b	404	* @{
<>	156:95d6b41a828b	405	*/
<>	156:95d6b41a828b	406	#define LL_USART_BINARY_LOGIC_POSITIVE (uint32_t)0x00000000U /!< Logical data from the data register are send/received in positive/direct logic. (1=H, 0=L) /
<>	156:95d6b41a828b	407	#define LL_USART_BINARY_LOGIC_NEGATIVE USART_CR2_DATAINV /!< Logical data from the data register are send/received in negative/inverse logic. (1=L, 0=H). The parity bit is also inverted. /
<>	156:95d6b41a828b	408	/**
<>	156:95d6b41a828b	409	* @}
<>	156:95d6b41a828b	410	*/
<>	156:95d6b41a828b	411
<>	156:95d6b41a828b	412	/** @defgroup USART_LL_EC_BITORDER Bit Order
<>	156:95d6b41a828b	413	* @{
<>	156:95d6b41a828b	414	*/
<>	156:95d6b41a828b	415	#define LL_USART_BITORDER_LSBFIRST (uint32_t)0x00000000U /!< data is transmitted/received with data bit 0 first, following the start bit /
<>	156:95d6b41a828b	416	#define LL_USART_BITORDER_MSBFIRST USART_CR2_MSBFIRST /!< data is transmitted/received with the MSB first, following the start bit /
<>	156:95d6b41a828b	417	/**
<>	156:95d6b41a828b	418	* @}
<>	156:95d6b41a828b	419	*/
<>	156:95d6b41a828b	420
<>	156:95d6b41a828b	421	/** @defgroup USART_LL_EC_AUTOBAUD_DETECT_ON Autobaud Detection
<>	156:95d6b41a828b	422	* @{
<>	156:95d6b41a828b	423	*/
<>	156:95d6b41a828b	424	#define LL_USART_AUTOBAUD_DETECT_ON_STARTBIT (uint32_t)0x00000000U /!< Measurement of the start bit is used to detect the baud rate /
<>	156:95d6b41a828b	425	#define LL_USART_AUTOBAUD_DETECT_ON_FALLINGEDGE USART_CR2_ABRMODE_0 /!< Falling edge to falling edge measurement. Received frame must start with a single bit = 1 -> Frame = Start10xxxxxx /
<>	156:95d6b41a828b	426	#if defined(USART_FABR_SUPPORT)
<>	156:95d6b41a828b	427	#define LL_USART_AUTOBAUD_DETECT_ON_7F_FRAME USART_CR2_ABRMODE_1 /!< 0x7F frame detection /
<>	156:95d6b41a828b	428	#define LL_USART_AUTOBAUD_DETECT_ON_55_FRAME (USART_CR2_ABRMODE_1 \| USART_CR2_ABRMODE_0) /!< 0x55 frame detection /
<>	156:95d6b41a828b	429	#endif
<>	156:95d6b41a828b	430	/**
<>	156:95d6b41a828b	431	* @}
<>	156:95d6b41a828b	432	*/
<>	156:95d6b41a828b	433
<>	156:95d6b41a828b	434	/** @defgroup USART_LL_EC_ADDRESS_DETECT Address Length Detection
<>	156:95d6b41a828b	435	* @{
<>	156:95d6b41a828b	436	*/
<>	156:95d6b41a828b	437	#define LL_USART_ADDRESS_DETECT_4B (uint32_t)0x00000000U /!< 4-bit address detection method selected /
<>	156:95d6b41a828b	438	#define LL_USART_ADDRESS_DETECT_7B USART_CR2_ADDM7 /!< 7-bit address detection (in 8-bit data mode) method selected /
<>	156:95d6b41a828b	439	/**
<>	156:95d6b41a828b	440	* @}
<>	156:95d6b41a828b	441	*/
<>	156:95d6b41a828b	442
<>	156:95d6b41a828b	443	/** @defgroup USART_LL_EC_HWCONTROL Hardware Control
<>	156:95d6b41a828b	444	* @{
<>	156:95d6b41a828b	445	*/
<>	156:95d6b41a828b	446	#define LL_USART_HWCONTROL_NONE (uint32_t)0x00000000U /!< CTS and RTS hardware flow control disabled /
<>	156:95d6b41a828b	447	#define LL_USART_HWCONTROL_RTS USART_CR3_RTSE /!< RTS output enabled, data is only requested when there is space in the receive buffer /
<>	156:95d6b41a828b	448	#define LL_USART_HWCONTROL_CTS USART_CR3_CTSE /!< CTS mode enabled, data is only transmitted when the nCTS input is asserted (tied to 0) /
<>	156:95d6b41a828b	449	#define LL_USART_HWCONTROL_RTS_CTS (USART_CR3_RTSE \| USART_CR3_CTSE) /!< CTS and RTS hardware flow control enabled /
<>	156:95d6b41a828b	450	/**
<>	156:95d6b41a828b	451	* @}
<>	156:95d6b41a828b	452	*/
<>	156:95d6b41a828b	453
<>	156:95d6b41a828b	454	#if defined(USART_WUSM_SUPPORT)
<>	156:95d6b41a828b	455	/** @defgroup USART_LL_EC_WAKEUP_ON Wakeup Activation
<>	156:95d6b41a828b	456	* @{
<>	156:95d6b41a828b	457	*/
<>	156:95d6b41a828b	458	#define LL_USART_WAKEUP_ON_ADDRESS (uint32_t)0x00000000U /!< Wake up active on address match /
<>	156:95d6b41a828b	459	#define LL_USART_WAKEUP_ON_STARTBIT USART_CR3_WUS_1 /!< Wake up active on Start bit detection /
<>	156:95d6b41a828b	460	#define LL_USART_WAKEUP_ON_RXNE (USART_CR3_WUS_0 \| USART_CR3_WUS_1) /!< Wake up active on RXNE /
<>	156:95d6b41a828b	461	/**
<>	156:95d6b41a828b	462	* @}
<>	156:95d6b41a828b	463	*/
<>	156:95d6b41a828b	464	#endif
<>	156:95d6b41a828b	465
<>	156:95d6b41a828b	466	#if defined(USART_IRDA_SUPPORT)
<>	156:95d6b41a828b	467	/** @defgroup USART_LL_EC_IRDA_POWER IrDA Power
<>	156:95d6b41a828b	468	* @{
<>	156:95d6b41a828b	469	*/
<>	156:95d6b41a828b	470	#define LL_USART_IRDA_POWER_NORMAL (uint32_t)0x00000000U /!< IrDA normal power mode /
<>	156:95d6b41a828b	471	#define LL_USART_IRDA_POWER_LOW USART_CR3_IRLP /!< IrDA low power mode /
<>	156:95d6b41a828b	472	/**
<>	156:95d6b41a828b	473	* @}
<>	156:95d6b41a828b	474	*/
<>	156:95d6b41a828b	475	#endif
<>	156:95d6b41a828b	476
<>	156:95d6b41a828b	477	#if defined(USART_LIN_SUPPORT)
<>	156:95d6b41a828b	478	/** @defgroup USART_LL_EC_LINBREAK_DETECT LIN Break Detection Length
<>	156:95d6b41a828b	479	* @{
<>	156:95d6b41a828b	480	*/
<>	156:95d6b41a828b	481	#define LL_USART_LINBREAK_DETECT_10B (uint32_t)0x00000000U /!< 10-bit break detection method selected /
<>	156:95d6b41a828b	482	#define LL_USART_LINBREAK_DETECT_11B USART_CR2_LBDL /!< 11-bit break detection method selected /
<>	156:95d6b41a828b	483	/**
<>	156:95d6b41a828b	484	* @}
<>	156:95d6b41a828b	485	*/
<>	156:95d6b41a828b	486	#endif
<>	156:95d6b41a828b	487
<>	156:95d6b41a828b	488	/** @defgroup USART_LL_EC_DE_POLARITY Driver Enable Polarity
<>	156:95d6b41a828b	489	* @{
<>	156:95d6b41a828b	490	*/
<>	156:95d6b41a828b	491	#define LL_USART_DE_POLARITY_HIGH (uint32_t)0x00000000U /!< DE signal is active high /
<>	156:95d6b41a828b	492	#define LL_USART_DE_POLARITY_LOW USART_CR3_DEP /!< DE signal is active low /
<>	156:95d6b41a828b	493	/**
<>	156:95d6b41a828b	494	* @}
<>	156:95d6b41a828b	495	*/
<>	156:95d6b41a828b	496
<>	156:95d6b41a828b	497	/** @defgroup USART_LL_EC_DMA_REG_DATA DMA Register Data
<>	156:95d6b41a828b	498	* @{
<>	156:95d6b41a828b	499	*/
<>	156:95d6b41a828b	500	#define LL_USART_DMA_REG_DATA_TRANSMIT (uint32_t)0U /!< Get address of data register used for transmission /
<>	156:95d6b41a828b	501	#define LL_USART_DMA_REG_DATA_RECEIVE (uint32_t)1U /!< Get address of data register used for reception /
<>	156:95d6b41a828b	502	/**
<>	156:95d6b41a828b	503	* @}
<>	156:95d6b41a828b	504	*/
<>	156:95d6b41a828b	505
<>	156:95d6b41a828b	506	/**
<>	156:95d6b41a828b	507	* @}
<>	156:95d6b41a828b	508	*/
<>	156:95d6b41a828b	509
<>	156:95d6b41a828b	510	/* Exported macro ------------------------------------------------------------*/
<>	156:95d6b41a828b	511	/** @defgroup USART_LL_Exported_Macros USART Exported Macros
<>	156:95d6b41a828b	512	* @{
<>	156:95d6b41a828b	513	*/
<>	156:95d6b41a828b	514
<>	156:95d6b41a828b	515	/** @defgroup USART_LL_EM_WRITE_READ Common Write and read registers Macros
<>	156:95d6b41a828b	516	* @{
<>	156:95d6b41a828b	517	*/
<>	156:95d6b41a828b	518
<>	156:95d6b41a828b	519	/**
<>	156:95d6b41a828b	520	* @brief Write a value in USART register
<>	156:95d6b41a828b	521	* @param __INSTANCE__ USART Instance
<>	156:95d6b41a828b	522	* @param __REG__ Register to be written
<>	156:95d6b41a828b	523	* @param __VALUE__ Value to be written in the register
<>	156:95d6b41a828b	524	* @retval None
<>	156:95d6b41a828b	525	*/
<>	156:95d6b41a828b	526	#define LL_USART_WriteReg(__INSTANCE__, __REG__, __VALUE__) WRITE_REG(__INSTANCE__->__REG__, (__VALUE__))
<>	156:95d6b41a828b	527
<>	156:95d6b41a828b	528	/**
<>	156:95d6b41a828b	529	* @brief Read a value in USART register
<>	156:95d6b41a828b	530	* @param __INSTANCE__ USART Instance
<>	156:95d6b41a828b	531	* @param __REG__ Register to be read
<>	156:95d6b41a828b	532	* @retval Register value
<>	156:95d6b41a828b	533	*/
<>	156:95d6b41a828b	534	#define LL_USART_ReadReg(__INSTANCE__, __REG__) READ_REG(__INSTANCE__->__REG__)
<>	156:95d6b41a828b	535	/**
<>	156:95d6b41a828b	536	* @}
<>	156:95d6b41a828b	537	*/
<>	156:95d6b41a828b	538
<>	156:95d6b41a828b	539	/** @defgroup USART_LL_EM_Exported_Macros_Helper Exported_Macros_Helper
<>	156:95d6b41a828b	540	* @{
<>	156:95d6b41a828b	541	*/
<>	156:95d6b41a828b	542
<>	156:95d6b41a828b	543	/**
<>	156:95d6b41a828b	544	* @brief Compute USARTDIV value according to Peripheral Clock and
<>	156:95d6b41a828b	545	* expected Baud Rate in 8 bits sampling mode (32 bits value of USARTDIV is returned)
<>	156:95d6b41a828b	546	* @param __PERIPHCLK__ Peripheral Clock frequency used for USART instance
<>	156:95d6b41a828b	547	* @param __BAUDRATE__ Baud rate value to achieve
<>	156:95d6b41a828b	548	* @retval USARTDIV value to be used for BRR register filling in OverSampling_8 case
<>	156:95d6b41a828b	549	*/
<>	156:95d6b41a828b	550	#define __LL_USART_DIV_SAMPLING8(__PERIPHCLK__, __BAUDRATE__) ((((__PERIPHCLK__)*2) + ((__BAUDRATE__)/2))/(__BAUDRATE__))
<>	156:95d6b41a828b	551
<>	156:95d6b41a828b	552	/**
<>	156:95d6b41a828b	553	* @brief Compute USARTDIV value according to Peripheral Clock and
<>	156:95d6b41a828b	554	* expected Baud Rate in 16 bits sampling mode (32 bits value of USARTDIV is returned)
<>	156:95d6b41a828b	555	* @param __PERIPHCLK__ Peripheral Clock frequency used for USART instance
<>	156:95d6b41a828b	556	* @param __BAUDRATE__ Baud rate value to achieve
<>	156:95d6b41a828b	557	* @retval USARTDIV value to be used for BRR register filling in OverSampling_16 case
<>	156:95d6b41a828b	558	*/
<>	156:95d6b41a828b	559	#define __LL_USART_DIV_SAMPLING16(__PERIPHCLK__, __BAUDRATE__) (((__PERIPHCLK__) + ((__BAUDRATE__)/2))/(__BAUDRATE__))
<>	156:95d6b41a828b	560
<>	156:95d6b41a828b	561	/**
<>	156:95d6b41a828b	562	* @}
<>	156:95d6b41a828b	563	*/
<>	156:95d6b41a828b	564
<>	156:95d6b41a828b	565	/**
<>	156:95d6b41a828b	566	* @}
<>	156:95d6b41a828b	567	*/
<>	156:95d6b41a828b	568
<>	156:95d6b41a828b	569	/* Exported functions --------------------------------------------------------*/
<>	156:95d6b41a828b	570
<>	156:95d6b41a828b	571	/** @defgroup USART_LL_Exported_Functions USART Exported Functions
<>	156:95d6b41a828b	572	* @{
<>	156:95d6b41a828b	573	*/
<>	156:95d6b41a828b	574
<>	156:95d6b41a828b	575	/** @defgroup USART_LL_EF_Configuration Configuration functions
<>	156:95d6b41a828b	576	* @{
<>	156:95d6b41a828b	577	*/
<>	156:95d6b41a828b	578
<>	156:95d6b41a828b	579	/**
<>	156:95d6b41a828b	580	* @brief USART Enable
<>	156:95d6b41a828b	581	* @rmtoll CR1 UE LL_USART_Enable
<>	156:95d6b41a828b	582	* @param USARTx USART Instance
<>	156:95d6b41a828b	583	* @retval None
<>	156:95d6b41a828b	584	*/
<>	156:95d6b41a828b	585	__STATIC_INLINE void LL_USART_Enable(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	586	{
<>	156:95d6b41a828b	587	SET_BIT(USARTx->CR1, USART_CR1_UE);
<>	156:95d6b41a828b	588	}
<>	156:95d6b41a828b	589
<>	156:95d6b41a828b	590	/**
<>	156:95d6b41a828b	591	* @brief USART Disable (all USART prescalers and outputs are disabled)
<>	156:95d6b41a828b	592	* @note When USART is disabled, USART prescalers and outputs are stopped immediately,
<>	156:95d6b41a828b	593	* and current operations are discarded. The configuration of the USART is kept, but all the status
<>	156:95d6b41a828b	594	* flags, in the USARTx_ISR are set to their default values.
<>	156:95d6b41a828b	595	* @rmtoll CR1 UE LL_USART_Disable
<>	156:95d6b41a828b	596	* @param USARTx USART Instance
<>	156:95d6b41a828b	597	* @retval None
<>	156:95d6b41a828b	598	*/
<>	156:95d6b41a828b	599	__STATIC_INLINE void LL_USART_Disable(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	600	{
<>	156:95d6b41a828b	601	CLEAR_BIT(USARTx->CR1, USART_CR1_UE);
<>	156:95d6b41a828b	602	}
<>	156:95d6b41a828b	603
<>	156:95d6b41a828b	604	/**
<>	156:95d6b41a828b	605	* @brief Indicate if USART is enabled
<>	156:95d6b41a828b	606	* @rmtoll CR1 UE LL_USART_IsEnabled
<>	156:95d6b41a828b	607	* @param USARTx USART Instance
<>	156:95d6b41a828b	608	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	609	*/
<>	156:95d6b41a828b	610	__STATIC_INLINE uint32_t LL_USART_IsEnabled(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	611	{
<>	156:95d6b41a828b	612	return (READ_BIT(USARTx->CR1, USART_CR1_UE) == (USART_CR1_UE));
<>	156:95d6b41a828b	613	}
<>	156:95d6b41a828b	614
<>	156:95d6b41a828b	615	#if defined(USART_WUSM_SUPPORT)
<>	156:95d6b41a828b	616	/**
<>	156:95d6b41a828b	617	* @brief USART enabled in STOP Mode.
<>	156:95d6b41a828b	618	* @note When this function is enabled, USART is able to wake up the MCU from Stop mode, provided that
<>	156:95d6b41a828b	619	* USART clock selection is HSI or LSE in RCC.
<>	156:95d6b41a828b	620	* @note Macro @ref IS_UART_WAKEUP_FROMSTOP_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	621	* Wake-up from Stop mode feature is supported by the USARTx instance.
<>	156:95d6b41a828b	622	* @rmtoll CR1 UESM LL_USART_EnableInStopMode
<>	156:95d6b41a828b	623	* @param USARTx USART Instance
<>	156:95d6b41a828b	624	* @retval None
<>	156:95d6b41a828b	625	*/
<>	156:95d6b41a828b	626	__STATIC_INLINE void LL_USART_EnableInStopMode(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	627	{
<>	156:95d6b41a828b	628	SET_BIT(USARTx->CR1, USART_CR1_UESM);
<>	156:95d6b41a828b	629	}
<>	156:95d6b41a828b	630
<>	156:95d6b41a828b	631	/**
<>	156:95d6b41a828b	632	* @brief USART disabled in STOP Mode.
<>	156:95d6b41a828b	633	* @note When this function is disabled, USART is not able to wake up the MCU from Stop mode
<>	156:95d6b41a828b	634	* @note Macro @ref IS_UART_WAKEUP_FROMSTOP_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	635	* Wake-up from Stop mode feature is supported by the USARTx instance.
<>	156:95d6b41a828b	636	* @rmtoll CR1 UESM LL_USART_DisableInStopMode
<>	156:95d6b41a828b	637	* @param USARTx USART Instance
<>	156:95d6b41a828b	638	* @retval None
<>	156:95d6b41a828b	639	*/
<>	156:95d6b41a828b	640	__STATIC_INLINE void LL_USART_DisableInStopMode(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	641	{
<>	156:95d6b41a828b	642	CLEAR_BIT(USARTx->CR1, USART_CR1_UESM);
<>	156:95d6b41a828b	643	}
<>	156:95d6b41a828b	644
<>	156:95d6b41a828b	645	/**
<>	156:95d6b41a828b	646	* @brief Indicate if USART is enabled in STOP Mode (able to wake up MCU from Stop mode or not)
<>	156:95d6b41a828b	647	* @note Macro @ref IS_UART_WAKEUP_FROMSTOP_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	648	* Wake-up from Stop mode feature is supported by the USARTx instance.
<>	156:95d6b41a828b	649	* @rmtoll CR1 UESM LL_USART_IsEnabledInStopMode
<>	156:95d6b41a828b	650	* @param USARTx USART Instance
<>	156:95d6b41a828b	651	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	652	*/
<>	156:95d6b41a828b	653	__STATIC_INLINE uint32_t LL_USART_IsEnabledInStopMode(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	654	{
<>	156:95d6b41a828b	655	return (READ_BIT(USARTx->CR1, USART_CR1_UESM) == (USART_CR1_UESM));
<>	156:95d6b41a828b	656	}
<>	156:95d6b41a828b	657	#endif
<>	156:95d6b41a828b	658
<>	156:95d6b41a828b	659	/**
<>	156:95d6b41a828b	660	* @brief Receiver Enable (Receiver is enabled and begins searching for a start bit)
<>	156:95d6b41a828b	661	* @rmtoll CR1 RE LL_USART_EnableDirectionRx
<>	156:95d6b41a828b	662	* @param USARTx USART Instance
<>	156:95d6b41a828b	663	* @retval None
<>	156:95d6b41a828b	664	*/
<>	156:95d6b41a828b	665	__STATIC_INLINE void LL_USART_EnableDirectionRx(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	666	{
<>	156:95d6b41a828b	667	SET_BIT(USARTx->CR1, USART_CR1_RE);
<>	156:95d6b41a828b	668	}
<>	156:95d6b41a828b	669
<>	156:95d6b41a828b	670	/**
<>	156:95d6b41a828b	671	* @brief Receiver Disable
<>	156:95d6b41a828b	672	* @rmtoll CR1 RE LL_USART_DisableDirectionRx
<>	156:95d6b41a828b	673	* @param USARTx USART Instance
<>	156:95d6b41a828b	674	* @retval None
<>	156:95d6b41a828b	675	*/
<>	156:95d6b41a828b	676	__STATIC_INLINE void LL_USART_DisableDirectionRx(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	677	{
<>	156:95d6b41a828b	678	CLEAR_BIT(USARTx->CR1, USART_CR1_RE);
<>	156:95d6b41a828b	679	}
<>	156:95d6b41a828b	680
<>	156:95d6b41a828b	681	/**
<>	156:95d6b41a828b	682	* @brief Transmitter Enable
<>	156:95d6b41a828b	683	* @rmtoll CR1 TE LL_USART_EnableDirectionTx
<>	156:95d6b41a828b	684	* @param USARTx USART Instance
<>	156:95d6b41a828b	685	* @retval None
<>	156:95d6b41a828b	686	*/
<>	156:95d6b41a828b	687	__STATIC_INLINE void LL_USART_EnableDirectionTx(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	688	{
<>	156:95d6b41a828b	689	SET_BIT(USARTx->CR1, USART_CR1_TE);
<>	156:95d6b41a828b	690	}
<>	156:95d6b41a828b	691
<>	156:95d6b41a828b	692	/**
<>	156:95d6b41a828b	693	* @brief Transmitter Disable
<>	156:95d6b41a828b	694	* @rmtoll CR1 TE LL_USART_DisableDirectionTx
<>	156:95d6b41a828b	695	* @param USARTx USART Instance
<>	156:95d6b41a828b	696	* @retval None
<>	156:95d6b41a828b	697	*/
<>	156:95d6b41a828b	698	__STATIC_INLINE void LL_USART_DisableDirectionTx(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	699	{
<>	156:95d6b41a828b	700	CLEAR_BIT(USARTx->CR1, USART_CR1_TE);
<>	156:95d6b41a828b	701	}
<>	156:95d6b41a828b	702
<>	156:95d6b41a828b	703	/**
<>	156:95d6b41a828b	704	* @brief Configure simultaneously enabled/disabled states
<>	156:95d6b41a828b	705	* of Transmitter and Receiver
<>	156:95d6b41a828b	706	* @rmtoll CR1 RE LL_USART_SetTransferDirection\n
<>	156:95d6b41a828b	707	* CR1 TE LL_USART_SetTransferDirection
<>	156:95d6b41a828b	708	* @param USARTx USART Instance
<>	156:95d6b41a828b	709	* @param TransferDirection This parameter can be one of the following values:
<>	156:95d6b41a828b	710	* @arg @ref LL_USART_DIRECTION_NONE
<>	156:95d6b41a828b	711	* @arg @ref LL_USART_DIRECTION_RX
<>	156:95d6b41a828b	712	* @arg @ref LL_USART_DIRECTION_TX
<>	156:95d6b41a828b	713	* @arg @ref LL_USART_DIRECTION_TX_RX
<>	156:95d6b41a828b	714	* @retval None
<>	156:95d6b41a828b	715	*/
<>	156:95d6b41a828b	716	__STATIC_INLINE void LL_USART_SetTransferDirection(USART_TypeDef *USARTx, uint32_t TransferDirection)
<>	156:95d6b41a828b	717	{
<>	156:95d6b41a828b	718	MODIFY_REG(USARTx->CR1, USART_CR1_RE \| USART_CR1_TE, TransferDirection);
<>	156:95d6b41a828b	719	}
<>	156:95d6b41a828b	720
<>	156:95d6b41a828b	721	/**
<>	156:95d6b41a828b	722	* @brief Return enabled/disabled states of Transmitter and Receiver
<>	156:95d6b41a828b	723	* @rmtoll CR1 RE LL_USART_GetTransferDirection\n
<>	156:95d6b41a828b	724	* CR1 TE LL_USART_GetTransferDirection
<>	156:95d6b41a828b	725	* @param USARTx USART Instance
<>	156:95d6b41a828b	726	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	727	* @arg @ref LL_USART_DIRECTION_NONE
<>	156:95d6b41a828b	728	* @arg @ref LL_USART_DIRECTION_RX
<>	156:95d6b41a828b	729	* @arg @ref LL_USART_DIRECTION_TX
<>	156:95d6b41a828b	730	* @arg @ref LL_USART_DIRECTION_TX_RX
<>	156:95d6b41a828b	731	*/
<>	156:95d6b41a828b	732	__STATIC_INLINE uint32_t LL_USART_GetTransferDirection(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	733	{
<>	156:95d6b41a828b	734	return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_RE \| USART_CR1_TE));
<>	156:95d6b41a828b	735	}
<>	156:95d6b41a828b	736
<>	156:95d6b41a828b	737	/**
<>	156:95d6b41a828b	738	* @brief Configure Parity (enabled/disabled and parity mode if enabled).
<>	156:95d6b41a828b	739	* @note This function selects if hardware parity control (generation and detection) is enabled or disabled.
<>	156:95d6b41a828b	740	* When the parity control is enabled (Odd or Even), computed parity bit is inserted at the MSB position
<>	156:95d6b41a828b	741	* (9th or 8th bit depending on data width) and parity is checked on the received data.
<>	156:95d6b41a828b	742	* @rmtoll CR1 PS LL_USART_SetParity\n
<>	156:95d6b41a828b	743	* CR1 PCE LL_USART_SetParity
<>	156:95d6b41a828b	744	* @param USARTx USART Instance
<>	156:95d6b41a828b	745	* @param Parity This parameter can be one of the following values:
<>	156:95d6b41a828b	746	* @arg @ref LL_USART_PARITY_NONE
<>	156:95d6b41a828b	747	* @arg @ref LL_USART_PARITY_EVEN
<>	156:95d6b41a828b	748	* @arg @ref LL_USART_PARITY_ODD
<>	156:95d6b41a828b	749	* @retval None
<>	156:95d6b41a828b	750	*/
<>	156:95d6b41a828b	751	__STATIC_INLINE void LL_USART_SetParity(USART_TypeDef *USARTx, uint32_t Parity)
<>	156:95d6b41a828b	752	{
<>	156:95d6b41a828b	753	MODIFY_REG(USARTx->CR1, USART_CR1_PS \| USART_CR1_PCE, Parity);
<>	156:95d6b41a828b	754	}
<>	156:95d6b41a828b	755
<>	156:95d6b41a828b	756	/**
<>	156:95d6b41a828b	757	* @brief Return Parity configuration (enabled/disabled and parity mode if enabled)
<>	156:95d6b41a828b	758	* @rmtoll CR1 PS LL_USART_GetParity\n
<>	156:95d6b41a828b	759	* CR1 PCE LL_USART_GetParity
<>	156:95d6b41a828b	760	* @param USARTx USART Instance
<>	156:95d6b41a828b	761	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	762	* @arg @ref LL_USART_PARITY_NONE
<>	156:95d6b41a828b	763	* @arg @ref LL_USART_PARITY_EVEN
<>	156:95d6b41a828b	764	* @arg @ref LL_USART_PARITY_ODD
<>	156:95d6b41a828b	765	*/
<>	156:95d6b41a828b	766	__STATIC_INLINE uint32_t LL_USART_GetParity(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	767	{
<>	156:95d6b41a828b	768	return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_PS \| USART_CR1_PCE));
<>	156:95d6b41a828b	769	}
<>	156:95d6b41a828b	770
<>	156:95d6b41a828b	771	/**
<>	156:95d6b41a828b	772	* @brief Set Receiver Wake Up method from Mute mode.
<>	156:95d6b41a828b	773	* @rmtoll CR1 WAKE LL_USART_SetWakeUpMethod
<>	156:95d6b41a828b	774	* @param USARTx USART Instance
<>	156:95d6b41a828b	775	* @param Method This parameter can be one of the following values:
<>	156:95d6b41a828b	776	* @arg @ref LL_USART_WAKEUP_IDLELINE
<>	156:95d6b41a828b	777	* @arg @ref LL_USART_WAKEUP_ADDRESSMARK
<>	156:95d6b41a828b	778	* @retval None
<>	156:95d6b41a828b	779	*/
<>	156:95d6b41a828b	780	__STATIC_INLINE void LL_USART_SetWakeUpMethod(USART_TypeDef *USARTx, uint32_t Method)
<>	156:95d6b41a828b	781	{
<>	156:95d6b41a828b	782	MODIFY_REG(USARTx->CR1, USART_CR1_WAKE, Method);
<>	156:95d6b41a828b	783	}
<>	156:95d6b41a828b	784
<>	156:95d6b41a828b	785	/**
<>	156:95d6b41a828b	786	* @brief Return Receiver Wake Up method from Mute mode
<>	156:95d6b41a828b	787	* @rmtoll CR1 WAKE LL_USART_GetWakeUpMethod
<>	156:95d6b41a828b	788	* @param USARTx USART Instance
<>	156:95d6b41a828b	789	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	790	* @arg @ref LL_USART_WAKEUP_IDLELINE
<>	156:95d6b41a828b	791	* @arg @ref LL_USART_WAKEUP_ADDRESSMARK
<>	156:95d6b41a828b	792	*/
<>	156:95d6b41a828b	793	__STATIC_INLINE uint32_t LL_USART_GetWakeUpMethod(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	794	{
<>	156:95d6b41a828b	795	return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_WAKE));
<>	156:95d6b41a828b	796	}
<>	156:95d6b41a828b	797
<>	156:95d6b41a828b	798	/**
<>	156:95d6b41a828b	799	* @brief Set Word length (i.e. nb of data bits, excluding start and stop bits)
<>	156:95d6b41a828b	800	* @rmtoll CR1 M0 LL_USART_SetDataWidth\n
<>	156:95d6b41a828b	801	* CR1 M1 LL_USART_SetDataWidth
<>	156:95d6b41a828b	802	* @param USARTx USART Instance
<>	156:95d6b41a828b	803	* @param DataWidth This parameter can be one of the following values:
<>	156:95d6b41a828b	804	* @arg @ref LL_USART_DATAWIDTH_7B (*)
<>	156:95d6b41a828b	805	* @arg @ref LL_USART_DATAWIDTH_8B
<>	156:95d6b41a828b	806	* @arg @ref LL_USART_DATAWIDTH_9B
<>	156:95d6b41a828b	807	*
<>	156:95d6b41a828b	808	* (*) Values not available on all devices
<>	156:95d6b41a828b	809	* @retval None
<>	156:95d6b41a828b	810	*/
<>	156:95d6b41a828b	811	__STATIC_INLINE void LL_USART_SetDataWidth(USART_TypeDef *USARTx, uint32_t DataWidth)
<>	156:95d6b41a828b	812	{
<>	156:95d6b41a828b	813	MODIFY_REG(USARTx->CR1, USART_CR1_M, DataWidth);
<>	156:95d6b41a828b	814	}
<>	156:95d6b41a828b	815
<>	156:95d6b41a828b	816	/**
<>	156:95d6b41a828b	817	* @brief Return Word length (i.e. nb of data bits, excluding start and stop bits)
<>	156:95d6b41a828b	818	* @rmtoll CR1 M0 LL_USART_GetDataWidth\n
<>	156:95d6b41a828b	819	* CR1 M1 LL_USART_GetDataWidth
<>	156:95d6b41a828b	820	* @param USARTx USART Instance
<>	156:95d6b41a828b	821	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	822	* @arg @ref LL_USART_DATAWIDTH_7B (*)
<>	156:95d6b41a828b	823	* @arg @ref LL_USART_DATAWIDTH_8B
<>	156:95d6b41a828b	824	* @arg @ref LL_USART_DATAWIDTH_9B
<>	156:95d6b41a828b	825	*
<>	156:95d6b41a828b	826	* (*) Values not available on all devices
<>	156:95d6b41a828b	827	*/
<>	156:95d6b41a828b	828	__STATIC_INLINE uint32_t LL_USART_GetDataWidth(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	829	{
<>	156:95d6b41a828b	830	return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_M));
<>	156:95d6b41a828b	831	}
<>	156:95d6b41a828b	832
<>	156:95d6b41a828b	833	/**
<>	156:95d6b41a828b	834	* @brief Allow switch between Mute Mode and Active mode
<>	156:95d6b41a828b	835	* @rmtoll CR1 MME LL_USART_EnableMuteMode
<>	156:95d6b41a828b	836	* @param USARTx USART Instance
<>	156:95d6b41a828b	837	* @retval None
<>	156:95d6b41a828b	838	*/
<>	156:95d6b41a828b	839	__STATIC_INLINE void LL_USART_EnableMuteMode(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	840	{
<>	156:95d6b41a828b	841	SET_BIT(USARTx->CR1, USART_CR1_MME);
<>	156:95d6b41a828b	842	}
<>	156:95d6b41a828b	843
<>	156:95d6b41a828b	844	/**
<>	156:95d6b41a828b	845	* @brief Prevent Mute Mode use. Set Receiver in active mode permanently.
<>	156:95d6b41a828b	846	* @rmtoll CR1 MME LL_USART_DisableMuteMode
<>	156:95d6b41a828b	847	* @param USARTx USART Instance
<>	156:95d6b41a828b	848	* @retval None
<>	156:95d6b41a828b	849	*/
<>	156:95d6b41a828b	850	__STATIC_INLINE void LL_USART_DisableMuteMode(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	851	{
<>	156:95d6b41a828b	852	CLEAR_BIT(USARTx->CR1, USART_CR1_MME);
<>	156:95d6b41a828b	853	}
<>	156:95d6b41a828b	854
<>	156:95d6b41a828b	855	/**
<>	156:95d6b41a828b	856	* @brief Indicate if switch between Mute Mode and Active mode is allowed
<>	156:95d6b41a828b	857	* @rmtoll CR1 MME LL_USART_IsEnabledMuteMode
<>	156:95d6b41a828b	858	* @param USARTx USART Instance
<>	156:95d6b41a828b	859	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	860	*/
<>	156:95d6b41a828b	861	__STATIC_INLINE uint32_t LL_USART_IsEnabledMuteMode(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	862	{
<>	156:95d6b41a828b	863	return (READ_BIT(USARTx->CR1, USART_CR1_MME) == (USART_CR1_MME));
<>	156:95d6b41a828b	864	}
<>	156:95d6b41a828b	865
<>	156:95d6b41a828b	866	/**
<>	156:95d6b41a828b	867	* @brief Set Oversampling to 8-bit or 16-bit mode
<>	156:95d6b41a828b	868	* @rmtoll CR1 OVER8 LL_USART_SetOverSampling
<>	156:95d6b41a828b	869	* @param USARTx USART Instance
<>	156:95d6b41a828b	870	* @param OverSampling This parameter can be one of the following values:
<>	156:95d6b41a828b	871	* @arg @ref LL_USART_OVERSAMPLING_16
<>	156:95d6b41a828b	872	* @arg @ref LL_USART_OVERSAMPLING_8
<>	156:95d6b41a828b	873	* @retval None
<>	156:95d6b41a828b	874	*/
<>	156:95d6b41a828b	875	__STATIC_INLINE void LL_USART_SetOverSampling(USART_TypeDef *USARTx, uint32_t OverSampling)
<>	156:95d6b41a828b	876	{
<>	156:95d6b41a828b	877	MODIFY_REG(USARTx->CR1, USART_CR1_OVER8, OverSampling);
<>	156:95d6b41a828b	878	}
<>	156:95d6b41a828b	879
<>	156:95d6b41a828b	880	/**
<>	156:95d6b41a828b	881	* @brief Return Oversampling mode
<>	156:95d6b41a828b	882	* @rmtoll CR1 OVER8 LL_USART_GetOverSampling
<>	156:95d6b41a828b	883	* @param USARTx USART Instance
<>	156:95d6b41a828b	884	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	885	* @arg @ref LL_USART_OVERSAMPLING_16
<>	156:95d6b41a828b	886	* @arg @ref LL_USART_OVERSAMPLING_8
<>	156:95d6b41a828b	887	*/
<>	156:95d6b41a828b	888	__STATIC_INLINE uint32_t LL_USART_GetOverSampling(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	889	{
<>	156:95d6b41a828b	890	return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_OVER8));
<>	156:95d6b41a828b	891	}
<>	156:95d6b41a828b	892
<>	156:95d6b41a828b	893	/**
<>	156:95d6b41a828b	894	* @brief Configure if Clock pulse of the last data bit is output to the SCLK pin or not
<>	156:95d6b41a828b	895	* @note Macro @ref IS_USART_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	896	* Synchronous mode is supported by the USARTx instance.
<>	156:95d6b41a828b	897	* @rmtoll CR2 LBCL LL_USART_SetLastClkPulseOutput
<>	156:95d6b41a828b	898	* @param USARTx USART Instance
<>	156:95d6b41a828b	899	* @param LastBitClockPulse This parameter can be one of the following values:
<>	156:95d6b41a828b	900	* @arg @ref LL_USART_LASTCLKPULSE_NO_OUTPUT
<>	156:95d6b41a828b	901	* @arg @ref LL_USART_LASTCLKPULSE_OUTPUT
<>	156:95d6b41a828b	902	* @retval None
<>	156:95d6b41a828b	903	*/
<>	156:95d6b41a828b	904	__STATIC_INLINE void LL_USART_SetLastClkPulseOutput(USART_TypeDef *USARTx, uint32_t LastBitClockPulse)
<>	156:95d6b41a828b	905	{
<>	156:95d6b41a828b	906	MODIFY_REG(USARTx->CR2, USART_CR2_LBCL, LastBitClockPulse);
<>	156:95d6b41a828b	907	}
<>	156:95d6b41a828b	908
<>	156:95d6b41a828b	909	/**
<>	156:95d6b41a828b	910	* @brief Retrieve Clock pulse of the last data bit output configuration
<>	156:95d6b41a828b	911	* (Last bit Clock pulse output to the SCLK pin or not)
<>	156:95d6b41a828b	912	* @note Macro @ref IS_USART_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	913	* Synchronous mode is supported by the USARTx instance.
<>	156:95d6b41a828b	914	* @rmtoll CR2 LBCL LL_USART_GetLastClkPulseOutput
<>	156:95d6b41a828b	915	* @param USARTx USART Instance
<>	156:95d6b41a828b	916	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	917	* @arg @ref LL_USART_LASTCLKPULSE_NO_OUTPUT
<>	156:95d6b41a828b	918	* @arg @ref LL_USART_LASTCLKPULSE_OUTPUT
<>	156:95d6b41a828b	919	*/
<>	156:95d6b41a828b	920	__STATIC_INLINE uint32_t LL_USART_GetLastClkPulseOutput(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	921	{
<>	156:95d6b41a828b	922	return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_LBCL));
<>	156:95d6b41a828b	923	}
<>	156:95d6b41a828b	924
<>	156:95d6b41a828b	925	/**
<>	156:95d6b41a828b	926	* @brief Select the phase of the clock output on the SCLK pin in synchronous mode
<>	156:95d6b41a828b	927	* @note Macro @ref IS_USART_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	928	* Synchronous mode is supported by the USARTx instance.
<>	156:95d6b41a828b	929	* @rmtoll CR2 CPHA LL_USART_SetClockPhase
<>	156:95d6b41a828b	930	* @param USARTx USART Instance
<>	156:95d6b41a828b	931	* @param ClockPhase This parameter can be one of the following values:
<>	156:95d6b41a828b	932	* @arg @ref LL_USART_PHASE_1EDGE
<>	156:95d6b41a828b	933	* @arg @ref LL_USART_PHASE_2EDGE
<>	156:95d6b41a828b	934	* @retval None
<>	156:95d6b41a828b	935	*/
<>	156:95d6b41a828b	936	__STATIC_INLINE void LL_USART_SetClockPhase(USART_TypeDef *USARTx, uint32_t ClockPhase)
<>	156:95d6b41a828b	937	{
<>	156:95d6b41a828b	938	MODIFY_REG(USARTx->CR2, USART_CR2_CPHA, ClockPhase);
<>	156:95d6b41a828b	939	}
<>	156:95d6b41a828b	940
<>	156:95d6b41a828b	941	/**
<>	156:95d6b41a828b	942	* @brief Return phase of the clock output on the SCLK pin in synchronous mode
<>	156:95d6b41a828b	943	* @note Macro @ref IS_USART_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	944	* Synchronous mode is supported by the USARTx instance.
<>	156:95d6b41a828b	945	* @rmtoll CR2 CPHA LL_USART_GetClockPhase
<>	156:95d6b41a828b	946	* @param USARTx USART Instance
<>	156:95d6b41a828b	947	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	948	* @arg @ref LL_USART_PHASE_1EDGE
<>	156:95d6b41a828b	949	* @arg @ref LL_USART_PHASE_2EDGE
<>	156:95d6b41a828b	950	*/
<>	156:95d6b41a828b	951	__STATIC_INLINE uint32_t LL_USART_GetClockPhase(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	952	{
<>	156:95d6b41a828b	953	return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_CPHA));
<>	156:95d6b41a828b	954	}
<>	156:95d6b41a828b	955
<>	156:95d6b41a828b	956	/**
<>	156:95d6b41a828b	957	* @brief Select the polarity of the clock output on the SCLK pin in synchronous mode
<>	156:95d6b41a828b	958	* @note Macro @ref IS_USART_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	959	* Synchronous mode is supported by the USARTx instance.
<>	156:95d6b41a828b	960	* @rmtoll CR2 CPOL LL_USART_SetClockPolarity
<>	156:95d6b41a828b	961	* @param USARTx USART Instance
<>	156:95d6b41a828b	962	* @param ClockPolarity This parameter can be one of the following values:
<>	156:95d6b41a828b	963	* @arg @ref LL_USART_POLARITY_LOW
<>	156:95d6b41a828b	964	* @arg @ref LL_USART_POLARITY_HIGH
<>	156:95d6b41a828b	965	* @retval None
<>	156:95d6b41a828b	966	*/
<>	156:95d6b41a828b	967	__STATIC_INLINE void LL_USART_SetClockPolarity(USART_TypeDef *USARTx, uint32_t ClockPolarity)
<>	156:95d6b41a828b	968	{
<>	156:95d6b41a828b	969	MODIFY_REG(USARTx->CR2, USART_CR2_CPOL, ClockPolarity);
<>	156:95d6b41a828b	970	}
<>	156:95d6b41a828b	971
<>	156:95d6b41a828b	972	/**
<>	156:95d6b41a828b	973	* @brief Return polarity of the clock output on the SCLK pin in synchronous mode
<>	156:95d6b41a828b	974	* @note Macro @ref IS_USART_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	975	* Synchronous mode is supported by the USARTx instance.
<>	156:95d6b41a828b	976	* @rmtoll CR2 CPOL LL_USART_GetClockPolarity
<>	156:95d6b41a828b	977	* @param USARTx USART Instance
<>	156:95d6b41a828b	978	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	979	* @arg @ref LL_USART_POLARITY_LOW
<>	156:95d6b41a828b	980	* @arg @ref LL_USART_POLARITY_HIGH
<>	156:95d6b41a828b	981	*/
<>	156:95d6b41a828b	982	__STATIC_INLINE uint32_t LL_USART_GetClockPolarity(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	983	{
<>	156:95d6b41a828b	984	return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_CPOL));
<>	156:95d6b41a828b	985	}
<>	156:95d6b41a828b	986
<>	156:95d6b41a828b	987	/**
<>	156:95d6b41a828b	988	* @brief Configure Clock signal format (Phase Polarity and choice about output of last bit clock pulse)
<>	156:95d6b41a828b	989	* @note Macro @ref IS_USART_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	990	* Synchronous mode is supported by the USARTx instance.
<>	156:95d6b41a828b	991	* @note Call of this function is equivalent to following function call sequence :
<>	156:95d6b41a828b	992	* - Clock Phase configuration using @ref LL_USART_SetClockPhase() function
<>	156:95d6b41a828b	993	* - Clock Polarity configuration using @ref LL_USART_SetClockPolarity() function
<>	156:95d6b41a828b	994	* - Output of Last bit Clock pulse configuration using @ref LL_USART_SetLastClkPulseOutput() function
<>	156:95d6b41a828b	995	* @rmtoll CR2 CPHA LL_USART_ConfigClock\n
<>	156:95d6b41a828b	996	* CR2 CPOL LL_USART_ConfigClock\n
<>	156:95d6b41a828b	997	* CR2 LBCL LL_USART_ConfigClock
<>	156:95d6b41a828b	998	* @param USARTx USART Instance
<>	156:95d6b41a828b	999	* @param Phase This parameter can be one of the following values:
<>	156:95d6b41a828b	1000	* @arg @ref LL_USART_PHASE_1EDGE
<>	156:95d6b41a828b	1001	* @arg @ref LL_USART_PHASE_2EDGE
<>	156:95d6b41a828b	1002	* @param Polarity This parameter can be one of the following values:
<>	156:95d6b41a828b	1003	* @arg @ref LL_USART_POLARITY_LOW
<>	156:95d6b41a828b	1004	* @arg @ref LL_USART_POLARITY_HIGH
<>	156:95d6b41a828b	1005	* @param LBCPOutput This parameter can be one of the following values:
<>	156:95d6b41a828b	1006	* @arg @ref LL_USART_LASTCLKPULSE_NO_OUTPUT
<>	156:95d6b41a828b	1007	* @arg @ref LL_USART_LASTCLKPULSE_OUTPUT
<>	156:95d6b41a828b	1008	* @retval None
<>	156:95d6b41a828b	1009	*/
<>	156:95d6b41a828b	1010	__STATIC_INLINE void LL_USART_ConfigClock(USART_TypeDef *USARTx, uint32_t Phase, uint32_t Polarity, uint32_t LBCPOutput)
<>	156:95d6b41a828b	1011	{
<>	156:95d6b41a828b	1012	MODIFY_REG(USARTx->CR2, USART_CR2_CPHA \| USART_CR2_CPOL \| USART_CR2_LBCL, Phase \| Polarity \| LBCPOutput);
<>	156:95d6b41a828b	1013	}
<>	156:95d6b41a828b	1014
<>	156:95d6b41a828b	1015	/**
<>	156:95d6b41a828b	1016	* @brief Enable Clock output on SCLK pin
<>	156:95d6b41a828b	1017	* @note Macro @ref IS_USART_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1018	* Synchronous mode is supported by the USARTx instance.
<>	156:95d6b41a828b	1019	* @rmtoll CR2 CLKEN LL_USART_EnableSCLKOutput
<>	156:95d6b41a828b	1020	* @param USARTx USART Instance
<>	156:95d6b41a828b	1021	* @retval None
<>	156:95d6b41a828b	1022	*/
<>	156:95d6b41a828b	1023	__STATIC_INLINE void LL_USART_EnableSCLKOutput(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1024	{
<>	156:95d6b41a828b	1025	SET_BIT(USARTx->CR2, USART_CR2_CLKEN);
<>	156:95d6b41a828b	1026	}
<>	156:95d6b41a828b	1027
<>	156:95d6b41a828b	1028	/**
<>	156:95d6b41a828b	1029	* @brief Disable Clock output on SCLK pin
<>	156:95d6b41a828b	1030	* @note Macro @ref IS_USART_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1031	* Synchronous mode is supported by the USARTx instance.
<>	156:95d6b41a828b	1032	* @rmtoll CR2 CLKEN LL_USART_DisableSCLKOutput
<>	156:95d6b41a828b	1033	* @param USARTx USART Instance
<>	156:95d6b41a828b	1034	* @retval None
<>	156:95d6b41a828b	1035	*/
<>	156:95d6b41a828b	1036	__STATIC_INLINE void LL_USART_DisableSCLKOutput(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1037	{
<>	156:95d6b41a828b	1038	CLEAR_BIT(USARTx->CR2, USART_CR2_CLKEN);
<>	156:95d6b41a828b	1039	}
<>	156:95d6b41a828b	1040
<>	156:95d6b41a828b	1041	/**
<>	156:95d6b41a828b	1042	* @brief Indicate if Clock output on SCLK pin is enabled
<>	156:95d6b41a828b	1043	* @note Macro @ref IS_USART_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1044	* Synchronous mode is supported by the USARTx instance.
<>	156:95d6b41a828b	1045	* @rmtoll CR2 CLKEN LL_USART_IsEnabledSCLKOutput
<>	156:95d6b41a828b	1046	* @param USARTx USART Instance
<>	156:95d6b41a828b	1047	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	1048	*/
<>	156:95d6b41a828b	1049	__STATIC_INLINE uint32_t LL_USART_IsEnabledSCLKOutput(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1050	{
<>	156:95d6b41a828b	1051	return (READ_BIT(USARTx->CR2, USART_CR2_CLKEN) == (USART_CR2_CLKEN));
<>	156:95d6b41a828b	1052	}
<>	156:95d6b41a828b	1053
<>	156:95d6b41a828b	1054	/**
<>	156:95d6b41a828b	1055	* @brief Set the length of the stop bits
<>	156:95d6b41a828b	1056	* @rmtoll CR2 STOP LL_USART_SetStopBitsLength
<>	156:95d6b41a828b	1057	* @param USARTx USART Instance
<>	156:95d6b41a828b	1058	* @param StopBits This parameter can be one of the following values:
<>	156:95d6b41a828b	1059	* @arg @ref LL_USART_STOPBITS_0_5 (*)
<>	156:95d6b41a828b	1060	* @arg @ref LL_USART_STOPBITS_1
<>	156:95d6b41a828b	1061	* @arg @ref LL_USART_STOPBITS_1_5 (*)
<>	156:95d6b41a828b	1062	* @arg @ref LL_USART_STOPBITS_2
<>	156:95d6b41a828b	1063	*
<>	156:95d6b41a828b	1064	* (*) Values not available on all devices
<>	156:95d6b41a828b	1065	* @retval None
<>	156:95d6b41a828b	1066	*/
<>	156:95d6b41a828b	1067	__STATIC_INLINE void LL_USART_SetStopBitsLength(USART_TypeDef *USARTx, uint32_t StopBits)
<>	156:95d6b41a828b	1068	{
<>	156:95d6b41a828b	1069	MODIFY_REG(USARTx->CR2, USART_CR2_STOP, StopBits);
<>	156:95d6b41a828b	1070	}
<>	156:95d6b41a828b	1071
<>	156:95d6b41a828b	1072	/**
<>	156:95d6b41a828b	1073	* @brief Retrieve the length of the stop bits
<>	156:95d6b41a828b	1074	* @rmtoll CR2 STOP LL_USART_GetStopBitsLength
<>	156:95d6b41a828b	1075	* @param USARTx USART Instance
<>	156:95d6b41a828b	1076	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	1077	* @arg @ref LL_USART_STOPBITS_0_5 (*)
<>	156:95d6b41a828b	1078	* @arg @ref LL_USART_STOPBITS_1
<>	156:95d6b41a828b	1079	* @arg @ref LL_USART_STOPBITS_1_5 (*)
<>	156:95d6b41a828b	1080	* @arg @ref LL_USART_STOPBITS_2
<>	156:95d6b41a828b	1081	*
<>	156:95d6b41a828b	1082	* (*) Values not available on all devices
<>	156:95d6b41a828b	1083	*/
<>	156:95d6b41a828b	1084	__STATIC_INLINE uint32_t LL_USART_GetStopBitsLength(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1085	{
<>	156:95d6b41a828b	1086	return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_STOP));
<>	156:95d6b41a828b	1087	}
<>	156:95d6b41a828b	1088
<>	156:95d6b41a828b	1089	/**
<>	156:95d6b41a828b	1090	* @brief Configure Character frame format (Datawidth, Parity control, Stop Bits)
<>	156:95d6b41a828b	1091	* @note Call of this function is equivalent to following function call sequence :
<>	156:95d6b41a828b	1092	* - Data Width configuration using @ref LL_USART_SetDataWidth() function
<>	156:95d6b41a828b	1093	* - Parity Control and mode configuration using @ref LL_USART_SetParity() function
<>	156:95d6b41a828b	1094	* - Stop bits configuration using @ref LL_USART_SetStopBitsLength() function
<>	156:95d6b41a828b	1095	* @rmtoll CR1 PS LL_USART_ConfigCharacter\n
<>	156:95d6b41a828b	1096	* CR1 PCE LL_USART_ConfigCharacter\n
<>	156:95d6b41a828b	1097	* CR1 M0 LL_USART_ConfigCharacter\n
<>	156:95d6b41a828b	1098	* CR1 M1 LL_USART_ConfigCharacter\n
<>	156:95d6b41a828b	1099	* CR2 STOP LL_USART_ConfigCharacter
<>	156:95d6b41a828b	1100	* @param USARTx USART Instance
<>	156:95d6b41a828b	1101	* @param DataWidth This parameter can be one of the following values:
<>	156:95d6b41a828b	1102	* @arg @ref LL_USART_DATAWIDTH_7B (*)
<>	156:95d6b41a828b	1103	* @arg @ref LL_USART_DATAWIDTH_8B
<>	156:95d6b41a828b	1104	* @arg @ref LL_USART_DATAWIDTH_9B
<>	156:95d6b41a828b	1105	* @param Parity This parameter can be one of the following values:
<>	156:95d6b41a828b	1106	* @arg @ref LL_USART_PARITY_NONE
<>	156:95d6b41a828b	1107	* @arg @ref LL_USART_PARITY_EVEN
<>	156:95d6b41a828b	1108	* @arg @ref LL_USART_PARITY_ODD
<>	156:95d6b41a828b	1109	* @param StopBits This parameter can be one of the following values:
<>	156:95d6b41a828b	1110	* @arg @ref LL_USART_STOPBITS_0_5 (*)
<>	156:95d6b41a828b	1111	* @arg @ref LL_USART_STOPBITS_1
<>	156:95d6b41a828b	1112	* @arg @ref LL_USART_STOPBITS_1_5 (*)
<>	156:95d6b41a828b	1113	* @arg @ref LL_USART_STOPBITS_2
<>	156:95d6b41a828b	1114	*
<>	156:95d6b41a828b	1115	* (*) Values not available on all devices
<>	156:95d6b41a828b	1116	* @retval None
<>	156:95d6b41a828b	1117	*/
<>	156:95d6b41a828b	1118	__STATIC_INLINE void LL_USART_ConfigCharacter(USART_TypeDef *USARTx, uint32_t DataWidth, uint32_t Parity,
<>	156:95d6b41a828b	1119	uint32_t StopBits)
<>	156:95d6b41a828b	1120	{
<>	156:95d6b41a828b	1121	MODIFY_REG(USARTx->CR1, USART_CR1_PS \| USART_CR1_PCE \| USART_CR1_M, Parity \| DataWidth);
<>	156:95d6b41a828b	1122	MODIFY_REG(USARTx->CR2, USART_CR2_STOP, StopBits);
<>	156:95d6b41a828b	1123	}
<>	156:95d6b41a828b	1124
<>	156:95d6b41a828b	1125	/**
<>	156:95d6b41a828b	1126	* @brief Configure TX/RX pins swapping setting.
<>	156:95d6b41a828b	1127	* @rmtoll CR2 SWAP LL_USART_SetTXRXSwap
<>	156:95d6b41a828b	1128	* @param USARTx USART Instance
<>	156:95d6b41a828b	1129	* @param SwapConfig This parameter can be one of the following values:
<>	156:95d6b41a828b	1130	* @arg @ref LL_USART_TXRX_STANDARD
<>	156:95d6b41a828b	1131	* @arg @ref LL_USART_TXRX_SWAPPED
<>	156:95d6b41a828b	1132	* @retval None
<>	156:95d6b41a828b	1133	*/
<>	156:95d6b41a828b	1134	__STATIC_INLINE void LL_USART_SetTXRXSwap(USART_TypeDef *USARTx, uint32_t SwapConfig)
<>	156:95d6b41a828b	1135	{
<>	156:95d6b41a828b	1136	MODIFY_REG(USARTx->CR2, USART_CR2_SWAP, SwapConfig);
<>	156:95d6b41a828b	1137	}
<>	156:95d6b41a828b	1138
<>	156:95d6b41a828b	1139	/**
<>	156:95d6b41a828b	1140	* @brief Retrieve TX/RX pins swapping configuration.
<>	156:95d6b41a828b	1141	* @rmtoll CR2 SWAP LL_USART_GetTXRXSwap
<>	156:95d6b41a828b	1142	* @param USARTx USART Instance
<>	156:95d6b41a828b	1143	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	1144	* @arg @ref LL_USART_TXRX_STANDARD
<>	156:95d6b41a828b	1145	* @arg @ref LL_USART_TXRX_SWAPPED
<>	156:95d6b41a828b	1146	*/
<>	156:95d6b41a828b	1147	__STATIC_INLINE uint32_t LL_USART_GetTXRXSwap(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1148	{
<>	156:95d6b41a828b	1149	return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_SWAP));
<>	156:95d6b41a828b	1150	}
<>	156:95d6b41a828b	1151
<>	156:95d6b41a828b	1152	/**
<>	156:95d6b41a828b	1153	* @brief Configure RX pin active level logic
<>	156:95d6b41a828b	1154	* @rmtoll CR2 RXINV LL_USART_SetRXPinLevel
<>	156:95d6b41a828b	1155	* @param USARTx USART Instance
<>	156:95d6b41a828b	1156	* @param PinInvMethod This parameter can be one of the following values:
<>	156:95d6b41a828b	1157	* @arg @ref LL_USART_RXPIN_LEVEL_STANDARD
<>	156:95d6b41a828b	1158	* @arg @ref LL_USART_RXPIN_LEVEL_INVERTED
<>	156:95d6b41a828b	1159	* @retval None
<>	156:95d6b41a828b	1160	*/
<>	156:95d6b41a828b	1161	__STATIC_INLINE void LL_USART_SetRXPinLevel(USART_TypeDef *USARTx, uint32_t PinInvMethod)
<>	156:95d6b41a828b	1162	{
<>	156:95d6b41a828b	1163	MODIFY_REG(USARTx->CR2, USART_CR2_RXINV, PinInvMethod);
<>	156:95d6b41a828b	1164	}
<>	156:95d6b41a828b	1165
<>	156:95d6b41a828b	1166	/**
<>	156:95d6b41a828b	1167	* @brief Retrieve RX pin active level logic configuration
<>	156:95d6b41a828b	1168	* @rmtoll CR2 RXINV LL_USART_GetRXPinLevel
<>	156:95d6b41a828b	1169	* @param USARTx USART Instance
<>	156:95d6b41a828b	1170	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	1171	* @arg @ref LL_USART_RXPIN_LEVEL_STANDARD
<>	156:95d6b41a828b	1172	* @arg @ref LL_USART_RXPIN_LEVEL_INVERTED
<>	156:95d6b41a828b	1173	*/
<>	156:95d6b41a828b	1174	__STATIC_INLINE uint32_t LL_USART_GetRXPinLevel(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1175	{
<>	156:95d6b41a828b	1176	return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_RXINV));
<>	156:95d6b41a828b	1177	}
<>	156:95d6b41a828b	1178
<>	156:95d6b41a828b	1179	/**
<>	156:95d6b41a828b	1180	* @brief Configure TX pin active level logic
<>	156:95d6b41a828b	1181	* @rmtoll CR2 TXINV LL_USART_SetTXPinLevel
<>	156:95d6b41a828b	1182	* @param USARTx USART Instance
<>	156:95d6b41a828b	1183	* @param PinInvMethod This parameter can be one of the following values:
<>	156:95d6b41a828b	1184	* @arg @ref LL_USART_TXPIN_LEVEL_STANDARD
<>	156:95d6b41a828b	1185	* @arg @ref LL_USART_TXPIN_LEVEL_INVERTED
<>	156:95d6b41a828b	1186	* @retval None
<>	156:95d6b41a828b	1187	*/
<>	156:95d6b41a828b	1188	__STATIC_INLINE void LL_USART_SetTXPinLevel(USART_TypeDef *USARTx, uint32_t PinInvMethod)
<>	156:95d6b41a828b	1189	{
<>	156:95d6b41a828b	1190	MODIFY_REG(USARTx->CR2, USART_CR2_TXINV, PinInvMethod);
<>	156:95d6b41a828b	1191	}
<>	156:95d6b41a828b	1192
<>	156:95d6b41a828b	1193	/**
<>	156:95d6b41a828b	1194	* @brief Retrieve TX pin active level logic configuration
<>	156:95d6b41a828b	1195	* @rmtoll CR2 TXINV LL_USART_GetTXPinLevel
<>	156:95d6b41a828b	1196	* @param USARTx USART Instance
<>	156:95d6b41a828b	1197	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	1198	* @arg @ref LL_USART_TXPIN_LEVEL_STANDARD
<>	156:95d6b41a828b	1199	* @arg @ref LL_USART_TXPIN_LEVEL_INVERTED
<>	156:95d6b41a828b	1200	*/
<>	156:95d6b41a828b	1201	__STATIC_INLINE uint32_t LL_USART_GetTXPinLevel(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1202	{
<>	156:95d6b41a828b	1203	return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_TXINV));
<>	156:95d6b41a828b	1204	}
<>	156:95d6b41a828b	1205
<>	156:95d6b41a828b	1206	/**
<>	156:95d6b41a828b	1207	* @brief Configure Binary data logic.
<>	156:95d6b41a828b	1208	* @note Allow to define how Logical data from the data register are send/received :
<>	156:95d6b41a828b	1209	* either in positive/direct logic (1=H, 0=L) or in negative/inverse logic (1=L, 0=H)
<>	156:95d6b41a828b	1210	* @rmtoll CR2 DATAINV LL_USART_SetBinaryDataLogic
<>	156:95d6b41a828b	1211	* @param USARTx USART Instance
<>	156:95d6b41a828b	1212	* @param DataLogic This parameter can be one of the following values:
<>	156:95d6b41a828b	1213	* @arg @ref LL_USART_BINARY_LOGIC_POSITIVE
<>	156:95d6b41a828b	1214	* @arg @ref LL_USART_BINARY_LOGIC_NEGATIVE
<>	156:95d6b41a828b	1215	* @retval None
<>	156:95d6b41a828b	1216	*/
<>	156:95d6b41a828b	1217	__STATIC_INLINE void LL_USART_SetBinaryDataLogic(USART_TypeDef *USARTx, uint32_t DataLogic)
<>	156:95d6b41a828b	1218	{
<>	156:95d6b41a828b	1219	MODIFY_REG(USARTx->CR2, USART_CR2_DATAINV, DataLogic);
<>	156:95d6b41a828b	1220	}
<>	156:95d6b41a828b	1221
<>	156:95d6b41a828b	1222	/**
<>	156:95d6b41a828b	1223	* @brief Retrieve Binary data configuration
<>	156:95d6b41a828b	1224	* @rmtoll CR2 DATAINV LL_USART_GetBinaryDataLogic
<>	156:95d6b41a828b	1225	* @param USARTx USART Instance
<>	156:95d6b41a828b	1226	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	1227	* @arg @ref LL_USART_BINARY_LOGIC_POSITIVE
<>	156:95d6b41a828b	1228	* @arg @ref LL_USART_BINARY_LOGIC_NEGATIVE
<>	156:95d6b41a828b	1229	*/
<>	156:95d6b41a828b	1230	__STATIC_INLINE uint32_t LL_USART_GetBinaryDataLogic(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1231	{
<>	156:95d6b41a828b	1232	return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_DATAINV));
<>	156:95d6b41a828b	1233	}
<>	156:95d6b41a828b	1234
<>	156:95d6b41a828b	1235	/**
<>	156:95d6b41a828b	1236	* @brief Configure transfer bit order (either Less or Most Significant Bit First)
<>	156:95d6b41a828b	1237	* @note MSB First means data is transmitted/received with the MSB first, following the start bit.
<>	156:95d6b41a828b	1238	* LSB First means data is transmitted/received with data bit 0 first, following the start bit.
<>	156:95d6b41a828b	1239	* @rmtoll CR2 MSBFIRST LL_USART_SetTransferBitOrder
<>	156:95d6b41a828b	1240	* @param USARTx USART Instance
<>	156:95d6b41a828b	1241	* @param BitOrder This parameter can be one of the following values:
<>	156:95d6b41a828b	1242	* @arg @ref LL_USART_BITORDER_LSBFIRST
<>	156:95d6b41a828b	1243	* @arg @ref LL_USART_BITORDER_MSBFIRST
<>	156:95d6b41a828b	1244	* @retval None
<>	156:95d6b41a828b	1245	*/
<>	156:95d6b41a828b	1246	__STATIC_INLINE void LL_USART_SetTransferBitOrder(USART_TypeDef *USARTx, uint32_t BitOrder)
<>	156:95d6b41a828b	1247	{
<>	156:95d6b41a828b	1248	MODIFY_REG(USARTx->CR2, USART_CR2_MSBFIRST, BitOrder);
<>	156:95d6b41a828b	1249	}
<>	156:95d6b41a828b	1250
<>	156:95d6b41a828b	1251	/**
<>	156:95d6b41a828b	1252	* @brief Return transfer bit order (either Less or Most Significant Bit First)
<>	156:95d6b41a828b	1253	* @note MSB First means data is transmitted/received with the MSB first, following the start bit.
<>	156:95d6b41a828b	1254	* LSB First means data is transmitted/received with data bit 0 first, following the start bit.
<>	156:95d6b41a828b	1255	* @rmtoll CR2 MSBFIRST LL_USART_GetTransferBitOrder
<>	156:95d6b41a828b	1256	* @param USARTx USART Instance
<>	156:95d6b41a828b	1257	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	1258	* @arg @ref LL_USART_BITORDER_LSBFIRST
<>	156:95d6b41a828b	1259	* @arg @ref LL_USART_BITORDER_MSBFIRST
<>	156:95d6b41a828b	1260	*/
<>	156:95d6b41a828b	1261	__STATIC_INLINE uint32_t LL_USART_GetTransferBitOrder(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1262	{
<>	156:95d6b41a828b	1263	return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_MSBFIRST));
<>	156:95d6b41a828b	1264	}
<>	156:95d6b41a828b	1265
<>	156:95d6b41a828b	1266	/**
<>	156:95d6b41a828b	1267	* @brief Enable Auto Baud-Rate Detection
<>	156:95d6b41a828b	1268	* @note Macro @ref IS_USART_AUTOBAUDRATE_DETECTION_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1269	* Auto Baud Rate detection feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1270	* @rmtoll CR2 ABREN LL_USART_EnableAutoBaudRate
<>	156:95d6b41a828b	1271	* @param USARTx USART Instance
<>	156:95d6b41a828b	1272	* @retval None
<>	156:95d6b41a828b	1273	*/
<>	156:95d6b41a828b	1274	__STATIC_INLINE void LL_USART_EnableAutoBaudRate(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1275	{
<>	156:95d6b41a828b	1276	SET_BIT(USARTx->CR2, USART_CR2_ABREN);
<>	156:95d6b41a828b	1277	}
<>	156:95d6b41a828b	1278
<>	156:95d6b41a828b	1279	/**
<>	156:95d6b41a828b	1280	* @brief Disable Auto Baud-Rate Detection
<>	156:95d6b41a828b	1281	* @note Macro @ref IS_USART_AUTOBAUDRATE_DETECTION_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1282	* Auto Baud Rate detection feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1283	* @rmtoll CR2 ABREN LL_USART_DisableAutoBaudRate
<>	156:95d6b41a828b	1284	* @param USARTx USART Instance
<>	156:95d6b41a828b	1285	* @retval None
<>	156:95d6b41a828b	1286	*/
<>	156:95d6b41a828b	1287	__STATIC_INLINE void LL_USART_DisableAutoBaudRate(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1288	{
<>	156:95d6b41a828b	1289	CLEAR_BIT(USARTx->CR2, USART_CR2_ABREN);
<>	156:95d6b41a828b	1290	}
<>	156:95d6b41a828b	1291
<>	156:95d6b41a828b	1292	/**
<>	156:95d6b41a828b	1293	* @brief Indicate if Auto Baud-Rate Detection mechanism is enabled
<>	156:95d6b41a828b	1294	* @note Macro @ref IS_USART_AUTOBAUDRATE_DETECTION_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1295	* Auto Baud Rate detection feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1296	* @rmtoll CR2 ABREN LL_USART_IsEnabledAutoBaud
<>	156:95d6b41a828b	1297	* @param USARTx USART Instance
<>	156:95d6b41a828b	1298	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	1299	*/
<>	156:95d6b41a828b	1300	__STATIC_INLINE uint32_t LL_USART_IsEnabledAutoBaud(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1301	{
<>	156:95d6b41a828b	1302	return (READ_BIT(USARTx->CR2, USART_CR2_ABREN) == (USART_CR2_ABREN));
<>	156:95d6b41a828b	1303	}
<>	156:95d6b41a828b	1304
<>	156:95d6b41a828b	1305	/**
<>	156:95d6b41a828b	1306	* @brief Set Auto Baud-Rate mode bits
<>	156:95d6b41a828b	1307	* @note Macro @ref IS_USART_AUTOBAUDRATE_DETECTION_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1308	* Auto Baud Rate detection feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1309	* @rmtoll CR2 ABRMODE LL_USART_SetAutoBaudRateMode
<>	156:95d6b41a828b	1310	* @param USARTx USART Instance
<>	156:95d6b41a828b	1311	* @param AutoBaudRateMode This parameter can be one of the following values:
<>	156:95d6b41a828b	1312	* @arg @ref LL_USART_AUTOBAUD_DETECT_ON_STARTBIT
<>	156:95d6b41a828b	1313	* @arg @ref LL_USART_AUTOBAUD_DETECT_ON_FALLINGEDGE
<>	156:95d6b41a828b	1314	* @arg @ref LL_USART_AUTOBAUD_DETECT_ON_7F_FRAME (*)
<>	156:95d6b41a828b	1315	* @arg @ref LL_USART_AUTOBAUD_DETECT_ON_55_FRAME (*)
<>	156:95d6b41a828b	1316	*
<>	156:95d6b41a828b	1317	* (*) Values not available on all devices
<>	156:95d6b41a828b	1318	* @retval None
<>	156:95d6b41a828b	1319	*/
<>	156:95d6b41a828b	1320	__STATIC_INLINE void LL_USART_SetAutoBaudRateMode(USART_TypeDef *USARTx, uint32_t AutoBaudRateMode)
<>	156:95d6b41a828b	1321	{
<>	156:95d6b41a828b	1322	MODIFY_REG(USARTx->CR2, USART_CR2_ABRMODE, AutoBaudRateMode);
<>	156:95d6b41a828b	1323	}
<>	156:95d6b41a828b	1324
<>	156:95d6b41a828b	1325	/**
<>	156:95d6b41a828b	1326	* @brief Return Auto Baud-Rate mode
<>	156:95d6b41a828b	1327	* @note Macro @ref IS_USART_AUTOBAUDRATE_DETECTION_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1328	* Auto Baud Rate detection feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1329	* @rmtoll CR2 ABRMODE LL_USART_GetAutoBaudRateMode
<>	156:95d6b41a828b	1330	* @param USARTx USART Instance
<>	156:95d6b41a828b	1331	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	1332	* @arg @ref LL_USART_AUTOBAUD_DETECT_ON_STARTBIT
<>	156:95d6b41a828b	1333	* @arg @ref LL_USART_AUTOBAUD_DETECT_ON_FALLINGEDGE
<>	156:95d6b41a828b	1334	* @arg @ref LL_USART_AUTOBAUD_DETECT_ON_7F_FRAME (*)
<>	156:95d6b41a828b	1335	* @arg @ref LL_USART_AUTOBAUD_DETECT_ON_55_FRAME (*)
<>	156:95d6b41a828b	1336	*
<>	156:95d6b41a828b	1337	* (*) Values not available on all devices
<>	156:95d6b41a828b	1338	*/
<>	156:95d6b41a828b	1339	__STATIC_INLINE uint32_t LL_USART_GetAutoBaudRateMode(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1340	{
<>	156:95d6b41a828b	1341	return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_ABRMODE));
<>	156:95d6b41a828b	1342	}
<>	156:95d6b41a828b	1343
<>	156:95d6b41a828b	1344	/**
<>	156:95d6b41a828b	1345	* @brief Enable Receiver Timeout
<>	156:95d6b41a828b	1346	* @rmtoll CR2 RTOEN LL_USART_EnableRxTimeout
<>	156:95d6b41a828b	1347	* @param USARTx USART Instance
<>	156:95d6b41a828b	1348	* @retval None
<>	156:95d6b41a828b	1349	*/
<>	156:95d6b41a828b	1350	__STATIC_INLINE void LL_USART_EnableRxTimeout(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1351	{
<>	156:95d6b41a828b	1352	SET_BIT(USARTx->CR2, USART_CR2_RTOEN);
<>	156:95d6b41a828b	1353	}
<>	156:95d6b41a828b	1354
<>	156:95d6b41a828b	1355	/**
<>	156:95d6b41a828b	1356	* @brief Disable Receiver Timeout
<>	156:95d6b41a828b	1357	* @rmtoll CR2 RTOEN LL_USART_DisableRxTimeout
<>	156:95d6b41a828b	1358	* @param USARTx USART Instance
<>	156:95d6b41a828b	1359	* @retval None
<>	156:95d6b41a828b	1360	*/
<>	156:95d6b41a828b	1361	__STATIC_INLINE void LL_USART_DisableRxTimeout(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1362	{
<>	156:95d6b41a828b	1363	CLEAR_BIT(USARTx->CR2, USART_CR2_RTOEN);
<>	156:95d6b41a828b	1364	}
<>	156:95d6b41a828b	1365
<>	156:95d6b41a828b	1366	/**
<>	156:95d6b41a828b	1367	* @brief Indicate if Receiver Timeout feature is enabled
<>	156:95d6b41a828b	1368	* @rmtoll CR2 RTOEN LL_USART_IsEnabledRxTimeout
<>	156:95d6b41a828b	1369	* @param USARTx USART Instance
<>	156:95d6b41a828b	1370	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	1371	*/
<>	156:95d6b41a828b	1372	__STATIC_INLINE uint32_t LL_USART_IsEnabledRxTimeout(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1373	{
<>	156:95d6b41a828b	1374	return (READ_BIT(USARTx->CR2, USART_CR2_RTOEN) == (USART_CR2_RTOEN));
<>	156:95d6b41a828b	1375	}
<>	156:95d6b41a828b	1376
<>	156:95d6b41a828b	1377	/**
<>	156:95d6b41a828b	1378	* @brief Set Address of the USART node.
<>	156:95d6b41a828b	1379	* @note This is used in multiprocessor communication during Mute mode or Stop mode,
<>	156:95d6b41a828b	1380	* for wake up with address mark detection.
<>	156:95d6b41a828b	1381	* @note 4bits address node is used when 4-bit Address Detection is selected in ADDM7.
<>	156:95d6b41a828b	1382	* (b7-b4 should be set to 0)
<>	156:95d6b41a828b	1383	* 8bits address node is used when 7-bit Address Detection is selected in ADDM7.
<>	156:95d6b41a828b	1384	* (This is used in multiprocessor communication during Mute mode or Stop mode,
<>	156:95d6b41a828b	1385	* for wake up with 7-bit address mark detection.
<>	156:95d6b41a828b	1386	* The MSB of the character sent by the transmitter should be equal to 1.
<>	156:95d6b41a828b	1387	* It may also be used for character detection during normal reception,
<>	156:95d6b41a828b	1388	* Mute mode inactive (for example, end of block detection in ModBus protocol).
<>	156:95d6b41a828b	1389	* In this case, the whole received character (8-bit) is compared to the ADD[7:0]
<>	156:95d6b41a828b	1390	* value and CMF flag is set on match)
<>	156:95d6b41a828b	1391	* @rmtoll CR2 ADD LL_USART_ConfigNodeAddress\n
<>	156:95d6b41a828b	1392	* CR2 ADDM7 LL_USART_ConfigNodeAddress
<>	156:95d6b41a828b	1393	* @param USARTx USART Instance
<>	156:95d6b41a828b	1394	* @param AddressLen This parameter can be one of the following values:
<>	156:95d6b41a828b	1395	* @arg @ref LL_USART_ADDRESS_DETECT_4B
<>	156:95d6b41a828b	1396	* @arg @ref LL_USART_ADDRESS_DETECT_7B
<>	156:95d6b41a828b	1397	* @param NodeAddress 4 or 7 bit Address of the USART node.
<>	156:95d6b41a828b	1398	* @retval None
<>	156:95d6b41a828b	1399	*/
<>	156:95d6b41a828b	1400	__STATIC_INLINE void LL_USART_ConfigNodeAddress(USART_TypeDef *USARTx, uint32_t AddressLen, uint32_t NodeAddress)
<>	156:95d6b41a828b	1401	{
<>	156:95d6b41a828b	1402	MODIFY_REG(USARTx->CR2, USART_CR2_ADD \| USART_CR2_ADDM7,
<>	156:95d6b41a828b	1403	(uint32_t)(AddressLen \| (NodeAddress << USART_POSITION_CR2_ADD)));
<>	156:95d6b41a828b	1404	}
<>	156:95d6b41a828b	1405
<>	156:95d6b41a828b	1406	/**
<>	156:95d6b41a828b	1407	* @brief Return 8 bit Address of the USART node as set in ADD field of CR2.
<>	156:95d6b41a828b	1408	* @note If 4-bit Address Detection is selected in ADDM7,
<>	156:95d6b41a828b	1409	* only 4bits (b3-b0) of returned value are relevant (b31-b4 are not relevant)
<>	156:95d6b41a828b	1410	* If 7-bit Address Detection is selected in ADDM7,
<>	156:95d6b41a828b	1411	* only 8bits (b7-b0) of returned value are relevant (b31-b8 are not relevant)
<>	156:95d6b41a828b	1412	* @rmtoll CR2 ADD LL_USART_GetNodeAddress
<>	156:95d6b41a828b	1413	* @param USARTx USART Instance
<>	156:95d6b41a828b	1414	* @retval Address of the USART node (Value between Min_Data=0 and Max_Data=255)
<>	156:95d6b41a828b	1415	*/
<>	156:95d6b41a828b	1416	__STATIC_INLINE uint32_t LL_USART_GetNodeAddress(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1417	{
<>	156:95d6b41a828b	1418	return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_ADD) >> USART_POSITION_CR2_ADD);
<>	156:95d6b41a828b	1419	}
<>	156:95d6b41a828b	1420
<>	156:95d6b41a828b	1421	/**
<>	156:95d6b41a828b	1422	* @brief Return Length of Node Address used in Address Detection mode (7-bit or 4-bit)
<>	156:95d6b41a828b	1423	* @rmtoll CR2 ADDM7 LL_USART_GetNodeAddressLen
<>	156:95d6b41a828b	1424	* @param USARTx USART Instance
<>	156:95d6b41a828b	1425	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	1426	* @arg @ref LL_USART_ADDRESS_DETECT_4B
<>	156:95d6b41a828b	1427	* @arg @ref LL_USART_ADDRESS_DETECT_7B
<>	156:95d6b41a828b	1428	*/
<>	156:95d6b41a828b	1429	__STATIC_INLINE uint32_t LL_USART_GetNodeAddressLen(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1430	{
<>	156:95d6b41a828b	1431	return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_ADDM7));
<>	156:95d6b41a828b	1432	}
<>	156:95d6b41a828b	1433
<>	156:95d6b41a828b	1434	/**
<>	156:95d6b41a828b	1435	* @brief Enable RTS HW Flow Control
<>	156:95d6b41a828b	1436	* @note Macro @ref IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1437	* Hardware Flow control feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1438	* @rmtoll CR3 RTSE LL_USART_EnableRTSHWFlowCtrl
<>	156:95d6b41a828b	1439	* @param USARTx USART Instance
<>	156:95d6b41a828b	1440	* @retval None
<>	156:95d6b41a828b	1441	*/
<>	156:95d6b41a828b	1442	__STATIC_INLINE void LL_USART_EnableRTSHWFlowCtrl(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1443	{
<>	156:95d6b41a828b	1444	SET_BIT(USARTx->CR3, USART_CR3_RTSE);
<>	156:95d6b41a828b	1445	}
<>	156:95d6b41a828b	1446
<>	156:95d6b41a828b	1447	/**
<>	156:95d6b41a828b	1448	* @brief Disable RTS HW Flow Control
<>	156:95d6b41a828b	1449	* @note Macro @ref IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1450	* Hardware Flow control feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1451	* @rmtoll CR3 RTSE LL_USART_DisableRTSHWFlowCtrl
<>	156:95d6b41a828b	1452	* @param USARTx USART Instance
<>	156:95d6b41a828b	1453	* @retval None
<>	156:95d6b41a828b	1454	*/
<>	156:95d6b41a828b	1455	__STATIC_INLINE void LL_USART_DisableRTSHWFlowCtrl(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1456	{
<>	156:95d6b41a828b	1457	CLEAR_BIT(USARTx->CR3, USART_CR3_RTSE);
<>	156:95d6b41a828b	1458	}
<>	156:95d6b41a828b	1459
<>	156:95d6b41a828b	1460	/**
<>	156:95d6b41a828b	1461	* @brief Enable CTS HW Flow Control
<>	156:95d6b41a828b	1462	* @note Macro @ref IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1463	* Hardware Flow control feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1464	* @rmtoll CR3 CTSE LL_USART_EnableCTSHWFlowCtrl
<>	156:95d6b41a828b	1465	* @param USARTx USART Instance
<>	156:95d6b41a828b	1466	* @retval None
<>	156:95d6b41a828b	1467	*/
<>	156:95d6b41a828b	1468	__STATIC_INLINE void LL_USART_EnableCTSHWFlowCtrl(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1469	{
<>	156:95d6b41a828b	1470	SET_BIT(USARTx->CR3, USART_CR3_CTSE);
<>	156:95d6b41a828b	1471	}
<>	156:95d6b41a828b	1472
<>	156:95d6b41a828b	1473	/**
<>	156:95d6b41a828b	1474	* @brief Disable CTS HW Flow Control
<>	156:95d6b41a828b	1475	* @note Macro @ref IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1476	* Hardware Flow control feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1477	* @rmtoll CR3 CTSE LL_USART_DisableCTSHWFlowCtrl
<>	156:95d6b41a828b	1478	* @param USARTx USART Instance
<>	156:95d6b41a828b	1479	* @retval None
<>	156:95d6b41a828b	1480	*/
<>	156:95d6b41a828b	1481	__STATIC_INLINE void LL_USART_DisableCTSHWFlowCtrl(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1482	{
<>	156:95d6b41a828b	1483	CLEAR_BIT(USARTx->CR3, USART_CR3_CTSE);
<>	156:95d6b41a828b	1484	}
<>	156:95d6b41a828b	1485
<>	156:95d6b41a828b	1486	/**
<>	156:95d6b41a828b	1487	* @brief Configure HW Flow Control mode (both CTS and RTS)
<>	156:95d6b41a828b	1488	* @note Macro @ref IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1489	* Hardware Flow control feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1490	* @rmtoll CR3 RTSE LL_USART_SetHWFlowCtrl\n
<>	156:95d6b41a828b	1491	* CR3 CTSE LL_USART_SetHWFlowCtrl
<>	156:95d6b41a828b	1492	* @param USARTx USART Instance
<>	156:95d6b41a828b	1493	* @param HardwareFlowControl This parameter can be one of the following values:
<>	156:95d6b41a828b	1494	* @arg @ref LL_USART_HWCONTROL_NONE
<>	156:95d6b41a828b	1495	* @arg @ref LL_USART_HWCONTROL_RTS
<>	156:95d6b41a828b	1496	* @arg @ref LL_USART_HWCONTROL_CTS
<>	156:95d6b41a828b	1497	* @arg @ref LL_USART_HWCONTROL_RTS_CTS
<>	156:95d6b41a828b	1498	* @retval None
<>	156:95d6b41a828b	1499	*/
<>	156:95d6b41a828b	1500	__STATIC_INLINE void LL_USART_SetHWFlowCtrl(USART_TypeDef *USARTx, uint32_t HardwareFlowControl)
<>	156:95d6b41a828b	1501	{
<>	156:95d6b41a828b	1502	MODIFY_REG(USARTx->CR3, USART_CR3_RTSE \| USART_CR3_CTSE, HardwareFlowControl);
<>	156:95d6b41a828b	1503	}
<>	156:95d6b41a828b	1504
<>	156:95d6b41a828b	1505	/**
<>	156:95d6b41a828b	1506	* @brief Return HW Flow Control configuration (both CTS and RTS)
<>	156:95d6b41a828b	1507	* @note Macro @ref IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1508	* Hardware Flow control feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1509	* @rmtoll CR3 RTSE LL_USART_GetHWFlowCtrl\n
<>	156:95d6b41a828b	1510	* CR3 CTSE LL_USART_GetHWFlowCtrl
<>	156:95d6b41a828b	1511	* @param USARTx USART Instance
<>	156:95d6b41a828b	1512	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	1513	* @arg @ref LL_USART_HWCONTROL_NONE
<>	156:95d6b41a828b	1514	* @arg @ref LL_USART_HWCONTROL_RTS
<>	156:95d6b41a828b	1515	* @arg @ref LL_USART_HWCONTROL_CTS
<>	156:95d6b41a828b	1516	* @arg @ref LL_USART_HWCONTROL_RTS_CTS
<>	156:95d6b41a828b	1517	*/
<>	156:95d6b41a828b	1518	__STATIC_INLINE uint32_t LL_USART_GetHWFlowCtrl(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1519	{
<>	156:95d6b41a828b	1520	return (uint32_t)(READ_BIT(USARTx->CR3, USART_CR3_RTSE \| USART_CR3_CTSE));
<>	156:95d6b41a828b	1521	}
<>	156:95d6b41a828b	1522
<>	156:95d6b41a828b	1523	/**
<>	156:95d6b41a828b	1524	* @brief Enable One bit sampling method
<>	156:95d6b41a828b	1525	* @rmtoll CR3 ONEBIT LL_USART_EnableOneBitSamp
<>	156:95d6b41a828b	1526	* @param USARTx USART Instance
<>	156:95d6b41a828b	1527	* @retval None
<>	156:95d6b41a828b	1528	*/
<>	156:95d6b41a828b	1529	__STATIC_INLINE void LL_USART_EnableOneBitSamp(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1530	{
<>	156:95d6b41a828b	1531	SET_BIT(USARTx->CR3, USART_CR3_ONEBIT);
<>	156:95d6b41a828b	1532	}
<>	156:95d6b41a828b	1533
<>	156:95d6b41a828b	1534	/**
<>	156:95d6b41a828b	1535	* @brief Disable One bit sampling method
<>	156:95d6b41a828b	1536	* @rmtoll CR3 ONEBIT LL_USART_DisableOneBitSamp
<>	156:95d6b41a828b	1537	* @param USARTx USART Instance
<>	156:95d6b41a828b	1538	* @retval None
<>	156:95d6b41a828b	1539	*/
<>	156:95d6b41a828b	1540	__STATIC_INLINE void LL_USART_DisableOneBitSamp(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1541	{
<>	156:95d6b41a828b	1542	CLEAR_BIT(USARTx->CR3, USART_CR3_ONEBIT);
<>	156:95d6b41a828b	1543	}
<>	156:95d6b41a828b	1544
<>	156:95d6b41a828b	1545	/**
<>	156:95d6b41a828b	1546	* @brief Indicate if One bit sampling method is enabled
<>	156:95d6b41a828b	1547	* @rmtoll CR3 ONEBIT LL_USART_IsEnabledOneBitSamp
<>	156:95d6b41a828b	1548	* @param USARTx USART Instance
<>	156:95d6b41a828b	1549	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	1550	*/
<>	156:95d6b41a828b	1551	__STATIC_INLINE uint32_t LL_USART_IsEnabledOneBitSamp(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1552	{
<>	156:95d6b41a828b	1553	return (READ_BIT(USARTx->CR3, USART_CR3_ONEBIT) == (USART_CR3_ONEBIT));
<>	156:95d6b41a828b	1554	}
<>	156:95d6b41a828b	1555
<>	156:95d6b41a828b	1556	/**
<>	156:95d6b41a828b	1557	* @brief Enable Overrun detection
<>	156:95d6b41a828b	1558	* @rmtoll CR3 OVRDIS LL_USART_EnableOverrunDetect
<>	156:95d6b41a828b	1559	* @param USARTx USART Instance
<>	156:95d6b41a828b	1560	* @retval None
<>	156:95d6b41a828b	1561	*/
<>	156:95d6b41a828b	1562	__STATIC_INLINE void LL_USART_EnableOverrunDetect(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1563	{
<>	156:95d6b41a828b	1564	CLEAR_BIT(USARTx->CR3, USART_CR3_OVRDIS);
<>	156:95d6b41a828b	1565	}
<>	156:95d6b41a828b	1566
<>	156:95d6b41a828b	1567	/**
<>	156:95d6b41a828b	1568	* @brief Disable Overrun detection
<>	156:95d6b41a828b	1569	* @rmtoll CR3 OVRDIS LL_USART_DisableOverrunDetect
<>	156:95d6b41a828b	1570	* @param USARTx USART Instance
<>	156:95d6b41a828b	1571	* @retval None
<>	156:95d6b41a828b	1572	*/
<>	156:95d6b41a828b	1573	__STATIC_INLINE void LL_USART_DisableOverrunDetect(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1574	{
<>	156:95d6b41a828b	1575	SET_BIT(USARTx->CR3, USART_CR3_OVRDIS);
<>	156:95d6b41a828b	1576	}
<>	156:95d6b41a828b	1577
<>	156:95d6b41a828b	1578	/**
<>	156:95d6b41a828b	1579	* @brief Indicate if Overrun detection is enabled
<>	156:95d6b41a828b	1580	* @rmtoll CR3 OVRDIS LL_USART_IsEnabledOverrunDetect
<>	156:95d6b41a828b	1581	* @param USARTx USART Instance
<>	156:95d6b41a828b	1582	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	1583	*/
<>	156:95d6b41a828b	1584	__STATIC_INLINE uint32_t LL_USART_IsEnabledOverrunDetect(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1585	{
<>	156:95d6b41a828b	1586	return (READ_BIT(USARTx->CR3, USART_CR3_OVRDIS) != USART_CR3_OVRDIS);
<>	156:95d6b41a828b	1587	}
<>	156:95d6b41a828b	1588
<>	156:95d6b41a828b	1589	#if defined(USART_WUSM_SUPPORT)
<>	156:95d6b41a828b	1590	/**
<>	156:95d6b41a828b	1591	* @brief Select event type for Wake UP Interrupt Flag (WUS[1:0] bits)
<>	156:95d6b41a828b	1592	* @note Macro @ref IS_UART_WAKEUP_FROMSTOP_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1593	* Wake-up from Stop mode feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1594	* @rmtoll CR3 WUS LL_USART_SetWKUPType
<>	156:95d6b41a828b	1595	* @param USARTx USART Instance
<>	156:95d6b41a828b	1596	* @param Type This parameter can be one of the following values:
<>	156:95d6b41a828b	1597	* @arg @ref LL_USART_WAKEUP_ON_ADDRESS
<>	156:95d6b41a828b	1598	* @arg @ref LL_USART_WAKEUP_ON_STARTBIT
<>	156:95d6b41a828b	1599	* @arg @ref LL_USART_WAKEUP_ON_RXNE
<>	156:95d6b41a828b	1600	* @retval None
<>	156:95d6b41a828b	1601	*/
<>	156:95d6b41a828b	1602	__STATIC_INLINE void LL_USART_SetWKUPType(USART_TypeDef *USARTx, uint32_t Type)
<>	156:95d6b41a828b	1603	{
<>	156:95d6b41a828b	1604	MODIFY_REG(USARTx->CR3, USART_CR3_WUS, Type);
<>	156:95d6b41a828b	1605	}
<>	156:95d6b41a828b	1606
<>	156:95d6b41a828b	1607	/**
<>	156:95d6b41a828b	1608	* @brief Return event type for Wake UP Interrupt Flag (WUS[1:0] bits)
<>	156:95d6b41a828b	1609	* @note Macro @ref IS_UART_WAKEUP_FROMSTOP_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1610	* Wake-up from Stop mode feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1611	* @rmtoll CR3 WUS LL_USART_GetWKUPType
<>	156:95d6b41a828b	1612	* @param USARTx USART Instance
<>	156:95d6b41a828b	1613	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	1614	* @arg @ref LL_USART_WAKEUP_ON_ADDRESS
<>	156:95d6b41a828b	1615	* @arg @ref LL_USART_WAKEUP_ON_STARTBIT
<>	156:95d6b41a828b	1616	* @arg @ref LL_USART_WAKEUP_ON_RXNE
<>	156:95d6b41a828b	1617	*/
<>	156:95d6b41a828b	1618	__STATIC_INLINE uint32_t LL_USART_GetWKUPType(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1619	{
<>	156:95d6b41a828b	1620	return (uint32_t)(READ_BIT(USARTx->CR3, USART_CR3_WUS));
<>	156:95d6b41a828b	1621	}
<>	156:95d6b41a828b	1622	#endif
<>	156:95d6b41a828b	1623
<>	156:95d6b41a828b	1624	/**
<>	156:95d6b41a828b	1625	* @brief Configure USART BRR register for achieving expected Baud Rate value.
<>	156:95d6b41a828b	1626	* @note Compute and set USARTDIV value in BRR Register (full BRR content)
<>	156:95d6b41a828b	1627	* according to used Peripheral Clock, Oversampling mode, and expected Baud Rate values
<>	156:95d6b41a828b	1628	* @note Peripheral clock and Baud rate values provided as function parameters should be valid
<>	156:95d6b41a828b	1629	* (Baud rate value != 0)
<>	156:95d6b41a828b	1630	* @rmtoll BRR BRR LL_USART_SetBaudRate
<>	156:95d6b41a828b	1631	* @param USARTx USART Instance
<>	156:95d6b41a828b	1632	* @param PeriphClk Peripheral Clock
<>	156:95d6b41a828b	1633	* @param OverSampling This parameter can be one of the following values:
<>	156:95d6b41a828b	1634	* @arg @ref LL_USART_OVERSAMPLING_16
<>	156:95d6b41a828b	1635	* @arg @ref LL_USART_OVERSAMPLING_8
<>	156:95d6b41a828b	1636	* @param BaudRate Baud Rate
<>	156:95d6b41a828b	1637	* @retval None
<>	156:95d6b41a828b	1638	*/
<>	156:95d6b41a828b	1639	__STATIC_INLINE void LL_USART_SetBaudRate(USART_TypeDef *USARTx, uint32_t PeriphClk, uint32_t OverSampling,
<>	156:95d6b41a828b	1640	uint32_t BaudRate)
<>	156:95d6b41a828b	1641	{
<>	156:95d6b41a828b	1642	register uint32_t usartdiv = 0x0U;
<>	156:95d6b41a828b	1643	register uint32_t brrtemp = 0x0U;
<>	156:95d6b41a828b	1644
<>	156:95d6b41a828b	1645	if (OverSampling == LL_USART_OVERSAMPLING_8)
<>	156:95d6b41a828b	1646	{
<>	156:95d6b41a828b	1647	usartdiv = (uint16_t)(__LL_USART_DIV_SAMPLING8(PeriphClk, BaudRate));
<>	156:95d6b41a828b	1648	brrtemp = usartdiv & 0xFFF0U;
<>	156:95d6b41a828b	1649	brrtemp \|= (uint16_t)((usartdiv & (uint16_t)0x000FU) >> 1U);
<>	156:95d6b41a828b	1650	USARTx->BRR = brrtemp;
<>	156:95d6b41a828b	1651	}
<>	156:95d6b41a828b	1652	else
<>	156:95d6b41a828b	1653	{
<>	156:95d6b41a828b	1654	USARTx->BRR = (uint16_t)(__LL_USART_DIV_SAMPLING16(PeriphClk, BaudRate));
<>	156:95d6b41a828b	1655	}
<>	156:95d6b41a828b	1656	}
<>	156:95d6b41a828b	1657
<>	156:95d6b41a828b	1658	/**
<>	156:95d6b41a828b	1659	* @brief Return current Baud Rate value, according to USARTDIV present in BRR register
<>	156:95d6b41a828b	1660	* (full BRR content), and to used Peripheral Clock and Oversampling mode values
<>	156:95d6b41a828b	1661	* @note In case of non-initialized or invalid value stored in BRR register, value 0 will be returned.
<>	156:95d6b41a828b	1662	* @rmtoll BRR BRR LL_USART_GetBaudRate
<>	156:95d6b41a828b	1663	* @param USARTx USART Instance
<>	156:95d6b41a828b	1664	* @param PeriphClk Peripheral Clock
<>	156:95d6b41a828b	1665	* @param OverSampling This parameter can be one of the following values:
<>	156:95d6b41a828b	1666	* @arg @ref LL_USART_OVERSAMPLING_16
<>	156:95d6b41a828b	1667	* @arg @ref LL_USART_OVERSAMPLING_8
<>	156:95d6b41a828b	1668	* @retval Baud Rate
<>	156:95d6b41a828b	1669	*/
<>	156:95d6b41a828b	1670	__STATIC_INLINE uint32_t LL_USART_GetBaudRate(USART_TypeDef *USARTx, uint32_t PeriphClk, uint32_t OverSampling)
<>	156:95d6b41a828b	1671	{
<>	156:95d6b41a828b	1672	register uint32_t usartdiv = 0x0U;
<>	156:95d6b41a828b	1673	register uint32_t brrresult = 0x0U;
<>	156:95d6b41a828b	1674
<>	156:95d6b41a828b	1675	usartdiv = USARTx->BRR;
<>	156:95d6b41a828b	1676
<>	156:95d6b41a828b	1677	if (OverSampling == LL_USART_OVERSAMPLING_8)
<>	156:95d6b41a828b	1678	{
<>	156:95d6b41a828b	1679	if ((usartdiv & 0xFFF7U) != 0U)
<>	156:95d6b41a828b	1680	{
<>	156:95d6b41a828b	1681	usartdiv = (uint16_t)((usartdiv & 0xFFF0U) \| ((usartdiv & 0x0007U) << 1U)) ;
<>	156:95d6b41a828b	1682	brrresult = (PeriphClk * 2U) / usartdiv;
<>	156:95d6b41a828b	1683	}
<>	156:95d6b41a828b	1684	}
<>	156:95d6b41a828b	1685	else
<>	156:95d6b41a828b	1686	{
<>	156:95d6b41a828b	1687	if ((usartdiv & 0xFFFFU) != 0U)
<>	156:95d6b41a828b	1688	{
<>	156:95d6b41a828b	1689	brrresult = PeriphClk / usartdiv;
<>	156:95d6b41a828b	1690	}
<>	156:95d6b41a828b	1691	}
<>	156:95d6b41a828b	1692	return (brrresult);
<>	156:95d6b41a828b	1693	}
<>	156:95d6b41a828b	1694
<>	156:95d6b41a828b	1695	/**
<>	156:95d6b41a828b	1696	* @brief Set Receiver Time Out Value (expressed in nb of bits duration)
<>	156:95d6b41a828b	1697	* @rmtoll RTOR RTO LL_USART_SetRxTimeout
<>	156:95d6b41a828b	1698	* @param USARTx USART Instance
<>	156:95d6b41a828b	1699	* @param Timeout Value between Min_Data=0x00 and Max_Data=0x00FFFFFF
<>	156:95d6b41a828b	1700	* @retval None
<>	156:95d6b41a828b	1701	*/
<>	156:95d6b41a828b	1702	__STATIC_INLINE void LL_USART_SetRxTimeout(USART_TypeDef *USARTx, uint32_t Timeout)
<>	156:95d6b41a828b	1703	{
<>	156:95d6b41a828b	1704	MODIFY_REG(USARTx->RTOR, USART_RTOR_RTO, Timeout);
<>	156:95d6b41a828b	1705	}
<>	156:95d6b41a828b	1706
<>	156:95d6b41a828b	1707	/**
<>	156:95d6b41a828b	1708	* @brief Get Receiver Time Out Value (expressed in nb of bits duration)
<>	156:95d6b41a828b	1709	* @rmtoll RTOR RTO LL_USART_GetRxTimeout
<>	156:95d6b41a828b	1710	* @param USARTx USART Instance
<>	156:95d6b41a828b	1711	* @retval Value between Min_Data=0x00 and Max_Data=0x00FFFFFF
<>	156:95d6b41a828b	1712	*/
<>	156:95d6b41a828b	1713	__STATIC_INLINE uint32_t LL_USART_GetRxTimeout(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1714	{
<>	156:95d6b41a828b	1715	return (uint32_t)(READ_BIT(USARTx->RTOR, USART_RTOR_RTO));
<>	156:95d6b41a828b	1716	}
<>	156:95d6b41a828b	1717
<>	156:95d6b41a828b	1718	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	1719	/**
<>	156:95d6b41a828b	1720	* @brief Set Block Length value in reception
<>	156:95d6b41a828b	1721	* @rmtoll RTOR BLEN LL_USART_SetBlockLength
<>	156:95d6b41a828b	1722	* @param USARTx USART Instance
<>	156:95d6b41a828b	1723	* @param BlockLength Value between Min_Data=0x00 and Max_Data=0xFF
<>	156:95d6b41a828b	1724	* @retval None
<>	156:95d6b41a828b	1725	*/
<>	156:95d6b41a828b	1726	__STATIC_INLINE void LL_USART_SetBlockLength(USART_TypeDef *USARTx, uint32_t BlockLength)
<>	156:95d6b41a828b	1727	{
<>	156:95d6b41a828b	1728	MODIFY_REG(USARTx->RTOR, USART_RTOR_BLEN, BlockLength << USART_POSITION_RTOR_BLEN);
<>	156:95d6b41a828b	1729	}
<>	156:95d6b41a828b	1730
<>	156:95d6b41a828b	1731	/**
<>	156:95d6b41a828b	1732	* @brief Get Block Length value in reception
<>	156:95d6b41a828b	1733	* @rmtoll RTOR BLEN LL_USART_GetBlockLength
<>	156:95d6b41a828b	1734	* @param USARTx USART Instance
<>	156:95d6b41a828b	1735	* @retval Value between Min_Data=0x00 and Max_Data=0xFF
<>	156:95d6b41a828b	1736	*/
<>	156:95d6b41a828b	1737	__STATIC_INLINE uint32_t LL_USART_GetBlockLength(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1738	{
<>	156:95d6b41a828b	1739	return (uint32_t)(READ_BIT(USARTx->RTOR, USART_RTOR_BLEN) >> USART_POSITION_RTOR_BLEN);
<>	156:95d6b41a828b	1740	}
<>	156:95d6b41a828b	1741	#endif
<>	156:95d6b41a828b	1742
<>	156:95d6b41a828b	1743	/**
<>	156:95d6b41a828b	1744	* @}
<>	156:95d6b41a828b	1745	*/
<>	156:95d6b41a828b	1746
<>	156:95d6b41a828b	1747	#if defined(USART_IRDA_SUPPORT)
<>	156:95d6b41a828b	1748	/** @defgroup USART_LL_EF_Configuration_IRDA Configuration functions related to Irda feature
<>	156:95d6b41a828b	1749	* @{
<>	156:95d6b41a828b	1750	*/
<>	156:95d6b41a828b	1751
<>	156:95d6b41a828b	1752	/**
<>	156:95d6b41a828b	1753	* @brief Enable IrDA mode
<>	156:95d6b41a828b	1754	* @note Macro @ref IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1755	* IrDA feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1756	* @rmtoll CR3 IREN LL_USART_EnableIrda
<>	156:95d6b41a828b	1757	* @param USARTx USART Instance
<>	156:95d6b41a828b	1758	* @retval None
<>	156:95d6b41a828b	1759	*/
<>	156:95d6b41a828b	1760	__STATIC_INLINE void LL_USART_EnableIrda(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1761	{
<>	156:95d6b41a828b	1762	SET_BIT(USARTx->CR3, USART_CR3_IREN);
<>	156:95d6b41a828b	1763	}
<>	156:95d6b41a828b	1764
<>	156:95d6b41a828b	1765	/**
<>	156:95d6b41a828b	1766	* @brief Disable IrDA mode
<>	156:95d6b41a828b	1767	* @note Macro @ref IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1768	* IrDA feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1769	* @rmtoll CR3 IREN LL_USART_DisableIrda
<>	156:95d6b41a828b	1770	* @param USARTx USART Instance
<>	156:95d6b41a828b	1771	* @retval None
<>	156:95d6b41a828b	1772	*/
<>	156:95d6b41a828b	1773	__STATIC_INLINE void LL_USART_DisableIrda(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1774	{
<>	156:95d6b41a828b	1775	CLEAR_BIT(USARTx->CR3, USART_CR3_IREN);
<>	156:95d6b41a828b	1776	}
<>	156:95d6b41a828b	1777
<>	156:95d6b41a828b	1778	/**
<>	156:95d6b41a828b	1779	* @brief Indicate if IrDA mode is enabled
<>	156:95d6b41a828b	1780	* @note Macro @ref IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1781	* IrDA feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1782	* @rmtoll CR3 IREN LL_USART_IsEnabledIrda
<>	156:95d6b41a828b	1783	* @param USARTx USART Instance
<>	156:95d6b41a828b	1784	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	1785	*/
<>	156:95d6b41a828b	1786	__STATIC_INLINE uint32_t LL_USART_IsEnabledIrda(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1787	{
<>	156:95d6b41a828b	1788	return (READ_BIT(USARTx->CR3, USART_CR3_IREN) == (USART_CR3_IREN));
<>	156:95d6b41a828b	1789	}
<>	156:95d6b41a828b	1790
<>	156:95d6b41a828b	1791	/**
<>	156:95d6b41a828b	1792	* @brief Configure IrDA Power Mode (Normal or Low Power)
<>	156:95d6b41a828b	1793	* @note Macro @ref IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1794	* IrDA feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1795	* @rmtoll CR3 IRLP LL_USART_SetIrdaPowerMode
<>	156:95d6b41a828b	1796	* @param USARTx USART Instance
<>	156:95d6b41a828b	1797	* @param PowerMode This parameter can be one of the following values:
<>	156:95d6b41a828b	1798	* @arg @ref LL_USART_IRDA_POWER_NORMAL
<>	156:95d6b41a828b	1799	* @arg @ref LL_USART_IRDA_POWER_LOW
<>	156:95d6b41a828b	1800	* @retval None
<>	156:95d6b41a828b	1801	*/
<>	156:95d6b41a828b	1802	__STATIC_INLINE void LL_USART_SetIrdaPowerMode(USART_TypeDef *USARTx, uint32_t PowerMode)
<>	156:95d6b41a828b	1803	{
<>	156:95d6b41a828b	1804	MODIFY_REG(USARTx->CR3, USART_CR3_IRLP, PowerMode);
<>	156:95d6b41a828b	1805	}
<>	156:95d6b41a828b	1806
<>	156:95d6b41a828b	1807	/**
<>	156:95d6b41a828b	1808	* @brief Retrieve IrDA Power Mode configuration (Normal or Low Power)
<>	156:95d6b41a828b	1809	* @note Macro @ref IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1810	* IrDA feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1811	* @rmtoll CR3 IRLP LL_USART_GetIrdaPowerMode
<>	156:95d6b41a828b	1812	* @param USARTx USART Instance
<>	156:95d6b41a828b	1813	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	1814	* @arg @ref LL_USART_IRDA_POWER_NORMAL
<>	156:95d6b41a828b	1815	* @arg @ref LL_USART_PHASE_2EDGE
<>	156:95d6b41a828b	1816	*/
<>	156:95d6b41a828b	1817	__STATIC_INLINE uint32_t LL_USART_GetIrdaPowerMode(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1818	{
<>	156:95d6b41a828b	1819	return (uint32_t)(READ_BIT(USARTx->CR3, USART_CR3_IRLP));
<>	156:95d6b41a828b	1820	}
<>	156:95d6b41a828b	1821
<>	156:95d6b41a828b	1822	/**
<>	156:95d6b41a828b	1823	* @brief Set Irda prescaler value, used for dividing the USART clock source
<>	156:95d6b41a828b	1824	* to achieve the Irda Low Power frequency (8 bits value)
<>	156:95d6b41a828b	1825	* @note Macro @ref IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1826	* IrDA feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1827	* @rmtoll GTPR PSC LL_USART_SetIrdaPrescaler
<>	156:95d6b41a828b	1828	* @param USARTx USART Instance
<>	156:95d6b41a828b	1829	* @param PrescalerValue Value between Min_Data=0x00 and Max_Data=0xFF
<>	156:95d6b41a828b	1830	* @retval None
<>	156:95d6b41a828b	1831	*/
<>	156:95d6b41a828b	1832	__STATIC_INLINE void LL_USART_SetIrdaPrescaler(USART_TypeDef *USARTx, uint32_t PrescalerValue)
<>	156:95d6b41a828b	1833	{
<>	156:95d6b41a828b	1834	MODIFY_REG(USARTx->GTPR, USART_GTPR_PSC, PrescalerValue);
<>	156:95d6b41a828b	1835	}
<>	156:95d6b41a828b	1836
<>	156:95d6b41a828b	1837	/**
<>	156:95d6b41a828b	1838	* @brief Return Irda prescaler value, used for dividing the USART clock source
<>	156:95d6b41a828b	1839	* to achieve the Irda Low Power frequency (8 bits value)
<>	156:95d6b41a828b	1840	* @note Macro @ref IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1841	* IrDA feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1842	* @rmtoll GTPR PSC LL_USART_GetIrdaPrescaler
<>	156:95d6b41a828b	1843	* @param USARTx USART Instance
<>	156:95d6b41a828b	1844	* @retval Irda prescaler value (Value between Min_Data=0x00 and Max_Data=0xFF)
<>	156:95d6b41a828b	1845	*/
<>	156:95d6b41a828b	1846	__STATIC_INLINE uint32_t LL_USART_GetIrdaPrescaler(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1847	{
<>	156:95d6b41a828b	1848	return (uint32_t)(READ_BIT(USARTx->GTPR, USART_GTPR_PSC));
<>	156:95d6b41a828b	1849	}
<>	156:95d6b41a828b	1850
<>	156:95d6b41a828b	1851	/**
<>	156:95d6b41a828b	1852	* @}
<>	156:95d6b41a828b	1853	*/
<>	156:95d6b41a828b	1854	#endif
<>	156:95d6b41a828b	1855
<>	156:95d6b41a828b	1856	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	1857	/** @defgroup USART_LL_EF_Configuration_Smartcard Configuration functions related to Smartcard feature
<>	156:95d6b41a828b	1858	* @{
<>	156:95d6b41a828b	1859	*/
<>	156:95d6b41a828b	1860
<>	156:95d6b41a828b	1861	/**
<>	156:95d6b41a828b	1862	* @brief Enable Smartcard NACK transmission
<>	156:95d6b41a828b	1863	* @note Macro @ref IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1864	* Smartcard feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1865	* @rmtoll CR3 NACK LL_USART_EnableSmartcardNACK
<>	156:95d6b41a828b	1866	* @param USARTx USART Instance
<>	156:95d6b41a828b	1867	* @retval None
<>	156:95d6b41a828b	1868	*/
<>	156:95d6b41a828b	1869	__STATIC_INLINE void LL_USART_EnableSmartcardNACK(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1870	{
<>	156:95d6b41a828b	1871	SET_BIT(USARTx->CR3, USART_CR3_NACK);
<>	156:95d6b41a828b	1872	}
<>	156:95d6b41a828b	1873
<>	156:95d6b41a828b	1874	/**
<>	156:95d6b41a828b	1875	* @brief Disable Smartcard NACK transmission
<>	156:95d6b41a828b	1876	* @note Macro @ref IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1877	* Smartcard feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1878	* @rmtoll CR3 NACK LL_USART_DisableSmartcardNACK
<>	156:95d6b41a828b	1879	* @param USARTx USART Instance
<>	156:95d6b41a828b	1880	* @retval None
<>	156:95d6b41a828b	1881	*/
<>	156:95d6b41a828b	1882	__STATIC_INLINE void LL_USART_DisableSmartcardNACK(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1883	{
<>	156:95d6b41a828b	1884	CLEAR_BIT(USARTx->CR3, USART_CR3_NACK);
<>	156:95d6b41a828b	1885	}
<>	156:95d6b41a828b	1886
<>	156:95d6b41a828b	1887	/**
<>	156:95d6b41a828b	1888	* @brief Indicate if Smartcard NACK transmission is enabled
<>	156:95d6b41a828b	1889	* @note Macro @ref IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1890	* Smartcard feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1891	* @rmtoll CR3 NACK LL_USART_IsEnabledSmartcardNACK
<>	156:95d6b41a828b	1892	* @param USARTx USART Instance
<>	156:95d6b41a828b	1893	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	1894	*/
<>	156:95d6b41a828b	1895	__STATIC_INLINE uint32_t LL_USART_IsEnabledSmartcardNACK(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1896	{
<>	156:95d6b41a828b	1897	return (READ_BIT(USARTx->CR3, USART_CR3_NACK) == (USART_CR3_NACK));
<>	156:95d6b41a828b	1898	}
<>	156:95d6b41a828b	1899
<>	156:95d6b41a828b	1900	/**
<>	156:95d6b41a828b	1901	* @brief Enable Smartcard mode
<>	156:95d6b41a828b	1902	* @note Macro @ref IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1903	* Smartcard feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1904	* @rmtoll CR3 SCEN LL_USART_EnableSmartcard
<>	156:95d6b41a828b	1905	* @param USARTx USART Instance
<>	156:95d6b41a828b	1906	* @retval None
<>	156:95d6b41a828b	1907	*/
<>	156:95d6b41a828b	1908	__STATIC_INLINE void LL_USART_EnableSmartcard(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1909	{
<>	156:95d6b41a828b	1910	SET_BIT(USARTx->CR3, USART_CR3_SCEN);
<>	156:95d6b41a828b	1911	}
<>	156:95d6b41a828b	1912
<>	156:95d6b41a828b	1913	/**
<>	156:95d6b41a828b	1914	* @brief Disable Smartcard mode
<>	156:95d6b41a828b	1915	* @note Macro @ref IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1916	* Smartcard feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1917	* @rmtoll CR3 SCEN LL_USART_DisableSmartcard
<>	156:95d6b41a828b	1918	* @param USARTx USART Instance
<>	156:95d6b41a828b	1919	* @retval None
<>	156:95d6b41a828b	1920	*/
<>	156:95d6b41a828b	1921	__STATIC_INLINE void LL_USART_DisableSmartcard(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1922	{
<>	156:95d6b41a828b	1923	CLEAR_BIT(USARTx->CR3, USART_CR3_SCEN);
<>	156:95d6b41a828b	1924	}
<>	156:95d6b41a828b	1925
<>	156:95d6b41a828b	1926	/**
<>	156:95d6b41a828b	1927	* @brief Indicate if Smartcard mode is enabled
<>	156:95d6b41a828b	1928	* @note Macro @ref IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1929	* Smartcard feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1930	* @rmtoll CR3 SCEN LL_USART_IsEnabledSmartcard
<>	156:95d6b41a828b	1931	* @param USARTx USART Instance
<>	156:95d6b41a828b	1932	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	1933	*/
<>	156:95d6b41a828b	1934	__STATIC_INLINE uint32_t LL_USART_IsEnabledSmartcard(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1935	{
<>	156:95d6b41a828b	1936	return (READ_BIT(USARTx->CR3, USART_CR3_SCEN) == (USART_CR3_SCEN));
<>	156:95d6b41a828b	1937	}
<>	156:95d6b41a828b	1938
<>	156:95d6b41a828b	1939	/**
<>	156:95d6b41a828b	1940	* @brief Set Smartcard Auto-Retry Count value (SCARCNT[2:0] bits)
<>	156:95d6b41a828b	1941	* @note Macro @ref IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1942	* Smartcard feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1943	* @note This bit-field specifies the number of retries in transmit and receive, in Smartcard mode.
<>	156:95d6b41a828b	1944	* In transmission mode, it specifies the number of automatic retransmission retries, before
<>	156:95d6b41a828b	1945	* generating a transmission error (FE bit set).
<>	156:95d6b41a828b	1946	* In reception mode, it specifies the number or erroneous reception trials, before generating a
<>	156:95d6b41a828b	1947	* reception error (RXNE and PE bits set)
<>	156:95d6b41a828b	1948	* @rmtoll CR3 SCARCNT LL_USART_SetSmartcardAutoRetryCount
<>	156:95d6b41a828b	1949	* @param USARTx USART Instance
<>	156:95d6b41a828b	1950	* @param AutoRetryCount Value between Min_Data=0 and Max_Data=7
<>	156:95d6b41a828b	1951	* @retval None
<>	156:95d6b41a828b	1952	*/
<>	156:95d6b41a828b	1953	__STATIC_INLINE void LL_USART_SetSmartcardAutoRetryCount(USART_TypeDef *USARTx, uint32_t AutoRetryCount)
<>	156:95d6b41a828b	1954	{
<>	156:95d6b41a828b	1955	MODIFY_REG(USARTx->CR3, USART_CR3_SCARCNT, AutoRetryCount << USART_POSITION_CR3_SCARCNT);
<>	156:95d6b41a828b	1956	}
<>	156:95d6b41a828b	1957
<>	156:95d6b41a828b	1958	/**
<>	156:95d6b41a828b	1959	* @brief Return Smartcard Auto-Retry Count value (SCARCNT[2:0] bits)
<>	156:95d6b41a828b	1960	* @note Macro @ref IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1961	* Smartcard feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1962	* @rmtoll CR3 SCARCNT LL_USART_GetSmartcardAutoRetryCount
<>	156:95d6b41a828b	1963	* @param USARTx USART Instance
<>	156:95d6b41a828b	1964	* @retval Smartcard Auto-Retry Count value (Value between Min_Data=0 and Max_Data=7)
<>	156:95d6b41a828b	1965	*/
<>	156:95d6b41a828b	1966	__STATIC_INLINE uint32_t LL_USART_GetSmartcardAutoRetryCount(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1967	{
<>	156:95d6b41a828b	1968	return (uint32_t)(READ_BIT(USARTx->CR3, USART_CR3_SCARCNT) >> USART_POSITION_CR3_SCARCNT);
<>	156:95d6b41a828b	1969	}
<>	156:95d6b41a828b	1970
<>	156:95d6b41a828b	1971	/**
<>	156:95d6b41a828b	1972	* @brief Set Smartcard prescaler value, used for dividing the USART clock
<>	156:95d6b41a828b	1973	* source to provide the SMARTCARD Clock (5 bits value)
<>	156:95d6b41a828b	1974	* @note Macro @ref IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1975	* Smartcard feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1976	* @rmtoll GTPR PSC LL_USART_SetSmartcardPrescaler
<>	156:95d6b41a828b	1977	* @param USARTx USART Instance
<>	156:95d6b41a828b	1978	* @param PrescalerValue Value between Min_Data=0 and Max_Data=31
<>	156:95d6b41a828b	1979	* @retval None
<>	156:95d6b41a828b	1980	*/
<>	156:95d6b41a828b	1981	__STATIC_INLINE void LL_USART_SetSmartcardPrescaler(USART_TypeDef *USARTx, uint32_t PrescalerValue)
<>	156:95d6b41a828b	1982	{
<>	156:95d6b41a828b	1983	MODIFY_REG(USARTx->GTPR, USART_GTPR_PSC, PrescalerValue);
<>	156:95d6b41a828b	1984	}
<>	156:95d6b41a828b	1985
<>	156:95d6b41a828b	1986	/**
<>	156:95d6b41a828b	1987	* @brief Return Smartcard prescaler value, used for dividing the USART clock
<>	156:95d6b41a828b	1988	* source to provide the SMARTCARD Clock (5 bits value)
<>	156:95d6b41a828b	1989	* @note Macro @ref IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	1990	* Smartcard feature is supported by the USARTx instance.
<>	156:95d6b41a828b	1991	* @rmtoll GTPR PSC LL_USART_GetSmartcardPrescaler
<>	156:95d6b41a828b	1992	* @param USARTx USART Instance
<>	156:95d6b41a828b	1993	* @retval Smartcard prescaler value (Value between Min_Data=0 and Max_Data=31)
<>	156:95d6b41a828b	1994	*/
<>	156:95d6b41a828b	1995	__STATIC_INLINE uint32_t LL_USART_GetSmartcardPrescaler(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	1996	{
<>	156:95d6b41a828b	1997	return (uint32_t)(READ_BIT(USARTx->GTPR, USART_GTPR_PSC));
<>	156:95d6b41a828b	1998	}
<>	156:95d6b41a828b	1999
<>	156:95d6b41a828b	2000	/**
<>	156:95d6b41a828b	2001	* @brief Set Smartcard Guard time value, expressed in nb of baud clocks periods
<>	156:95d6b41a828b	2002	* (GT[7:0] bits : Guard time value)
<>	156:95d6b41a828b	2003	* @note Macro @ref IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2004	* Smartcard feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2005	* @rmtoll GTPR GT LL_USART_SetSmartcardGuardTime
<>	156:95d6b41a828b	2006	* @param USARTx USART Instance
<>	156:95d6b41a828b	2007	* @param GuardTime Value between Min_Data=0x00 and Max_Data=0xFF
<>	156:95d6b41a828b	2008	* @retval None
<>	156:95d6b41a828b	2009	*/
<>	156:95d6b41a828b	2010	__STATIC_INLINE void LL_USART_SetSmartcardGuardTime(USART_TypeDef *USARTx, uint32_t GuardTime)
<>	156:95d6b41a828b	2011	{
<>	156:95d6b41a828b	2012	MODIFY_REG(USARTx->GTPR, USART_GTPR_GT, GuardTime << USART_POSITION_GTPR_GT);
<>	156:95d6b41a828b	2013	}
<>	156:95d6b41a828b	2014
<>	156:95d6b41a828b	2015	/**
<>	156:95d6b41a828b	2016	* @brief Return Smartcard Guard time value, expressed in nb of baud clocks periods
<>	156:95d6b41a828b	2017	* (GT[7:0] bits : Guard time value)
<>	156:95d6b41a828b	2018	* @note Macro @ref IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2019	* Smartcard feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2020	* @rmtoll GTPR GT LL_USART_GetSmartcardGuardTime
<>	156:95d6b41a828b	2021	* @param USARTx USART Instance
<>	156:95d6b41a828b	2022	* @retval Smartcard Guard time value (Value between Min_Data=0x00 and Max_Data=0xFF)
<>	156:95d6b41a828b	2023	*/
<>	156:95d6b41a828b	2024	__STATIC_INLINE uint32_t LL_USART_GetSmartcardGuardTime(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2025	{
<>	156:95d6b41a828b	2026	return (uint32_t)(READ_BIT(USARTx->GTPR, USART_GTPR_GT) >> USART_POSITION_GTPR_GT);
<>	156:95d6b41a828b	2027	}
<>	156:95d6b41a828b	2028
<>	156:95d6b41a828b	2029	/**
<>	156:95d6b41a828b	2030	* @}
<>	156:95d6b41a828b	2031	*/
<>	156:95d6b41a828b	2032	#endif
<>	156:95d6b41a828b	2033
<>	156:95d6b41a828b	2034	/** @defgroup USART_LL_EF_Configuration_HalfDuplex Configuration functions related to Half Duplex feature
<>	156:95d6b41a828b	2035	* @{
<>	156:95d6b41a828b	2036	*/
<>	156:95d6b41a828b	2037
<>	156:95d6b41a828b	2038	/**
<>	156:95d6b41a828b	2039	* @brief Enable Single Wire Half-Duplex mode
<>	156:95d6b41a828b	2040	* @note Macro @ref IS_UART_HALFDUPLEX_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2041	* Half-Duplex mode is supported by the USARTx instance.
<>	156:95d6b41a828b	2042	* @rmtoll CR3 HDSEL LL_USART_EnableHalfDuplex
<>	156:95d6b41a828b	2043	* @param USARTx USART Instance
<>	156:95d6b41a828b	2044	* @retval None
<>	156:95d6b41a828b	2045	*/
<>	156:95d6b41a828b	2046	__STATIC_INLINE void LL_USART_EnableHalfDuplex(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2047	{
<>	156:95d6b41a828b	2048	SET_BIT(USARTx->CR3, USART_CR3_HDSEL);
<>	156:95d6b41a828b	2049	}
<>	156:95d6b41a828b	2050
<>	156:95d6b41a828b	2051	/**
<>	156:95d6b41a828b	2052	* @brief Disable Single Wire Half-Duplex mode
<>	156:95d6b41a828b	2053	* @note Macro @ref IS_UART_HALFDUPLEX_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2054	* Half-Duplex mode is supported by the USARTx instance.
<>	156:95d6b41a828b	2055	* @rmtoll CR3 HDSEL LL_USART_DisableHalfDuplex
<>	156:95d6b41a828b	2056	* @param USARTx USART Instance
<>	156:95d6b41a828b	2057	* @retval None
<>	156:95d6b41a828b	2058	*/
<>	156:95d6b41a828b	2059	__STATIC_INLINE void LL_USART_DisableHalfDuplex(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2060	{
<>	156:95d6b41a828b	2061	CLEAR_BIT(USARTx->CR3, USART_CR3_HDSEL);
<>	156:95d6b41a828b	2062	}
<>	156:95d6b41a828b	2063
<>	156:95d6b41a828b	2064	/**
<>	156:95d6b41a828b	2065	* @brief Indicate if Single Wire Half-Duplex mode is enabled
<>	156:95d6b41a828b	2066	* @note Macro @ref IS_UART_HALFDUPLEX_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2067	* Half-Duplex mode is supported by the USARTx instance.
<>	156:95d6b41a828b	2068	* @rmtoll CR3 HDSEL LL_USART_IsEnabledHalfDuplex
<>	156:95d6b41a828b	2069	* @param USARTx USART Instance
<>	156:95d6b41a828b	2070	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2071	*/
<>	156:95d6b41a828b	2072	__STATIC_INLINE uint32_t LL_USART_IsEnabledHalfDuplex(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2073	{
<>	156:95d6b41a828b	2074	return (READ_BIT(USARTx->CR3, USART_CR3_HDSEL) == (USART_CR3_HDSEL));
<>	156:95d6b41a828b	2075	}
<>	156:95d6b41a828b	2076
<>	156:95d6b41a828b	2077	/**
<>	156:95d6b41a828b	2078	* @}
<>	156:95d6b41a828b	2079	*/
<>	156:95d6b41a828b	2080
<>	156:95d6b41a828b	2081	#if defined(USART_LIN_SUPPORT)
<>	156:95d6b41a828b	2082	/** @defgroup USART_LL_EF_Configuration_LIN Configuration functions related to LIN feature
<>	156:95d6b41a828b	2083	* @{
<>	156:95d6b41a828b	2084	*/
<>	156:95d6b41a828b	2085
<>	156:95d6b41a828b	2086	/**
<>	156:95d6b41a828b	2087	* @brief Set LIN Break Detection Length
<>	156:95d6b41a828b	2088	* @note Macro @ref IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2089	* LIN feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2090	* @rmtoll CR2 LBDL LL_USART_SetLINBrkDetectionLen
<>	156:95d6b41a828b	2091	* @param USARTx USART Instance
<>	156:95d6b41a828b	2092	* @param LINBDLength This parameter can be one of the following values:
<>	156:95d6b41a828b	2093	* @arg @ref LL_USART_LINBREAK_DETECT_10B
<>	156:95d6b41a828b	2094	* @arg @ref LL_USART_LINBREAK_DETECT_11B
<>	156:95d6b41a828b	2095	* @retval None
<>	156:95d6b41a828b	2096	*/
<>	156:95d6b41a828b	2097	__STATIC_INLINE void LL_USART_SetLINBrkDetectionLen(USART_TypeDef *USARTx, uint32_t LINBDLength)
<>	156:95d6b41a828b	2098	{
<>	156:95d6b41a828b	2099	MODIFY_REG(USARTx->CR2, USART_CR2_LBDL, LINBDLength);
<>	156:95d6b41a828b	2100	}
<>	156:95d6b41a828b	2101
<>	156:95d6b41a828b	2102	/**
<>	156:95d6b41a828b	2103	* @brief Return LIN Break Detection Length
<>	156:95d6b41a828b	2104	* @note Macro @ref IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2105	* LIN feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2106	* @rmtoll CR2 LBDL LL_USART_GetLINBrkDetectionLen
<>	156:95d6b41a828b	2107	* @param USARTx USART Instance
<>	156:95d6b41a828b	2108	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	2109	* @arg @ref LL_USART_LINBREAK_DETECT_10B
<>	156:95d6b41a828b	2110	* @arg @ref LL_USART_LINBREAK_DETECT_11B
<>	156:95d6b41a828b	2111	*/
<>	156:95d6b41a828b	2112	__STATIC_INLINE uint32_t LL_USART_GetLINBrkDetectionLen(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2113	{
<>	156:95d6b41a828b	2114	return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_LBDL));
<>	156:95d6b41a828b	2115	}
<>	156:95d6b41a828b	2116
<>	156:95d6b41a828b	2117	/**
<>	156:95d6b41a828b	2118	* @brief Enable LIN mode
<>	156:95d6b41a828b	2119	* @note Macro @ref IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2120	* LIN feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2121	* @rmtoll CR2 LINEN LL_USART_EnableLIN
<>	156:95d6b41a828b	2122	* @param USARTx USART Instance
<>	156:95d6b41a828b	2123	* @retval None
<>	156:95d6b41a828b	2124	*/
<>	156:95d6b41a828b	2125	__STATIC_INLINE void LL_USART_EnableLIN(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2126	{
<>	156:95d6b41a828b	2127	SET_BIT(USARTx->CR2, USART_CR2_LINEN);
<>	156:95d6b41a828b	2128	}
<>	156:95d6b41a828b	2129
<>	156:95d6b41a828b	2130	/**
<>	156:95d6b41a828b	2131	* @brief Disable LIN mode
<>	156:95d6b41a828b	2132	* @note Macro @ref IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2133	* LIN feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2134	* @rmtoll CR2 LINEN LL_USART_DisableLIN
<>	156:95d6b41a828b	2135	* @param USARTx USART Instance
<>	156:95d6b41a828b	2136	* @retval None
<>	156:95d6b41a828b	2137	*/
<>	156:95d6b41a828b	2138	__STATIC_INLINE void LL_USART_DisableLIN(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2139	{
<>	156:95d6b41a828b	2140	CLEAR_BIT(USARTx->CR2, USART_CR2_LINEN);
<>	156:95d6b41a828b	2141	}
<>	156:95d6b41a828b	2142
<>	156:95d6b41a828b	2143	/**
<>	156:95d6b41a828b	2144	* @brief Indicate if LIN mode is enabled
<>	156:95d6b41a828b	2145	* @note Macro @ref IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2146	* LIN feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2147	* @rmtoll CR2 LINEN LL_USART_IsEnabledLIN
<>	156:95d6b41a828b	2148	* @param USARTx USART Instance
<>	156:95d6b41a828b	2149	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2150	*/
<>	156:95d6b41a828b	2151	__STATIC_INLINE uint32_t LL_USART_IsEnabledLIN(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2152	{
<>	156:95d6b41a828b	2153	return (READ_BIT(USARTx->CR2, USART_CR2_LINEN) == (USART_CR2_LINEN));
<>	156:95d6b41a828b	2154	}
<>	156:95d6b41a828b	2155
<>	156:95d6b41a828b	2156	/**
<>	156:95d6b41a828b	2157	* @}
<>	156:95d6b41a828b	2158	*/
<>	156:95d6b41a828b	2159	#endif
<>	156:95d6b41a828b	2160
<>	156:95d6b41a828b	2161	/** @defgroup USART_LL_EF_Configuration_DE Configuration functions related to Driver Enable feature
<>	156:95d6b41a828b	2162	* @{
<>	156:95d6b41a828b	2163	*/
<>	156:95d6b41a828b	2164
<>	156:95d6b41a828b	2165	/**
<>	156:95d6b41a828b	2166	* @brief Set DEDT (Driver Enable De-Assertion Time), Time value expressed on 5 bits ([4:0] bits).
<>	156:95d6b41a828b	2167	* @note Macro @ref IS_UART_DRIVER_ENABLE_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2168	* Driver Enable feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2169	* @rmtoll CR1 DEDT LL_USART_SetDEDeassertionTime
<>	156:95d6b41a828b	2170	* @param USARTx USART Instance
<>	156:95d6b41a828b	2171	* @param Time Value between Min_Data=0 and Max_Data=31
<>	156:95d6b41a828b	2172	* @retval None
<>	156:95d6b41a828b	2173	*/
<>	156:95d6b41a828b	2174	__STATIC_INLINE void LL_USART_SetDEDeassertionTime(USART_TypeDef *USARTx, uint32_t Time)
<>	156:95d6b41a828b	2175	{
<>	156:95d6b41a828b	2176	MODIFY_REG(USARTx->CR1, USART_CR1_DEDT, Time << USART_POSITION_CR1_DEDT);
<>	156:95d6b41a828b	2177	}
<>	156:95d6b41a828b	2178
<>	156:95d6b41a828b	2179	/**
<>	156:95d6b41a828b	2180	* @brief Return DEDT (Driver Enable De-Assertion Time)
<>	156:95d6b41a828b	2181	* @note Macro @ref IS_UART_DRIVER_ENABLE_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2182	* Driver Enable feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2183	* @rmtoll CR1 DEDT LL_USART_GetDEDeassertionTime
<>	156:95d6b41a828b	2184	* @param USARTx USART Instance
<>	156:95d6b41a828b	2185	* @retval Time value expressed on 5 bits ([4:0] bits) : Value between Min_Data=0 and Max_Data=31
<>	156:95d6b41a828b	2186	*/
<>	156:95d6b41a828b	2187	__STATIC_INLINE uint32_t LL_USART_GetDEDeassertionTime(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2188	{
<>	156:95d6b41a828b	2189	return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_DEDT) >> USART_POSITION_CR1_DEDT);
<>	156:95d6b41a828b	2190	}
<>	156:95d6b41a828b	2191
<>	156:95d6b41a828b	2192	/**
<>	156:95d6b41a828b	2193	* @brief Set DEAT (Driver Enable Assertion Time), Time value expressed on 5 bits ([4:0] bits).
<>	156:95d6b41a828b	2194	* @note Macro @ref IS_UART_DRIVER_ENABLE_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2195	* Driver Enable feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2196	* @rmtoll CR1 DEAT LL_USART_SetDEAssertionTime
<>	156:95d6b41a828b	2197	* @param USARTx USART Instance
<>	156:95d6b41a828b	2198	* @param Time Value between Min_Data=0 and Max_Data=31
<>	156:95d6b41a828b	2199	* @retval None
<>	156:95d6b41a828b	2200	*/
<>	156:95d6b41a828b	2201	__STATIC_INLINE void LL_USART_SetDEAssertionTime(USART_TypeDef *USARTx, uint32_t Time)
<>	156:95d6b41a828b	2202	{
<>	156:95d6b41a828b	2203	MODIFY_REG(USARTx->CR1, USART_CR1_DEAT, Time << USART_POSITION_CR1_DEAT);
<>	156:95d6b41a828b	2204	}
<>	156:95d6b41a828b	2205
<>	156:95d6b41a828b	2206	/**
<>	156:95d6b41a828b	2207	* @brief Return DEAT (Driver Enable Assertion Time)
<>	156:95d6b41a828b	2208	* @note Macro @ref IS_UART_DRIVER_ENABLE_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2209	* Driver Enable feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2210	* @rmtoll CR1 DEAT LL_USART_GetDEAssertionTime
<>	156:95d6b41a828b	2211	* @param USARTx USART Instance
<>	156:95d6b41a828b	2212	* @retval Time value expressed on 5 bits ([4:0] bits) : Value between Min_Data=0 and Max_Data=31
<>	156:95d6b41a828b	2213	*/
<>	156:95d6b41a828b	2214	__STATIC_INLINE uint32_t LL_USART_GetDEAssertionTime(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2215	{
<>	156:95d6b41a828b	2216	return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_DEAT) >> USART_POSITION_CR1_DEAT);
<>	156:95d6b41a828b	2217	}
<>	156:95d6b41a828b	2218
<>	156:95d6b41a828b	2219	/**
<>	156:95d6b41a828b	2220	* @brief Enable Driver Enable (DE) Mode
<>	156:95d6b41a828b	2221	* @note Macro @ref IS_UART_DRIVER_ENABLE_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2222	* Driver Enable feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2223	* @rmtoll CR3 DEM LL_USART_EnableDEMode
<>	156:95d6b41a828b	2224	* @param USARTx USART Instance
<>	156:95d6b41a828b	2225	* @retval None
<>	156:95d6b41a828b	2226	*/
<>	156:95d6b41a828b	2227	__STATIC_INLINE void LL_USART_EnableDEMode(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2228	{
<>	156:95d6b41a828b	2229	SET_BIT(USARTx->CR3, USART_CR3_DEM);
<>	156:95d6b41a828b	2230	}
<>	156:95d6b41a828b	2231
<>	156:95d6b41a828b	2232	/**
<>	156:95d6b41a828b	2233	* @brief Disable Driver Enable (DE) Mode
<>	156:95d6b41a828b	2234	* @note Macro @ref IS_UART_DRIVER_ENABLE_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2235	* Driver Enable feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2236	* @rmtoll CR3 DEM LL_USART_DisableDEMode
<>	156:95d6b41a828b	2237	* @param USARTx USART Instance
<>	156:95d6b41a828b	2238	* @retval None
<>	156:95d6b41a828b	2239	*/
<>	156:95d6b41a828b	2240	__STATIC_INLINE void LL_USART_DisableDEMode(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2241	{
<>	156:95d6b41a828b	2242	CLEAR_BIT(USARTx->CR3, USART_CR3_DEM);
<>	156:95d6b41a828b	2243	}
<>	156:95d6b41a828b	2244
<>	156:95d6b41a828b	2245	/**
<>	156:95d6b41a828b	2246	* @brief Indicate if Driver Enable (DE) Mode is enabled
<>	156:95d6b41a828b	2247	* @note Macro @ref IS_UART_DRIVER_ENABLE_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2248	* Driver Enable feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2249	* @rmtoll CR3 DEM LL_USART_IsEnabledDEMode
<>	156:95d6b41a828b	2250	* @param USARTx USART Instance
<>	156:95d6b41a828b	2251	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2252	*/
<>	156:95d6b41a828b	2253	__STATIC_INLINE uint32_t LL_USART_IsEnabledDEMode(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2254	{
<>	156:95d6b41a828b	2255	return (READ_BIT(USARTx->CR3, USART_CR3_DEM) == (USART_CR3_DEM));
<>	156:95d6b41a828b	2256	}
<>	156:95d6b41a828b	2257
<>	156:95d6b41a828b	2258	/**
<>	156:95d6b41a828b	2259	* @brief Select Driver Enable Polarity
<>	156:95d6b41a828b	2260	* @note Macro @ref IS_UART_DRIVER_ENABLE_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2261	* Driver Enable feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2262	* @rmtoll CR3 DEP LL_USART_SetDESignalPolarity
<>	156:95d6b41a828b	2263	* @param USARTx USART Instance
<>	156:95d6b41a828b	2264	* @param Polarity This parameter can be one of the following values:
<>	156:95d6b41a828b	2265	* @arg @ref LL_USART_DE_POLARITY_HIGH
<>	156:95d6b41a828b	2266	* @arg @ref LL_USART_DE_POLARITY_LOW
<>	156:95d6b41a828b	2267	* @retval None
<>	156:95d6b41a828b	2268	*/
<>	156:95d6b41a828b	2269	__STATIC_INLINE void LL_USART_SetDESignalPolarity(USART_TypeDef *USARTx, uint32_t Polarity)
<>	156:95d6b41a828b	2270	{
<>	156:95d6b41a828b	2271	MODIFY_REG(USARTx->CR3, USART_CR3_DEP, Polarity);
<>	156:95d6b41a828b	2272	}
<>	156:95d6b41a828b	2273
<>	156:95d6b41a828b	2274	/**
<>	156:95d6b41a828b	2275	* @brief Return Driver Enable Polarity
<>	156:95d6b41a828b	2276	* @note Macro @ref IS_UART_DRIVER_ENABLE_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2277	* Driver Enable feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2278	* @rmtoll CR3 DEP LL_USART_GetDESignalPolarity
<>	156:95d6b41a828b	2279	* @param USARTx USART Instance
<>	156:95d6b41a828b	2280	* @retval Returned value can be one of the following values:
<>	156:95d6b41a828b	2281	* @arg @ref LL_USART_DE_POLARITY_HIGH
<>	156:95d6b41a828b	2282	* @arg @ref LL_USART_DE_POLARITY_LOW
<>	156:95d6b41a828b	2283	*/
<>	156:95d6b41a828b	2284	__STATIC_INLINE uint32_t LL_USART_GetDESignalPolarity(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2285	{
<>	156:95d6b41a828b	2286	return (uint32_t)(READ_BIT(USARTx->CR3, USART_CR3_DEP));
<>	156:95d6b41a828b	2287	}
<>	156:95d6b41a828b	2288
<>	156:95d6b41a828b	2289	/**
<>	156:95d6b41a828b	2290	* @}
<>	156:95d6b41a828b	2291	*/
<>	156:95d6b41a828b	2292
<>	156:95d6b41a828b	2293	/** @defgroup USART_LL_EF_AdvancedConfiguration Advanced Configurations services
<>	156:95d6b41a828b	2294	* @{
<>	156:95d6b41a828b	2295	*/
<>	156:95d6b41a828b	2296
<>	156:95d6b41a828b	2297	/**
<>	156:95d6b41a828b	2298	* @brief Perform basic configuration of USART for enabling use in Asynchronous Mode (UART)
<>	156:95d6b41a828b	2299	* @note In UART mode, the following bits must be kept cleared:
<>	156:95d6b41a828b	2300	* - LINEN bit in the USART_CR2 register (if LIN feature is supported),
<>	156:95d6b41a828b	2301	* - CLKEN bit in the USART_CR2 register,
<>	156:95d6b41a828b	2302	* - SCEN bit in the USART_CR3 register (if Smartcard feature is supported),
<>	156:95d6b41a828b	2303	* - IREN bit in the USART_CR3 register (if Irda feature is supported),
<>	156:95d6b41a828b	2304	* - HDSEL bit in the USART_CR3 register.
<>	156:95d6b41a828b	2305	* @note Call of this function is equivalent to following function call sequence :
<>	156:95d6b41a828b	2306	* - Clear LINEN in CR2 using @ref LL_USART_DisableLIN() function (if LIN feature is supported)
<>	156:95d6b41a828b	2307	* - Clear CLKEN in CR2 using @ref LL_USART_DisableSCLKOutput() function
<>	156:95d6b41a828b	2308	* - Clear SCEN in CR3 using @ref LL_USART_DisableSmartcard() function (if Smartcard feature is supported)
<>	156:95d6b41a828b	2309	* - Clear IREN in CR3 using @ref LL_USART_DisableIrda() function (if Irda feature is supported)
<>	156:95d6b41a828b	2310	* - Clear HDSEL in CR3 using @ref LL_USART_DisableHalfDuplex() function
<>	156:95d6b41a828b	2311	* @note Other remaining configurations items related to Asynchronous Mode
<>	156:95d6b41a828b	2312	* (as Baud Rate, Word length, Parity, ...) should be set using
<>	156:95d6b41a828b	2313	* dedicated functions
<>	156:95d6b41a828b	2314	* @rmtoll CR2 LINEN LL_USART_ConfigAsyncMode\n
<>	156:95d6b41a828b	2315	* CR2 CLKEN LL_USART_ConfigAsyncMode\n
<>	156:95d6b41a828b	2316	* CR3 SCEN LL_USART_ConfigAsyncMode\n
<>	156:95d6b41a828b	2317	* CR3 IREN LL_USART_ConfigAsyncMode\n
<>	156:95d6b41a828b	2318	* CR3 HDSEL LL_USART_ConfigAsyncMode
<>	156:95d6b41a828b	2319	* @param USARTx USART Instance
<>	156:95d6b41a828b	2320	* @retval None
<>	156:95d6b41a828b	2321	*/
<>	156:95d6b41a828b	2322	__STATIC_INLINE void LL_USART_ConfigAsyncMode(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2323	{
<>	156:95d6b41a828b	2324	/* In Asynchronous mode, the following bits must be kept cleared:
<>	156:95d6b41a828b	2325	- LINEN (if LIN feature is supported), CLKEN bits in the USART_CR2 register,
<>	156:95d6b41a828b	2326	- SCEN (if Smartcard feature is supported), IREN (if Irda feature is supported) and HDSEL bits in the USART_CR3 register.*/
<>	156:95d6b41a828b	2327	#if defined(USART_LIN_SUPPORT)
<>	156:95d6b41a828b	2328	CLEAR_BIT(USARTx->CR2, (USART_CR2_LINEN \| USART_CR2_CLKEN));
<>	156:95d6b41a828b	2329	#else
<>	156:95d6b41a828b	2330	CLEAR_BIT(USARTx->CR2, USART_CR2_CLKEN);
<>	156:95d6b41a828b	2331	#endif
<>	156:95d6b41a828b	2332	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	2333	#if defined(USART_IRDA_SUPPORT)
<>	156:95d6b41a828b	2334	CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN \| USART_CR3_IREN \| USART_CR3_HDSEL));
<>	156:95d6b41a828b	2335	#else
<>	156:95d6b41a828b	2336	CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN \| USART_CR3_HDSEL));
<>	156:95d6b41a828b	2337	#endif
<>	156:95d6b41a828b	2338	#else
<>	156:95d6b41a828b	2339	#if defined(USART_IRDA_SUPPORT)
<>	156:95d6b41a828b	2340	CLEAR_BIT(USARTx->CR3, (USART_CR3_IREN \| USART_CR3_HDSEL));
<>	156:95d6b41a828b	2341	#else
<>	156:95d6b41a828b	2342	CLEAR_BIT(USARTx->CR3, USART_CR3_HDSEL);
<>	156:95d6b41a828b	2343	#endif
<>	156:95d6b41a828b	2344	#endif
<>	156:95d6b41a828b	2345	}
<>	156:95d6b41a828b	2346
<>	156:95d6b41a828b	2347	/**
<>	156:95d6b41a828b	2348	* @brief Perform basic configuration of USART for enabling use in Synchronous Mode
<>	156:95d6b41a828b	2349	* @note In Synchronous mode, the following bits must be kept cleared:
<>	156:95d6b41a828b	2350	* - LINEN bit in the USART_CR2 register (if LIN feature is supported),
<>	156:95d6b41a828b	2351	* - SCEN bit in the USART_CR3 register (if Smartcard feature is supported),
<>	156:95d6b41a828b	2352	* - IREN bit in the USART_CR3 register (if Irda feature is supported),
<>	156:95d6b41a828b	2353	* - HDSEL bit in the USART_CR3 register.
<>	156:95d6b41a828b	2354	* This function also sets the USART in Synchronous mode.
<>	156:95d6b41a828b	2355	* @note Macro @ref IS_USART_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2356	* Synchronous mode is supported by the USARTx instance.
<>	156:95d6b41a828b	2357	* @note Call of this function is equivalent to following function call sequence :
<>	156:95d6b41a828b	2358	* - Clear LINEN in CR2 using @ref LL_USART_DisableLIN() function (if LIN feature is supported)
<>	156:95d6b41a828b	2359	* - Clear IREN in CR3 using @ref LL_USART_DisableIrda() function (if Irda feature is supported)
<>	156:95d6b41a828b	2360	* - Clear SCEN in CR3 using @ref LL_USART_DisableSmartcard() function (if Smartcard feature is supported)
<>	156:95d6b41a828b	2361	* - Clear HDSEL in CR3 using @ref LL_USART_DisableHalfDuplex() function
<>	156:95d6b41a828b	2362	* - Set CLKEN in CR2 using @ref LL_USART_EnableSCLKOutput() function
<>	156:95d6b41a828b	2363	* @note Other remaining configurations items related to Synchronous Mode
<>	156:95d6b41a828b	2364	* (as Baud Rate, Word length, Parity, Clock Polarity, ...) should be set using
<>	156:95d6b41a828b	2365	* dedicated functions
<>	156:95d6b41a828b	2366	* @rmtoll CR2 LINEN LL_USART_ConfigSyncMode\n
<>	156:95d6b41a828b	2367	* CR2 CLKEN LL_USART_ConfigSyncMode\n
<>	156:95d6b41a828b	2368	* CR3 SCEN LL_USART_ConfigSyncMode\n
<>	156:95d6b41a828b	2369	* CR3 IREN LL_USART_ConfigSyncMode\n
<>	156:95d6b41a828b	2370	* CR3 HDSEL LL_USART_ConfigSyncMode
<>	156:95d6b41a828b	2371	* @param USARTx USART Instance
<>	156:95d6b41a828b	2372	* @retval None
<>	156:95d6b41a828b	2373	*/
<>	156:95d6b41a828b	2374	__STATIC_INLINE void LL_USART_ConfigSyncMode(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2375	{
<>	156:95d6b41a828b	2376	/* In Synchronous mode, the following bits must be kept cleared:
<>	156:95d6b41a828b	2377	- LINEN (if LIN feature is supported) bit in the USART_CR2 register,
<>	156:95d6b41a828b	2378	- SCEN (if Smartcard feature is supported), IREN (if Irda feature is supported) and HDSEL bits in the USART_CR3 register.*/
<>	156:95d6b41a828b	2379	#if defined(USART_LIN_SUPPORT)
<>	156:95d6b41a828b	2380	CLEAR_BIT(USARTx->CR2, (USART_CR2_LINEN));
<>	156:95d6b41a828b	2381	#endif
<>	156:95d6b41a828b	2382	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	2383	#if defined(USART_IRDA_SUPPORT)
<>	156:95d6b41a828b	2384	CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN \| USART_CR3_IREN \| USART_CR3_HDSEL));
<>	156:95d6b41a828b	2385	#else
<>	156:95d6b41a828b	2386	CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN \| USART_CR3_HDSEL));
<>	156:95d6b41a828b	2387	#endif
<>	156:95d6b41a828b	2388	#else
<>	156:95d6b41a828b	2389	#if defined(USART_IRDA_SUPPORT)
<>	156:95d6b41a828b	2390	CLEAR_BIT(USARTx->CR3, (USART_CR3_IREN \| USART_CR3_HDSEL));
<>	156:95d6b41a828b	2391	#else
<>	156:95d6b41a828b	2392	CLEAR_BIT(USARTx->CR3, USART_CR3_HDSEL);
<>	156:95d6b41a828b	2393	#endif
<>	156:95d6b41a828b	2394	#endif
<>	156:95d6b41a828b	2395	/* set the UART/USART in Synchronous mode */
<>	156:95d6b41a828b	2396	SET_BIT(USARTx->CR2, USART_CR2_CLKEN);
<>	156:95d6b41a828b	2397	}
<>	156:95d6b41a828b	2398
<>	156:95d6b41a828b	2399	#if defined(USART_LIN_SUPPORT)
<>	156:95d6b41a828b	2400	/**
<>	156:95d6b41a828b	2401	* @brief Perform basic configuration of USART for enabling use in LIN Mode
<>	156:95d6b41a828b	2402	* @note In LIN mode, the following bits must be kept cleared:
<>	156:95d6b41a828b	2403	* - STOP and CLKEN bits in the USART_CR2 register,
<>	156:95d6b41a828b	2404	* - SCEN bit in the USART_CR3 register (if Smartcard feature is supported),
<>	156:95d6b41a828b	2405	* - IREN bit in the USART_CR3 register (if Irda feature is supported),
<>	156:95d6b41a828b	2406	* - HDSEL bit in the USART_CR3 register.
<>	156:95d6b41a828b	2407	* This function also set the UART/USART in LIN mode.
<>	156:95d6b41a828b	2408	* @note Macro @ref IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2409	* LIN feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2410	* @note Call of this function is equivalent to following function call sequence :
<>	156:95d6b41a828b	2411	* - Clear CLKEN in CR2 using @ref LL_USART_DisableSCLKOutput() function
<>	156:95d6b41a828b	2412	* - Clear STOP in CR2 using @ref LL_USART_SetStopBitsLength() function
<>	156:95d6b41a828b	2413	* - Clear SCEN in CR3 using @ref LL_USART_DisableSmartcard() function (if Smartcard feature is supported)
<>	156:95d6b41a828b	2414	* - Clear IREN in CR3 using @ref LL_USART_DisableIrda() function (if Irda feature is supported)
<>	156:95d6b41a828b	2415	* - Clear HDSEL in CR3 using @ref LL_USART_DisableHalfDuplex() function
<>	156:95d6b41a828b	2416	* - Set LINEN in CR2 using @ref LL_USART_EnableLIN() function
<>	156:95d6b41a828b	2417	* @note Other remaining configurations items related to LIN Mode
<>	156:95d6b41a828b	2418	* (as Baud Rate, Word length, LIN Break Detection Length, ...) should be set using
<>	156:95d6b41a828b	2419	* dedicated functions
<>	156:95d6b41a828b	2420	* @rmtoll CR2 CLKEN LL_USART_ConfigLINMode\n
<>	156:95d6b41a828b	2421	* CR2 STOP LL_USART_ConfigLINMode\n
<>	156:95d6b41a828b	2422	* CR2 LINEN LL_USART_ConfigLINMode\n
<>	156:95d6b41a828b	2423	* CR3 IREN LL_USART_ConfigLINMode\n
<>	156:95d6b41a828b	2424	* CR3 SCEN LL_USART_ConfigLINMode\n
<>	156:95d6b41a828b	2425	* CR3 HDSEL LL_USART_ConfigLINMode
<>	156:95d6b41a828b	2426	* @param USARTx USART Instance
<>	156:95d6b41a828b	2427	* @retval None
<>	156:95d6b41a828b	2428	*/
<>	156:95d6b41a828b	2429	__STATIC_INLINE void LL_USART_ConfigLINMode(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2430	{
<>	156:95d6b41a828b	2431	/* In LIN mode, the following bits must be kept cleared:
<>	156:95d6b41a828b	2432	- STOP and CLKEN bits in the USART_CR2 register,
<>	156:95d6b41a828b	2433	- IREN (if Irda feature is supported), SCEN (if Smartcard feature is supported) and HDSEL bits in the USART_CR3 register.*/
<>	156:95d6b41a828b	2434	CLEAR_BIT(USARTx->CR2, (USART_CR2_CLKEN \| USART_CR2_STOP));
<>	156:95d6b41a828b	2435	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	2436	#if defined(USART_IRDA_SUPPORT)
<>	156:95d6b41a828b	2437	CLEAR_BIT(USARTx->CR3, (USART_CR3_IREN \| USART_CR3_SCEN \| USART_CR3_HDSEL));
<>	156:95d6b41a828b	2438	#else
<>	156:95d6b41a828b	2439	CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN \| USART_CR3_HDSEL));
<>	156:95d6b41a828b	2440	#endif
<>	156:95d6b41a828b	2441	#else
<>	156:95d6b41a828b	2442	#if defined(USART_IRDA_SUPPORT)
<>	156:95d6b41a828b	2443	CLEAR_BIT(USARTx->CR3, (USART_CR3_IREN \| USART_CR3_HDSEL));
<>	156:95d6b41a828b	2444	#else
<>	156:95d6b41a828b	2445	CLEAR_BIT(USARTx->CR3, USART_CR3_HDSEL);
<>	156:95d6b41a828b	2446	#endif
<>	156:95d6b41a828b	2447	#endif
<>	156:95d6b41a828b	2448	/* Set the UART/USART in LIN mode */
<>	156:95d6b41a828b	2449	SET_BIT(USARTx->CR2, USART_CR2_LINEN);
<>	156:95d6b41a828b	2450	}
<>	156:95d6b41a828b	2451	#endif
<>	156:95d6b41a828b	2452
<>	156:95d6b41a828b	2453	/**
<>	156:95d6b41a828b	2454	* @brief Perform basic configuration of USART for enabling use in Half Duplex Mode
<>	156:95d6b41a828b	2455	* @note In Half Duplex mode, the following bits must be kept cleared:
<>	156:95d6b41a828b	2456	* - LINEN bit in the USART_CR2 register (if LIN feature is supported),
<>	156:95d6b41a828b	2457	* - CLKEN bit in the USART_CR2 register,
<>	156:95d6b41a828b	2458	* - SCEN bit in the USART_CR3 register (if Smartcard feature is supported),
<>	156:95d6b41a828b	2459	* - IREN bit in the USART_CR3 register (if Irda feature is supported),
<>	156:95d6b41a828b	2460	* This function also sets the UART/USART in Half Duplex mode.
<>	156:95d6b41a828b	2461	* @note Macro @ref IS_UART_HALFDUPLEX_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2462	* Half-Duplex mode is supported by the USARTx instance.
<>	156:95d6b41a828b	2463	* @note Call of this function is equivalent to following function call sequence :
<>	156:95d6b41a828b	2464	* - Clear LINEN in CR2 using @ref LL_USART_DisableLIN() function (if LIN feature is supported)
<>	156:95d6b41a828b	2465	* - Clear CLKEN in CR2 using @ref LL_USART_DisableSCLKOutput() function
<>	156:95d6b41a828b	2466	* - Clear SCEN in CR3 using @ref LL_USART_DisableSmartcard() function (if Smartcard feature is supported)
<>	156:95d6b41a828b	2467	* - Clear IREN in CR3 using @ref LL_USART_DisableIrda() function (if Irda feature is supported)
<>	156:95d6b41a828b	2468	* - Set HDSEL in CR3 using @ref LL_USART_EnableHalfDuplex() function
<>	156:95d6b41a828b	2469	* @note Other remaining configurations items related to Half Duplex Mode
<>	156:95d6b41a828b	2470	* (as Baud Rate, Word length, Parity, ...) should be set using
<>	156:95d6b41a828b	2471	* dedicated functions
<>	156:95d6b41a828b	2472	* @rmtoll CR2 LINEN LL_USART_ConfigHalfDuplexMode\n
<>	156:95d6b41a828b	2473	* CR2 CLKEN LL_USART_ConfigHalfDuplexMode\n
<>	156:95d6b41a828b	2474	* CR3 HDSEL LL_USART_ConfigHalfDuplexMode\n
<>	156:95d6b41a828b	2475	* CR3 SCEN LL_USART_ConfigHalfDuplexMode\n
<>	156:95d6b41a828b	2476	* CR3 IREN LL_USART_ConfigHalfDuplexMode
<>	156:95d6b41a828b	2477	* @param USARTx USART Instance
<>	156:95d6b41a828b	2478	* @retval None
<>	156:95d6b41a828b	2479	*/
<>	156:95d6b41a828b	2480	__STATIC_INLINE void LL_USART_ConfigHalfDuplexMode(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2481	{
<>	156:95d6b41a828b	2482	/* In Half Duplex mode, the following bits must be kept cleared:
<>	156:95d6b41a828b	2483	- LINEN (if LIN feature is supported), CLKEN bits in the USART_CR2 register,
<>	156:95d6b41a828b	2484	- SCEN (if Smartcard feature is supported) and IREN (if Irda feature is supported) bits in the USART_CR3 register.*/
<>	156:95d6b41a828b	2485	#if defined(USART_LIN_SUPPORT)
<>	156:95d6b41a828b	2486	CLEAR_BIT(USARTx->CR2, (USART_CR2_LINEN \| USART_CR2_CLKEN));
<>	156:95d6b41a828b	2487	#else
<>	156:95d6b41a828b	2488	CLEAR_BIT(USARTx->CR2, USART_CR2_CLKEN);
<>	156:95d6b41a828b	2489	#endif
<>	156:95d6b41a828b	2490	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	2491	#if defined(USART_IRDA_SUPPORT)
<>	156:95d6b41a828b	2492	CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN \| USART_CR3_IREN));
<>	156:95d6b41a828b	2493	#else
<>	156:95d6b41a828b	2494	CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN));
<>	156:95d6b41a828b	2495	#endif
<>	156:95d6b41a828b	2496	#else
<>	156:95d6b41a828b	2497	#if defined(USART_IRDA_SUPPORT)
<>	156:95d6b41a828b	2498	CLEAR_BIT(USARTx->CR3, (USART_CR3_IREN));
<>	156:95d6b41a828b	2499	#endif
<>	156:95d6b41a828b	2500	#endif
<>	156:95d6b41a828b	2501	/* set the UART/USART in Half Duplex mode */
<>	156:95d6b41a828b	2502	SET_BIT(USARTx->CR3, USART_CR3_HDSEL);
<>	156:95d6b41a828b	2503	}
<>	156:95d6b41a828b	2504
<>	156:95d6b41a828b	2505	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	2506	/**
<>	156:95d6b41a828b	2507	* @brief Perform basic configuration of USART for enabling use in Smartcard Mode
<>	156:95d6b41a828b	2508	* @note In Smartcard mode, the following bits must be kept cleared:
<>	156:95d6b41a828b	2509	* - LINEN bit in the USART_CR2 register (if LIN feature is supported),
<>	156:95d6b41a828b	2510	* - IREN bit in the USART_CR3 register (if Irda feature is supported),
<>	156:95d6b41a828b	2511	* - HDSEL bit in the USART_CR3 register.
<>	156:95d6b41a828b	2512	* This function also configures Stop bits to 1.5 bits and
<>	156:95d6b41a828b	2513	* sets the USART in Smartcard mode (SCEN bit).
<>	156:95d6b41a828b	2514	* Clock Output is also enabled (CLKEN).
<>	156:95d6b41a828b	2515	* @note Macro @ref IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2516	* Smartcard feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2517	* @note Call of this function is equivalent to following function call sequence :
<>	156:95d6b41a828b	2518	* - Clear LINEN in CR2 using @ref LL_USART_DisableLIN() function (if LIN feature is supported)
<>	156:95d6b41a828b	2519	* - Clear IREN in CR3 using @ref LL_USART_DisableIrda() function (if Irda feature is supported)
<>	156:95d6b41a828b	2520	* - Clear HDSEL in CR3 using @ref LL_USART_DisableHalfDuplex() function
<>	156:95d6b41a828b	2521	* - Configure STOP in CR2 using @ref LL_USART_SetStopBitsLength() function
<>	156:95d6b41a828b	2522	* - Set CLKEN in CR2 using @ref LL_USART_EnableSCLKOutput() function
<>	156:95d6b41a828b	2523	* - Set SCEN in CR3 using @ref LL_USART_EnableSmartcard() function
<>	156:95d6b41a828b	2524	* @note Other remaining configurations items related to Smartcard Mode
<>	156:95d6b41a828b	2525	* (as Baud Rate, Word length, Parity, ...) should be set using
<>	156:95d6b41a828b	2526	* dedicated functions
<>	156:95d6b41a828b	2527	* @rmtoll CR2 LINEN LL_USART_ConfigSmartcardMode\n
<>	156:95d6b41a828b	2528	* CR2 STOP LL_USART_ConfigSmartcardMode\n
<>	156:95d6b41a828b	2529	* CR2 CLKEN LL_USART_ConfigSmartcardMode\n
<>	156:95d6b41a828b	2530	* CR3 HDSEL LL_USART_ConfigSmartcardMode\n
<>	156:95d6b41a828b	2531	* CR3 SCEN LL_USART_ConfigSmartcardMode
<>	156:95d6b41a828b	2532	* @param USARTx USART Instance
<>	156:95d6b41a828b	2533	* @retval None
<>	156:95d6b41a828b	2534	*/
<>	156:95d6b41a828b	2535	__STATIC_INLINE void LL_USART_ConfigSmartcardMode(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2536	{
<>	156:95d6b41a828b	2537	/* In Smartcard mode, the following bits must be kept cleared:
<>	156:95d6b41a828b	2538	- LINEN (if LIN feature is supported) bit in the USART_CR2 register,
<>	156:95d6b41a828b	2539	- IREN (if Irda feature is supported) and HDSEL bits in the USART_CR3 register.*/
<>	156:95d6b41a828b	2540	#if defined(USART_LIN_SUPPORT)
<>	156:95d6b41a828b	2541	CLEAR_BIT(USARTx->CR2, (USART_CR2_LINEN));
<>	156:95d6b41a828b	2542	#endif
<>	156:95d6b41a828b	2543	#if defined(USART_IRDA_SUPPORT)
<>	156:95d6b41a828b	2544	CLEAR_BIT(USARTx->CR3, (USART_CR3_IREN \| USART_CR3_HDSEL));
<>	156:95d6b41a828b	2545	#else
<>	156:95d6b41a828b	2546	CLEAR_BIT(USARTx->CR3, (USART_CR3_HDSEL));
<>	156:95d6b41a828b	2547	#endif
<>	156:95d6b41a828b	2548	/* Configure Stop bits to 1.5 bits */
<>	156:95d6b41a828b	2549	/* Synchronous mode is activated by default */
<>	156:95d6b41a828b	2550	SET_BIT(USARTx->CR2, (USART_CR2_STOP_0 \| USART_CR2_STOP_1 \| USART_CR2_CLKEN));
<>	156:95d6b41a828b	2551	/* set the UART/USART in Smartcard mode */
<>	156:95d6b41a828b	2552	SET_BIT(USARTx->CR3, USART_CR3_SCEN);
<>	156:95d6b41a828b	2553	}
<>	156:95d6b41a828b	2554	#endif
<>	156:95d6b41a828b	2555
<>	156:95d6b41a828b	2556	#if defined(USART_IRDA_SUPPORT)
<>	156:95d6b41a828b	2557	/**
<>	156:95d6b41a828b	2558	* @brief Perform basic configuration of USART for enabling use in Irda Mode
<>	156:95d6b41a828b	2559	* @note In IRDA mode, the following bits must be kept cleared:
<>	156:95d6b41a828b	2560	* - LINEN bit in the USART_CR2 register (if LIN feature is supported),
<>	156:95d6b41a828b	2561	* - STOP and CLKEN bits in the USART_CR2 register,
<>	156:95d6b41a828b	2562	* - SCEN bit in the USART_CR3 register (if Smartcard feature is supported),
<>	156:95d6b41a828b	2563	* - HDSEL bit in the USART_CR3 register.
<>	156:95d6b41a828b	2564	* This function also sets the UART/USART in IRDA mode (IREN bit).
<>	156:95d6b41a828b	2565	* @note Macro @ref IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2566	* IrDA feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2567	* @note Call of this function is equivalent to following function call sequence :
<>	156:95d6b41a828b	2568	* - Clear LINEN in CR2 using @ref LL_USART_DisableLIN() function (if LIN feature is supported)
<>	156:95d6b41a828b	2569	* - Clear CLKEN in CR2 using @ref LL_USART_DisableSCLKOutput() function
<>	156:95d6b41a828b	2570	* - Clear SCEN in CR3 using @ref LL_USART_DisableSmartcard() function (if Smartcard feature is supported)
<>	156:95d6b41a828b	2571	* - Clear HDSEL in CR3 using @ref LL_USART_DisableHalfDuplex() function
<>	156:95d6b41a828b	2572	* - Configure STOP in CR2 using @ref LL_USART_SetStopBitsLength() function
<>	156:95d6b41a828b	2573	* - Set IREN in CR3 using @ref LL_USART_EnableIrda() function
<>	156:95d6b41a828b	2574	* @note Other remaining configurations items related to Irda Mode
<>	156:95d6b41a828b	2575	* (as Baud Rate, Word length, Power mode, ...) should be set using
<>	156:95d6b41a828b	2576	* dedicated functions
<>	156:95d6b41a828b	2577	* @rmtoll CR2 LINEN LL_USART_ConfigIrdaMode\n
<>	156:95d6b41a828b	2578	* CR2 CLKEN LL_USART_ConfigIrdaMode\n
<>	156:95d6b41a828b	2579	* CR2 STOP LL_USART_ConfigIrdaMode\n
<>	156:95d6b41a828b	2580	* CR3 SCEN LL_USART_ConfigIrdaMode\n
<>	156:95d6b41a828b	2581	* CR3 HDSEL LL_USART_ConfigIrdaMode\n
<>	156:95d6b41a828b	2582	* CR3 IREN LL_USART_ConfigIrdaMode
<>	156:95d6b41a828b	2583	* @param USARTx USART Instance
<>	156:95d6b41a828b	2584	* @retval None
<>	156:95d6b41a828b	2585	*/
<>	156:95d6b41a828b	2586	__STATIC_INLINE void LL_USART_ConfigIrdaMode(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2587	{
<>	156:95d6b41a828b	2588	/* In IRDA mode, the following bits must be kept cleared:
<>	156:95d6b41a828b	2589	- LINEN (if LIN feature is supported), STOP and CLKEN bits in the USART_CR2 register,
<>	156:95d6b41a828b	2590	- SCEN (if Smartcard feature is supported) and HDSEL bits in the USART_CR3 register.*/
<>	156:95d6b41a828b	2591	#if defined(USART_LIN_SUPPORT)
<>	156:95d6b41a828b	2592	CLEAR_BIT(USARTx->CR2, (USART_CR2_LINEN \| USART_CR2_CLKEN \| USART_CR2_STOP));
<>	156:95d6b41a828b	2593	#else
<>	156:95d6b41a828b	2594	CLEAR_BIT(USARTx->CR2, (USART_CR2_CLKEN \| USART_CR2_STOP));
<>	156:95d6b41a828b	2595	#endif
<>	156:95d6b41a828b	2596	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	2597	CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN \| USART_CR3_HDSEL));
<>	156:95d6b41a828b	2598	#else
<>	156:95d6b41a828b	2599	CLEAR_BIT(USARTx->CR3, (USART_CR3_HDSEL));
<>	156:95d6b41a828b	2600	#endif
<>	156:95d6b41a828b	2601	/* set the UART/USART in IRDA mode */
<>	156:95d6b41a828b	2602	SET_BIT(USARTx->CR3, USART_CR3_IREN);
<>	156:95d6b41a828b	2603	}
<>	156:95d6b41a828b	2604	#endif
<>	156:95d6b41a828b	2605
<>	156:95d6b41a828b	2606	/**
<>	156:95d6b41a828b	2607	* @brief Perform basic configuration of USART for enabling use in Multi processor Mode
<>	156:95d6b41a828b	2608	* (several USARTs connected in a network, one of the USARTs can be the master,
<>	156:95d6b41a828b	2609	* its TX output connected to the RX inputs of the other slaves USARTs).
<>	156:95d6b41a828b	2610	* @note In MultiProcessor mode, the following bits must be kept cleared:
<>	156:95d6b41a828b	2611	* - LINEN bit in the USART_CR2 register (if LIN feature is supported),
<>	156:95d6b41a828b	2612	* - CLKEN bit in the USART_CR2 register,
<>	156:95d6b41a828b	2613	* - SCEN bit in the USART_CR3 register (if Smartcard feature is supported),
<>	156:95d6b41a828b	2614	* - IREN bit in the USART_CR3 register (if Irda feature is supported),
<>	156:95d6b41a828b	2615	* - HDSEL bit in the USART_CR3 register.
<>	156:95d6b41a828b	2616	* @note Call of this function is equivalent to following function call sequence :
<>	156:95d6b41a828b	2617	* - Clear LINEN in CR2 using @ref LL_USART_DisableLIN() function (if LIN feature is supported)
<>	156:95d6b41a828b	2618	* - Clear CLKEN in CR2 using @ref LL_USART_DisableSCLKOutput() function
<>	156:95d6b41a828b	2619	* - Clear SCEN in CR3 using @ref LL_USART_DisableSmartcard() function (if Smartcard feature is supported)
<>	156:95d6b41a828b	2620	* - Clear IREN in CR3 using @ref LL_USART_DisableIrda() function (if Irda feature is supported)
<>	156:95d6b41a828b	2621	* - Clear HDSEL in CR3 using @ref LL_USART_DisableHalfDuplex() function
<>	156:95d6b41a828b	2622	* @note Other remaining configurations items related to Multi processor Mode
<>	156:95d6b41a828b	2623	* (as Baud Rate, Wake Up Method, Node address, ...) should be set using
<>	156:95d6b41a828b	2624	* dedicated functions
<>	156:95d6b41a828b	2625	* @rmtoll CR2 LINEN LL_USART_ConfigMultiProcessMode\n
<>	156:95d6b41a828b	2626	* CR2 CLKEN LL_USART_ConfigMultiProcessMode\n
<>	156:95d6b41a828b	2627	* CR3 SCEN LL_USART_ConfigMultiProcessMode\n
<>	156:95d6b41a828b	2628	* CR3 HDSEL LL_USART_ConfigMultiProcessMode\n
<>	156:95d6b41a828b	2629	* CR3 IREN LL_USART_ConfigMultiProcessMode
<>	156:95d6b41a828b	2630	* @param USARTx USART Instance
<>	156:95d6b41a828b	2631	* @retval None
<>	156:95d6b41a828b	2632	*/
<>	156:95d6b41a828b	2633	__STATIC_INLINE void LL_USART_ConfigMultiProcessMode(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2634	{
<>	156:95d6b41a828b	2635	/* In Multi Processor mode, the following bits must be kept cleared:
<>	156:95d6b41a828b	2636	- LINEN (if LIN feature is supported) and CLKEN bits in the USART_CR2 register,
<>	156:95d6b41a828b	2637	- IREN (if Irda feature is supported), SCEN (if Smartcard feature is supported) and HDSEL bits in the USART_CR3 register.*/
<>	156:95d6b41a828b	2638	#if defined(USART_LIN_SUPPORT)
<>	156:95d6b41a828b	2639	CLEAR_BIT(USARTx->CR2, (USART_CR2_LINEN \| USART_CR2_CLKEN));
<>	156:95d6b41a828b	2640	#else
<>	156:95d6b41a828b	2641	CLEAR_BIT(USARTx->CR2, USART_CR2_CLKEN);
<>	156:95d6b41a828b	2642	#endif
<>	156:95d6b41a828b	2643	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	2644	#if defined(USART_IRDA_SUPPORT)
<>	156:95d6b41a828b	2645	CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN \| USART_CR3_HDSEL \| USART_CR3_IREN));
<>	156:95d6b41a828b	2646	#else
<>	156:95d6b41a828b	2647	CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN \| USART_CR3_HDSEL));
<>	156:95d6b41a828b	2648	#endif
<>	156:95d6b41a828b	2649	#else
<>	156:95d6b41a828b	2650	#if defined(USART_IRDA_SUPPORT)
<>	156:95d6b41a828b	2651	CLEAR_BIT(USARTx->CR3, (USART_CR3_HDSEL \| USART_CR3_IREN));
<>	156:95d6b41a828b	2652	#else
<>	156:95d6b41a828b	2653	CLEAR_BIT(USARTx->CR3, (USART_CR3_HDSEL));
<>	156:95d6b41a828b	2654	#endif
<>	156:95d6b41a828b	2655	#endif
<>	156:95d6b41a828b	2656	}
<>	156:95d6b41a828b	2657
<>	156:95d6b41a828b	2658	/**
<>	156:95d6b41a828b	2659	* @}
<>	156:95d6b41a828b	2660	*/
<>	156:95d6b41a828b	2661
<>	156:95d6b41a828b	2662	/** @defgroup USART_LL_EF_FLAG_Management FLAG_Management
<>	156:95d6b41a828b	2663	* @{
<>	156:95d6b41a828b	2664	*/
<>	156:95d6b41a828b	2665
<>	156:95d6b41a828b	2666	/**
<>	156:95d6b41a828b	2667	* @brief Check if the USART Parity Error Flag is set or not
<>	156:95d6b41a828b	2668	* @rmtoll ISR PE LL_USART_IsActiveFlag_PE
<>	156:95d6b41a828b	2669	* @param USARTx USART Instance
<>	156:95d6b41a828b	2670	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2671	*/
<>	156:95d6b41a828b	2672	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_PE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2673	{
<>	156:95d6b41a828b	2674	return (READ_BIT(USARTx->ISR, USART_ISR_PE) == (USART_ISR_PE));
<>	156:95d6b41a828b	2675	}
<>	156:95d6b41a828b	2676
<>	156:95d6b41a828b	2677	/**
<>	156:95d6b41a828b	2678	* @brief Check if the USART Framing Error Flag is set or not
<>	156:95d6b41a828b	2679	* @rmtoll ISR FE LL_USART_IsActiveFlag_FE
<>	156:95d6b41a828b	2680	* @param USARTx USART Instance
<>	156:95d6b41a828b	2681	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2682	*/
<>	156:95d6b41a828b	2683	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_FE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2684	{
<>	156:95d6b41a828b	2685	return (READ_BIT(USARTx->ISR, USART_ISR_FE) == (USART_ISR_FE));
<>	156:95d6b41a828b	2686	}
<>	156:95d6b41a828b	2687
<>	156:95d6b41a828b	2688	/**
<>	156:95d6b41a828b	2689	* @brief Check if the USART Noise error detected Flag is set or not
<>	156:95d6b41a828b	2690	* @rmtoll ISR NF LL_USART_IsActiveFlag_NE
<>	156:95d6b41a828b	2691	* @param USARTx USART Instance
<>	156:95d6b41a828b	2692	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2693	*/
<>	156:95d6b41a828b	2694	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_NE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2695	{
<>	156:95d6b41a828b	2696	return (READ_BIT(USARTx->ISR, USART_ISR_NE) == (USART_ISR_NE));
<>	156:95d6b41a828b	2697	}
<>	156:95d6b41a828b	2698
<>	156:95d6b41a828b	2699	/**
<>	156:95d6b41a828b	2700	* @brief Check if the USART OverRun Error Flag is set or not
<>	156:95d6b41a828b	2701	* @rmtoll ISR ORE LL_USART_IsActiveFlag_ORE
<>	156:95d6b41a828b	2702	* @param USARTx USART Instance
<>	156:95d6b41a828b	2703	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2704	*/
<>	156:95d6b41a828b	2705	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_ORE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2706	{
<>	156:95d6b41a828b	2707	return (READ_BIT(USARTx->ISR, USART_ISR_ORE) == (USART_ISR_ORE));
<>	156:95d6b41a828b	2708	}
<>	156:95d6b41a828b	2709
<>	156:95d6b41a828b	2710	/**
<>	156:95d6b41a828b	2711	* @brief Check if the USART IDLE line detected Flag is set or not
<>	156:95d6b41a828b	2712	* @rmtoll ISR IDLE LL_USART_IsActiveFlag_IDLE
<>	156:95d6b41a828b	2713	* @param USARTx USART Instance
<>	156:95d6b41a828b	2714	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2715	*/
<>	156:95d6b41a828b	2716	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_IDLE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2717	{
<>	156:95d6b41a828b	2718	return (READ_BIT(USARTx->ISR, USART_ISR_IDLE) == (USART_ISR_IDLE));
<>	156:95d6b41a828b	2719	}
<>	156:95d6b41a828b	2720
<>	156:95d6b41a828b	2721	/**
<>	156:95d6b41a828b	2722	* @brief Check if the USART Read Data Register Not Empty Flag is set or not
<>	156:95d6b41a828b	2723	* @rmtoll ISR RXNE LL_USART_IsActiveFlag_RXNE
<>	156:95d6b41a828b	2724	* @param USARTx USART Instance
<>	156:95d6b41a828b	2725	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2726	*/
<>	156:95d6b41a828b	2727	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_RXNE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2728	{
<>	156:95d6b41a828b	2729	return (READ_BIT(USARTx->ISR, USART_ISR_RXNE) == (USART_ISR_RXNE));
<>	156:95d6b41a828b	2730	}
<>	156:95d6b41a828b	2731
<>	156:95d6b41a828b	2732	/**
<>	156:95d6b41a828b	2733	* @brief Check if the USART Transmission Complete Flag is set or not
<>	156:95d6b41a828b	2734	* @rmtoll ISR TC LL_USART_IsActiveFlag_TC
<>	156:95d6b41a828b	2735	* @param USARTx USART Instance
<>	156:95d6b41a828b	2736	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2737	*/
<>	156:95d6b41a828b	2738	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_TC(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2739	{
<>	156:95d6b41a828b	2740	return (READ_BIT(USARTx->ISR, USART_ISR_TC) == (USART_ISR_TC));
<>	156:95d6b41a828b	2741	}
<>	156:95d6b41a828b	2742
<>	156:95d6b41a828b	2743	/**
<>	156:95d6b41a828b	2744	* @brief Check if the USART Transmit Data Register Empty Flag is set or not
<>	156:95d6b41a828b	2745	* @rmtoll ISR TXE LL_USART_IsActiveFlag_TXE
<>	156:95d6b41a828b	2746	* @param USARTx USART Instance
<>	156:95d6b41a828b	2747	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2748	*/
<>	156:95d6b41a828b	2749	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_TXE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2750	{
<>	156:95d6b41a828b	2751	return (READ_BIT(USARTx->ISR, USART_ISR_TXE) == (USART_ISR_TXE));
<>	156:95d6b41a828b	2752	}
<>	156:95d6b41a828b	2753
<>	156:95d6b41a828b	2754	#if defined(USART_LIN_SUPPORT)
<>	156:95d6b41a828b	2755	/**
<>	156:95d6b41a828b	2756	* @brief Check if the USART LIN Break Detection Flag is set or not
<>	156:95d6b41a828b	2757	* @note Macro @ref IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2758	* LIN feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2759	* @rmtoll ISR LBDF LL_USART_IsActiveFlag_LBD
<>	156:95d6b41a828b	2760	* @param USARTx USART Instance
<>	156:95d6b41a828b	2761	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2762	*/
<>	156:95d6b41a828b	2763	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_LBD(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2764	{
<>	156:95d6b41a828b	2765	return (READ_BIT(USARTx->ISR, USART_ISR_LBDF) == (USART_ISR_LBDF));
<>	156:95d6b41a828b	2766	}
<>	156:95d6b41a828b	2767	#endif
<>	156:95d6b41a828b	2768
<>	156:95d6b41a828b	2769	/**
<>	156:95d6b41a828b	2770	* @brief Check if the USART CTS interrupt Flag is set or not
<>	156:95d6b41a828b	2771	* @note Macro @ref IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2772	* Hardware Flow control feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2773	* @rmtoll ISR CTSIF LL_USART_IsActiveFlag_nCTS
<>	156:95d6b41a828b	2774	* @param USARTx USART Instance
<>	156:95d6b41a828b	2775	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2776	*/
<>	156:95d6b41a828b	2777	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_nCTS(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2778	{
<>	156:95d6b41a828b	2779	return (READ_BIT(USARTx->ISR, USART_ISR_CTSIF) == (USART_ISR_CTSIF));
<>	156:95d6b41a828b	2780	}
<>	156:95d6b41a828b	2781
<>	156:95d6b41a828b	2782	/**
<>	156:95d6b41a828b	2783	* @brief Check if the USART CTS Flag is set or not
<>	156:95d6b41a828b	2784	* @note Macro @ref IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2785	* Hardware Flow control feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2786	* @rmtoll ISR CTS LL_USART_IsActiveFlag_CTS
<>	156:95d6b41a828b	2787	* @param USARTx USART Instance
<>	156:95d6b41a828b	2788	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2789	*/
<>	156:95d6b41a828b	2790	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_CTS(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2791	{
<>	156:95d6b41a828b	2792	return (READ_BIT(USARTx->ISR, USART_ISR_CTS) == (USART_ISR_CTS));
<>	156:95d6b41a828b	2793	}
<>	156:95d6b41a828b	2794
<>	156:95d6b41a828b	2795	/**
<>	156:95d6b41a828b	2796	* @brief Check if the USART Receiver Time Out Flag is set or not
<>	156:95d6b41a828b	2797	* @rmtoll ISR RTOF LL_USART_IsActiveFlag_RTO
<>	156:95d6b41a828b	2798	* @param USARTx USART Instance
<>	156:95d6b41a828b	2799	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2800	*/
<>	156:95d6b41a828b	2801	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_RTO(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2802	{
<>	156:95d6b41a828b	2803	return (READ_BIT(USARTx->ISR, USART_ISR_RTOF) == (USART_ISR_RTOF));
<>	156:95d6b41a828b	2804	}
<>	156:95d6b41a828b	2805
<>	156:95d6b41a828b	2806	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	2807	/**
<>	156:95d6b41a828b	2808	* @brief Check if the USART End Of Block Flag is set or not
<>	156:95d6b41a828b	2809	* @note Macro @ref IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2810	* Smartcard feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2811	* @rmtoll ISR EOBF LL_USART_IsActiveFlag_EOB
<>	156:95d6b41a828b	2812	* @param USARTx USART Instance
<>	156:95d6b41a828b	2813	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2814	*/
<>	156:95d6b41a828b	2815	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_EOB(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2816	{
<>	156:95d6b41a828b	2817	return (READ_BIT(USARTx->ISR, USART_ISR_EOBF) == (USART_ISR_EOBF));
<>	156:95d6b41a828b	2818	}
<>	156:95d6b41a828b	2819	#endif
<>	156:95d6b41a828b	2820
<>	156:95d6b41a828b	2821	/**
<>	156:95d6b41a828b	2822	* @brief Check if the USART Auto-Baud Rate Error Flag is set or not
<>	156:95d6b41a828b	2823	* @note Macro @ref IS_USART_AUTOBAUDRATE_DETECTION_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2824	* Auto Baud Rate detection feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2825	* @rmtoll ISR ABRE LL_USART_IsActiveFlag_ABRE
<>	156:95d6b41a828b	2826	* @param USARTx USART Instance
<>	156:95d6b41a828b	2827	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2828	*/
<>	156:95d6b41a828b	2829	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_ABRE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2830	{
<>	156:95d6b41a828b	2831	return (READ_BIT(USARTx->ISR, USART_ISR_ABRE) == (USART_ISR_ABRE));
<>	156:95d6b41a828b	2832	}
<>	156:95d6b41a828b	2833
<>	156:95d6b41a828b	2834	/**
<>	156:95d6b41a828b	2835	* @brief Check if the USART Auto-Baud Rate Flag is set or not
<>	156:95d6b41a828b	2836	* @note Macro @ref IS_USART_AUTOBAUDRATE_DETECTION_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2837	* Auto Baud Rate detection feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2838	* @rmtoll ISR ABRF LL_USART_IsActiveFlag_ABR
<>	156:95d6b41a828b	2839	* @param USARTx USART Instance
<>	156:95d6b41a828b	2840	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2841	*/
<>	156:95d6b41a828b	2842	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_ABR(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2843	{
<>	156:95d6b41a828b	2844	return (READ_BIT(USARTx->ISR, USART_ISR_ABRF) == (USART_ISR_ABRF));
<>	156:95d6b41a828b	2845	}
<>	156:95d6b41a828b	2846
<>	156:95d6b41a828b	2847	/**
<>	156:95d6b41a828b	2848	* @brief Check if the USART Busy Flag is set or not
<>	156:95d6b41a828b	2849	* @rmtoll ISR BUSY LL_USART_IsActiveFlag_BUSY
<>	156:95d6b41a828b	2850	* @param USARTx USART Instance
<>	156:95d6b41a828b	2851	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2852	*/
<>	156:95d6b41a828b	2853	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_BUSY(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2854	{
<>	156:95d6b41a828b	2855	return (READ_BIT(USARTx->ISR, USART_ISR_BUSY) == (USART_ISR_BUSY));
<>	156:95d6b41a828b	2856	}
<>	156:95d6b41a828b	2857
<>	156:95d6b41a828b	2858	/**
<>	156:95d6b41a828b	2859	* @brief Check if the USART Character Match Flag is set or not
<>	156:95d6b41a828b	2860	* @rmtoll ISR CMF LL_USART_IsActiveFlag_CM
<>	156:95d6b41a828b	2861	* @param USARTx USART Instance
<>	156:95d6b41a828b	2862	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2863	*/
<>	156:95d6b41a828b	2864	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_CM(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2865	{
<>	156:95d6b41a828b	2866	return (READ_BIT(USARTx->ISR, USART_ISR_CMF) == (USART_ISR_CMF));
<>	156:95d6b41a828b	2867	}
<>	156:95d6b41a828b	2868
<>	156:95d6b41a828b	2869	/**
<>	156:95d6b41a828b	2870	* @brief Check if the USART Send Break Flag is set or not
<>	156:95d6b41a828b	2871	* @rmtoll ISR SBKF LL_USART_IsActiveFlag_SBK
<>	156:95d6b41a828b	2872	* @param USARTx USART Instance
<>	156:95d6b41a828b	2873	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2874	*/
<>	156:95d6b41a828b	2875	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_SBK(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2876	{
<>	156:95d6b41a828b	2877	return (READ_BIT(USARTx->ISR, USART_ISR_SBKF) == (USART_ISR_SBKF));
<>	156:95d6b41a828b	2878	}
<>	156:95d6b41a828b	2879
<>	156:95d6b41a828b	2880	/**
<>	156:95d6b41a828b	2881	* @brief Check if the USART Receive Wake Up from mute mode Flag is set or not
<>	156:95d6b41a828b	2882	* @rmtoll ISR RWU LL_USART_IsActiveFlag_RWU
<>	156:95d6b41a828b	2883	* @param USARTx USART Instance
<>	156:95d6b41a828b	2884	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2885	*/
<>	156:95d6b41a828b	2886	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_RWU(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2887	{
<>	156:95d6b41a828b	2888	return (READ_BIT(USARTx->ISR, USART_ISR_RWU) == (USART_ISR_RWU));
<>	156:95d6b41a828b	2889	}
<>	156:95d6b41a828b	2890
<>	156:95d6b41a828b	2891	#if defined(USART_WUSM_SUPPORT)
<>	156:95d6b41a828b	2892	/**
<>	156:95d6b41a828b	2893	* @brief Check if the USART Wake Up from stop mode Flag is set or not
<>	156:95d6b41a828b	2894	* @note Macro @ref IS_UART_WAKEUP_FROMSTOP_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	2895	* Wake-up from Stop mode feature is supported by the USARTx instance.
<>	156:95d6b41a828b	2896	* @rmtoll ISR WUF LL_USART_IsActiveFlag_WKUP
<>	156:95d6b41a828b	2897	* @param USARTx USART Instance
<>	156:95d6b41a828b	2898	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2899	*/
<>	156:95d6b41a828b	2900	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_WKUP(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2901	{
<>	156:95d6b41a828b	2902	return (READ_BIT(USARTx->ISR, USART_ISR_WUF) == (USART_ISR_WUF));
<>	156:95d6b41a828b	2903	}
<>	156:95d6b41a828b	2904	#endif
<>	156:95d6b41a828b	2905
<>	156:95d6b41a828b	2906	/**
<>	156:95d6b41a828b	2907	* @brief Check if the USART Transmit Enable Acknowledge Flag is set or not
<>	156:95d6b41a828b	2908	* @rmtoll ISR TEACK LL_USART_IsActiveFlag_TEACK
<>	156:95d6b41a828b	2909	* @param USARTx USART Instance
<>	156:95d6b41a828b	2910	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2911	*/
<>	156:95d6b41a828b	2912	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_TEACK(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2913	{
<>	156:95d6b41a828b	2914	return (READ_BIT(USARTx->ISR, USART_ISR_TEACK) == (USART_ISR_TEACK));
<>	156:95d6b41a828b	2915	}
<>	156:95d6b41a828b	2916
<>	156:95d6b41a828b	2917	/**
<>	156:95d6b41a828b	2918	* @brief Check if the USART Receive Enable Acknowledge Flag is set or not
<>	156:95d6b41a828b	2919	* @rmtoll ISR REACK LL_USART_IsActiveFlag_REACK
<>	156:95d6b41a828b	2920	* @param USARTx USART Instance
<>	156:95d6b41a828b	2921	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	2922	*/
<>	156:95d6b41a828b	2923	__STATIC_INLINE uint32_t LL_USART_IsActiveFlag_REACK(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2924	{
<>	156:95d6b41a828b	2925	return (READ_BIT(USARTx->ISR, USART_ISR_REACK) == (USART_ISR_REACK));
<>	156:95d6b41a828b	2926	}
<>	156:95d6b41a828b	2927
<>	156:95d6b41a828b	2928
<>	156:95d6b41a828b	2929	/**
<>	156:95d6b41a828b	2930	* @brief Clear Parity Error Flag
<>	156:95d6b41a828b	2931	* @rmtoll ICR PECF LL_USART_ClearFlag_PE
<>	156:95d6b41a828b	2932	* @param USARTx USART Instance
<>	156:95d6b41a828b	2933	* @retval None
<>	156:95d6b41a828b	2934	*/
<>	156:95d6b41a828b	2935	__STATIC_INLINE void LL_USART_ClearFlag_PE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2936	{
<>	156:95d6b41a828b	2937	WRITE_REG(USARTx->ICR, USART_ICR_PECF);
<>	156:95d6b41a828b	2938	}
<>	156:95d6b41a828b	2939
<>	156:95d6b41a828b	2940	/**
<>	156:95d6b41a828b	2941	* @brief Clear Framing Error Flag
<>	156:95d6b41a828b	2942	* @rmtoll ICR FECF LL_USART_ClearFlag_FE
<>	156:95d6b41a828b	2943	* @param USARTx USART Instance
<>	156:95d6b41a828b	2944	* @retval None
<>	156:95d6b41a828b	2945	*/
<>	156:95d6b41a828b	2946	__STATIC_INLINE void LL_USART_ClearFlag_FE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2947	{
<>	156:95d6b41a828b	2948	WRITE_REG(USARTx->ICR, USART_ICR_FECF);
<>	156:95d6b41a828b	2949	}
<>	156:95d6b41a828b	2950
<>	156:95d6b41a828b	2951	/**
<>	156:95d6b41a828b	2952	* @brief Clear Noise detected Flag
<>	156:95d6b41a828b	2953	* @rmtoll ICR NCF LL_USART_ClearFlag_NE
<>	156:95d6b41a828b	2954	* @param USARTx USART Instance
<>	156:95d6b41a828b	2955	* @retval None
<>	156:95d6b41a828b	2956	*/
<>	156:95d6b41a828b	2957	__STATIC_INLINE void LL_USART_ClearFlag_NE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2958	{
<>	156:95d6b41a828b	2959	WRITE_REG(USARTx->ICR, USART_ICR_NCF);
<>	156:95d6b41a828b	2960	}
<>	156:95d6b41a828b	2961
<>	156:95d6b41a828b	2962	/**
<>	156:95d6b41a828b	2963	* @brief Clear OverRun Error Flag
<>	156:95d6b41a828b	2964	* @rmtoll ICR ORECF LL_USART_ClearFlag_ORE
<>	156:95d6b41a828b	2965	* @param USARTx USART Instance
<>	156:95d6b41a828b	2966	* @retval None
<>	156:95d6b41a828b	2967	*/
<>	156:95d6b41a828b	2968	__STATIC_INLINE void LL_USART_ClearFlag_ORE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2969	{
<>	156:95d6b41a828b	2970	WRITE_REG(USARTx->ICR, USART_ICR_ORECF);
<>	156:95d6b41a828b	2971	}
<>	156:95d6b41a828b	2972
<>	156:95d6b41a828b	2973	/**
<>	156:95d6b41a828b	2974	* @brief Clear IDLE line detected Flag
<>	156:95d6b41a828b	2975	* @rmtoll ICR IDLECF LL_USART_ClearFlag_IDLE
<>	156:95d6b41a828b	2976	* @param USARTx USART Instance
<>	156:95d6b41a828b	2977	* @retval None
<>	156:95d6b41a828b	2978	*/
<>	156:95d6b41a828b	2979	__STATIC_INLINE void LL_USART_ClearFlag_IDLE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2980	{
<>	156:95d6b41a828b	2981	WRITE_REG(USARTx->ICR, USART_ICR_IDLECF);
<>	156:95d6b41a828b	2982	}
<>	156:95d6b41a828b	2983
<>	156:95d6b41a828b	2984	/**
<>	156:95d6b41a828b	2985	* @brief Clear Transmission Complete Flag
<>	156:95d6b41a828b	2986	* @rmtoll ICR TCCF LL_USART_ClearFlag_TC
<>	156:95d6b41a828b	2987	* @param USARTx USART Instance
<>	156:95d6b41a828b	2988	* @retval None
<>	156:95d6b41a828b	2989	*/
<>	156:95d6b41a828b	2990	__STATIC_INLINE void LL_USART_ClearFlag_TC(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	2991	{
<>	156:95d6b41a828b	2992	WRITE_REG(USARTx->ICR, USART_ICR_TCCF);
<>	156:95d6b41a828b	2993	}
<>	156:95d6b41a828b	2994
<>	156:95d6b41a828b	2995
<>	156:95d6b41a828b	2996	#if defined(USART_LIN_SUPPORT)
<>	156:95d6b41a828b	2997	/**
<>	156:95d6b41a828b	2998	* @brief Clear LIN Break Detection Flag
<>	156:95d6b41a828b	2999	* @note Macro @ref IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	3000	* LIN feature is supported by the USARTx instance.
<>	156:95d6b41a828b	3001	* @rmtoll ICR LBDCF LL_USART_ClearFlag_LBD
<>	156:95d6b41a828b	3002	* @param USARTx USART Instance
<>	156:95d6b41a828b	3003	* @retval None
<>	156:95d6b41a828b	3004	*/
<>	156:95d6b41a828b	3005	__STATIC_INLINE void LL_USART_ClearFlag_LBD(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3006	{
<>	156:95d6b41a828b	3007	WRITE_REG(USARTx->ICR, USART_ICR_LBDCF);
<>	156:95d6b41a828b	3008	}
<>	156:95d6b41a828b	3009	#endif
<>	156:95d6b41a828b	3010
<>	156:95d6b41a828b	3011	/**
<>	156:95d6b41a828b	3012	* @brief Clear CTS Interrupt Flag
<>	156:95d6b41a828b	3013	* @note Macro @ref IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	3014	* Hardware Flow control feature is supported by the USARTx instance.
<>	156:95d6b41a828b	3015	* @rmtoll ICR CTSCF LL_USART_ClearFlag_nCTS
<>	156:95d6b41a828b	3016	* @param USARTx USART Instance
<>	156:95d6b41a828b	3017	* @retval None
<>	156:95d6b41a828b	3018	*/
<>	156:95d6b41a828b	3019	__STATIC_INLINE void LL_USART_ClearFlag_nCTS(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3020	{
<>	156:95d6b41a828b	3021	WRITE_REG(USARTx->ICR, USART_ICR_CTSCF);
<>	156:95d6b41a828b	3022	}
<>	156:95d6b41a828b	3023
<>	156:95d6b41a828b	3024	/**
<>	156:95d6b41a828b	3025	* @brief Clear Receiver Time Out Flag
<>	156:95d6b41a828b	3026	* @rmtoll ICR RTOCF LL_USART_ClearFlag_RTO
<>	156:95d6b41a828b	3027	* @param USARTx USART Instance
<>	156:95d6b41a828b	3028	* @retval None
<>	156:95d6b41a828b	3029	*/
<>	156:95d6b41a828b	3030	__STATIC_INLINE void LL_USART_ClearFlag_RTO(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3031	{
<>	156:95d6b41a828b	3032	WRITE_REG(USARTx->ICR, USART_ICR_RTOCF);
<>	156:95d6b41a828b	3033	}
<>	156:95d6b41a828b	3034
<>	156:95d6b41a828b	3035	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	3036	/**
<>	156:95d6b41a828b	3037	* @brief Clear End Of Block Flag
<>	156:95d6b41a828b	3038	* @note Macro @ref IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	3039	* Smartcard feature is supported by the USARTx instance.
<>	156:95d6b41a828b	3040	* @rmtoll ICR EOBCF LL_USART_ClearFlag_EOB
<>	156:95d6b41a828b	3041	* @param USARTx USART Instance
<>	156:95d6b41a828b	3042	* @retval None
<>	156:95d6b41a828b	3043	*/
<>	156:95d6b41a828b	3044	__STATIC_INLINE void LL_USART_ClearFlag_EOB(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3045	{
<>	156:95d6b41a828b	3046	WRITE_REG(USARTx->ICR, USART_ICR_EOBCF);
<>	156:95d6b41a828b	3047	}
<>	156:95d6b41a828b	3048	#endif
<>	156:95d6b41a828b	3049
<>	156:95d6b41a828b	3050	/**
<>	156:95d6b41a828b	3051	* @brief Clear Character Match Flag
<>	156:95d6b41a828b	3052	* @rmtoll ICR CMCF LL_USART_ClearFlag_CM
<>	156:95d6b41a828b	3053	* @param USARTx USART Instance
<>	156:95d6b41a828b	3054	* @retval None
<>	156:95d6b41a828b	3055	*/
<>	156:95d6b41a828b	3056	__STATIC_INLINE void LL_USART_ClearFlag_CM(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3057	{
<>	156:95d6b41a828b	3058	WRITE_REG(USARTx->ICR, USART_ICR_CMCF);
<>	156:95d6b41a828b	3059	}
<>	156:95d6b41a828b	3060
<>	156:95d6b41a828b	3061	#if defined(USART_WUSM_SUPPORT)
<>	156:95d6b41a828b	3062	/**
<>	156:95d6b41a828b	3063	* @brief Clear Wake Up from stop mode Flag
<>	156:95d6b41a828b	3064	* @note Macro @ref IS_UART_WAKEUP_FROMSTOP_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	3065	* Wake-up from Stop mode feature is supported by the USARTx instance.
<>	156:95d6b41a828b	3066	* @rmtoll ICR WUCF LL_USART_ClearFlag_WKUP
<>	156:95d6b41a828b	3067	* @param USARTx USART Instance
<>	156:95d6b41a828b	3068	* @retval None
<>	156:95d6b41a828b	3069	*/
<>	156:95d6b41a828b	3070	__STATIC_INLINE void LL_USART_ClearFlag_WKUP(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3071	{
<>	156:95d6b41a828b	3072	WRITE_REG(USARTx->ICR, USART_ICR_WUCF);
<>	156:95d6b41a828b	3073	}
<>	156:95d6b41a828b	3074	#endif
<>	156:95d6b41a828b	3075
<>	156:95d6b41a828b	3076	/**
<>	156:95d6b41a828b	3077	* @}
<>	156:95d6b41a828b	3078	*/
<>	156:95d6b41a828b	3079
<>	156:95d6b41a828b	3080	/** @defgroup USART_LL_EF_IT_Management IT_Management
<>	156:95d6b41a828b	3081	* @{
<>	156:95d6b41a828b	3082	*/
<>	156:95d6b41a828b	3083
<>	156:95d6b41a828b	3084	/**
<>	156:95d6b41a828b	3085	* @brief Enable IDLE Interrupt
<>	156:95d6b41a828b	3086	* @rmtoll CR1 IDLEIE LL_USART_EnableIT_IDLE
<>	156:95d6b41a828b	3087	* @param USARTx USART Instance
<>	156:95d6b41a828b	3088	* @retval None
<>	156:95d6b41a828b	3089	*/
<>	156:95d6b41a828b	3090	__STATIC_INLINE void LL_USART_EnableIT_IDLE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3091	{
<>	156:95d6b41a828b	3092	SET_BIT(USARTx->CR1, USART_CR1_IDLEIE);
<>	156:95d6b41a828b	3093	}
<>	156:95d6b41a828b	3094
<>	156:95d6b41a828b	3095	/**
<>	156:95d6b41a828b	3096	* @brief Enable RX Not Empty Interrupt
<>	156:95d6b41a828b	3097	* @rmtoll CR1 RXNEIE LL_USART_EnableIT_RXNE
<>	156:95d6b41a828b	3098	* @param USARTx USART Instance
<>	156:95d6b41a828b	3099	* @retval None
<>	156:95d6b41a828b	3100	*/
<>	156:95d6b41a828b	3101	__STATIC_INLINE void LL_USART_EnableIT_RXNE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3102	{
<>	156:95d6b41a828b	3103	SET_BIT(USARTx->CR1, USART_CR1_RXNEIE);
<>	156:95d6b41a828b	3104	}
<>	156:95d6b41a828b	3105
<>	156:95d6b41a828b	3106	/**
<>	156:95d6b41a828b	3107	* @brief Enable Transmission Complete Interrupt
<>	156:95d6b41a828b	3108	* @rmtoll CR1 TCIE LL_USART_EnableIT_TC
<>	156:95d6b41a828b	3109	* @param USARTx USART Instance
<>	156:95d6b41a828b	3110	* @retval None
<>	156:95d6b41a828b	3111	*/
<>	156:95d6b41a828b	3112	__STATIC_INLINE void LL_USART_EnableIT_TC(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3113	{
<>	156:95d6b41a828b	3114	SET_BIT(USARTx->CR1, USART_CR1_TCIE);
<>	156:95d6b41a828b	3115	}
<>	156:95d6b41a828b	3116
<>	156:95d6b41a828b	3117	/**
<>	156:95d6b41a828b	3118	* @brief Enable TX Empty Interrupt
<>	156:95d6b41a828b	3119	* @rmtoll CR1 TXEIE LL_USART_EnableIT_TXE
<>	156:95d6b41a828b	3120	* @param USARTx USART Instance
<>	156:95d6b41a828b	3121	* @retval None
<>	156:95d6b41a828b	3122	*/
<>	156:95d6b41a828b	3123	__STATIC_INLINE void LL_USART_EnableIT_TXE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3124	{
<>	156:95d6b41a828b	3125	SET_BIT(USARTx->CR1, USART_CR1_TXEIE);
<>	156:95d6b41a828b	3126	}
<>	156:95d6b41a828b	3127
<>	156:95d6b41a828b	3128	/**
<>	156:95d6b41a828b	3129	* @brief Enable Parity Error Interrupt
<>	156:95d6b41a828b	3130	* @rmtoll CR1 PEIE LL_USART_EnableIT_PE
<>	156:95d6b41a828b	3131	* @param USARTx USART Instance
<>	156:95d6b41a828b	3132	* @retval None
<>	156:95d6b41a828b	3133	*/
<>	156:95d6b41a828b	3134	__STATIC_INLINE void LL_USART_EnableIT_PE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3135	{
<>	156:95d6b41a828b	3136	SET_BIT(USARTx->CR1, USART_CR1_PEIE);
<>	156:95d6b41a828b	3137	}
<>	156:95d6b41a828b	3138
<>	156:95d6b41a828b	3139	/**
<>	156:95d6b41a828b	3140	* @brief Enable Character Match Interrupt
<>	156:95d6b41a828b	3141	* @rmtoll CR1 CMIE LL_USART_EnableIT_CM
<>	156:95d6b41a828b	3142	* @param USARTx USART Instance
<>	156:95d6b41a828b	3143	* @retval None
<>	156:95d6b41a828b	3144	*/
<>	156:95d6b41a828b	3145	__STATIC_INLINE void LL_USART_EnableIT_CM(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3146	{
<>	156:95d6b41a828b	3147	SET_BIT(USARTx->CR1, USART_CR1_CMIE);
<>	156:95d6b41a828b	3148	}
<>	156:95d6b41a828b	3149
<>	156:95d6b41a828b	3150	/**
<>	156:95d6b41a828b	3151	* @brief Enable Receiver Timeout Interrupt
<>	156:95d6b41a828b	3152	* @rmtoll CR1 RTOIE LL_USART_EnableIT_RTO
<>	156:95d6b41a828b	3153	* @param USARTx USART Instance
<>	156:95d6b41a828b	3154	* @retval None
<>	156:95d6b41a828b	3155	*/
<>	156:95d6b41a828b	3156	__STATIC_INLINE void LL_USART_EnableIT_RTO(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3157	{
<>	156:95d6b41a828b	3158	SET_BIT(USARTx->CR1, USART_CR1_RTOIE);
<>	156:95d6b41a828b	3159	}
<>	156:95d6b41a828b	3160
<>	156:95d6b41a828b	3161	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	3162	/**
<>	156:95d6b41a828b	3163	* @brief Enable End Of Block Interrupt
<>	156:95d6b41a828b	3164	* @note Macro @ref IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	3165	* Smartcard feature is supported by the USARTx instance.
<>	156:95d6b41a828b	3166	* @rmtoll CR1 EOBIE LL_USART_EnableIT_EOB
<>	156:95d6b41a828b	3167	* @param USARTx USART Instance
<>	156:95d6b41a828b	3168	* @retval None
<>	156:95d6b41a828b	3169	*/
<>	156:95d6b41a828b	3170	__STATIC_INLINE void LL_USART_EnableIT_EOB(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3171	{
<>	156:95d6b41a828b	3172	SET_BIT(USARTx->CR1, USART_CR1_EOBIE);
<>	156:95d6b41a828b	3173	}
<>	156:95d6b41a828b	3174	#endif
<>	156:95d6b41a828b	3175
<>	156:95d6b41a828b	3176	#if defined(USART_LIN_SUPPORT)
<>	156:95d6b41a828b	3177	/**
<>	156:95d6b41a828b	3178	* @brief Enable LIN Break Detection Interrupt
<>	156:95d6b41a828b	3179	* @note Macro @ref IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	3180	* LIN feature is supported by the USARTx instance.
<>	156:95d6b41a828b	3181	* @rmtoll CR2 LBDIE LL_USART_EnableIT_LBD
<>	156:95d6b41a828b	3182	* @param USARTx USART Instance
<>	156:95d6b41a828b	3183	* @retval None
<>	156:95d6b41a828b	3184	*/
<>	156:95d6b41a828b	3185	__STATIC_INLINE void LL_USART_EnableIT_LBD(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3186	{
<>	156:95d6b41a828b	3187	SET_BIT(USARTx->CR2, USART_CR2_LBDIE);
<>	156:95d6b41a828b	3188	}
<>	156:95d6b41a828b	3189	#endif
<>	156:95d6b41a828b	3190
<>	156:95d6b41a828b	3191	/**
<>	156:95d6b41a828b	3192	* @brief Enable Error Interrupt
<>	156:95d6b41a828b	3193	* @note When set, Error Interrupt Enable Bit is enabling interrupt generation in case of a framing
<>	156:95d6b41a828b	3194	* error, overrun error or noise flag (FE=1 or ORE=1 or NF=1 in the USARTx_ISR register).
<>	156:95d6b41a828b	3195	* 0: Interrupt is inhibited
<>	156:95d6b41a828b	3196	* 1: An interrupt is generated when FE=1 or ORE=1 or NF=1 in the USARTx_ISR register.
<>	156:95d6b41a828b	3197	* @rmtoll CR3 EIE LL_USART_EnableIT_ERROR
<>	156:95d6b41a828b	3198	* @param USARTx USART Instance
<>	156:95d6b41a828b	3199	* @retval None
<>	156:95d6b41a828b	3200	*/
<>	156:95d6b41a828b	3201	__STATIC_INLINE void LL_USART_EnableIT_ERROR(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3202	{
<>	156:95d6b41a828b	3203	SET_BIT(USARTx->CR3, USART_CR3_EIE);
<>	156:95d6b41a828b	3204	}
<>	156:95d6b41a828b	3205
<>	156:95d6b41a828b	3206	/**
<>	156:95d6b41a828b	3207	* @brief Enable CTS Interrupt
<>	156:95d6b41a828b	3208	* @note Macro @ref IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	3209	* Hardware Flow control feature is supported by the USARTx instance.
<>	156:95d6b41a828b	3210	* @rmtoll CR3 CTSIE LL_USART_EnableIT_CTS
<>	156:95d6b41a828b	3211	* @param USARTx USART Instance
<>	156:95d6b41a828b	3212	* @retval None
<>	156:95d6b41a828b	3213	*/
<>	156:95d6b41a828b	3214	__STATIC_INLINE void LL_USART_EnableIT_CTS(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3215	{
<>	156:95d6b41a828b	3216	SET_BIT(USARTx->CR3, USART_CR3_CTSIE);
<>	156:95d6b41a828b	3217	}
<>	156:95d6b41a828b	3218
<>	156:95d6b41a828b	3219	#if defined(USART_WUSM_SUPPORT)
<>	156:95d6b41a828b	3220	/**
<>	156:95d6b41a828b	3221	* @brief Enable Wake Up from Stop Mode Interrupt
<>	156:95d6b41a828b	3222	* @note Macro @ref IS_UART_WAKEUP_FROMSTOP_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	3223	* Wake-up from Stop mode feature is supported by the USARTx instance.
<>	156:95d6b41a828b	3224	* @rmtoll CR3 WUFIE LL_USART_EnableIT_WKUP
<>	156:95d6b41a828b	3225	* @param USARTx USART Instance
<>	156:95d6b41a828b	3226	* @retval None
<>	156:95d6b41a828b	3227	*/
<>	156:95d6b41a828b	3228	__STATIC_INLINE void LL_USART_EnableIT_WKUP(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3229	{
<>	156:95d6b41a828b	3230	SET_BIT(USARTx->CR3, USART_CR3_WUFIE);
<>	156:95d6b41a828b	3231	}
<>	156:95d6b41a828b	3232	#endif
<>	156:95d6b41a828b	3233
<>	156:95d6b41a828b	3234
<>	156:95d6b41a828b	3235	/**
<>	156:95d6b41a828b	3236	* @brief Disable IDLE Interrupt
<>	156:95d6b41a828b	3237	* @rmtoll CR1 IDLEIE LL_USART_DisableIT_IDLE
<>	156:95d6b41a828b	3238	* @param USARTx USART Instance
<>	156:95d6b41a828b	3239	* @retval None
<>	156:95d6b41a828b	3240	*/
<>	156:95d6b41a828b	3241	__STATIC_INLINE void LL_USART_DisableIT_IDLE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3242	{
<>	156:95d6b41a828b	3243	CLEAR_BIT(USARTx->CR1, USART_CR1_IDLEIE);
<>	156:95d6b41a828b	3244	}
<>	156:95d6b41a828b	3245
<>	156:95d6b41a828b	3246	/**
<>	156:95d6b41a828b	3247	* @brief Disable RX Not Empty Interrupt
<>	156:95d6b41a828b	3248	* @rmtoll CR1 RXNEIE LL_USART_DisableIT_RXNE
<>	156:95d6b41a828b	3249	* @param USARTx USART Instance
<>	156:95d6b41a828b	3250	* @retval None
<>	156:95d6b41a828b	3251	*/
<>	156:95d6b41a828b	3252	__STATIC_INLINE void LL_USART_DisableIT_RXNE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3253	{
<>	156:95d6b41a828b	3254	CLEAR_BIT(USARTx->CR1, USART_CR1_RXNEIE);
<>	156:95d6b41a828b	3255	}
<>	156:95d6b41a828b	3256
<>	156:95d6b41a828b	3257	/**
<>	156:95d6b41a828b	3258	* @brief Disable Transmission Complete Interrupt
<>	156:95d6b41a828b	3259	* @rmtoll CR1 TCIE LL_USART_DisableIT_TC
<>	156:95d6b41a828b	3260	* @param USARTx USART Instance
<>	156:95d6b41a828b	3261	* @retval None
<>	156:95d6b41a828b	3262	*/
<>	156:95d6b41a828b	3263	__STATIC_INLINE void LL_USART_DisableIT_TC(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3264	{
<>	156:95d6b41a828b	3265	CLEAR_BIT(USARTx->CR1, USART_CR1_TCIE);
<>	156:95d6b41a828b	3266	}
<>	156:95d6b41a828b	3267
<>	156:95d6b41a828b	3268	/**
<>	156:95d6b41a828b	3269	* @brief Disable TX Empty Interrupt
<>	156:95d6b41a828b	3270	* @rmtoll CR1 TXEIE LL_USART_DisableIT_TXE
<>	156:95d6b41a828b	3271	* @param USARTx USART Instance
<>	156:95d6b41a828b	3272	* @retval None
<>	156:95d6b41a828b	3273	*/
<>	156:95d6b41a828b	3274	__STATIC_INLINE void LL_USART_DisableIT_TXE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3275	{
<>	156:95d6b41a828b	3276	CLEAR_BIT(USARTx->CR1, USART_CR1_TXEIE);
<>	156:95d6b41a828b	3277	}
<>	156:95d6b41a828b	3278
<>	156:95d6b41a828b	3279	/**
<>	156:95d6b41a828b	3280	* @brief Disable Parity Error Interrupt
<>	156:95d6b41a828b	3281	* @rmtoll CR1 PEIE LL_USART_DisableIT_PE
<>	156:95d6b41a828b	3282	* @param USARTx USART Instance
<>	156:95d6b41a828b	3283	* @retval None
<>	156:95d6b41a828b	3284	*/
<>	156:95d6b41a828b	3285	__STATIC_INLINE void LL_USART_DisableIT_PE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3286	{
<>	156:95d6b41a828b	3287	CLEAR_BIT(USARTx->CR1, USART_CR1_PEIE);
<>	156:95d6b41a828b	3288	}
<>	156:95d6b41a828b	3289
<>	156:95d6b41a828b	3290	/**
<>	156:95d6b41a828b	3291	* @brief Disable Character Match Interrupt
<>	156:95d6b41a828b	3292	* @rmtoll CR1 CMIE LL_USART_DisableIT_CM
<>	156:95d6b41a828b	3293	* @param USARTx USART Instance
<>	156:95d6b41a828b	3294	* @retval None
<>	156:95d6b41a828b	3295	*/
<>	156:95d6b41a828b	3296	__STATIC_INLINE void LL_USART_DisableIT_CM(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3297	{
<>	156:95d6b41a828b	3298	CLEAR_BIT(USARTx->CR1, USART_CR1_CMIE);
<>	156:95d6b41a828b	3299	}
<>	156:95d6b41a828b	3300
<>	156:95d6b41a828b	3301	/**
<>	156:95d6b41a828b	3302	* @brief Disable Receiver Timeout Interrupt
<>	156:95d6b41a828b	3303	* @rmtoll CR1 RTOIE LL_USART_DisableIT_RTO
<>	156:95d6b41a828b	3304	* @param USARTx USART Instance
<>	156:95d6b41a828b	3305	* @retval None
<>	156:95d6b41a828b	3306	*/
<>	156:95d6b41a828b	3307	__STATIC_INLINE void LL_USART_DisableIT_RTO(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3308	{
<>	156:95d6b41a828b	3309	CLEAR_BIT(USARTx->CR1, USART_CR1_RTOIE);
<>	156:95d6b41a828b	3310	}
<>	156:95d6b41a828b	3311
<>	156:95d6b41a828b	3312	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	3313	/**
<>	156:95d6b41a828b	3314	* @brief Disable End Of Block Interrupt
<>	156:95d6b41a828b	3315	* @note Macro @ref IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	3316	* Smartcard feature is supported by the USARTx instance.
<>	156:95d6b41a828b	3317	* @rmtoll CR1 EOBIE LL_USART_DisableIT_EOB
<>	156:95d6b41a828b	3318	* @param USARTx USART Instance
<>	156:95d6b41a828b	3319	* @retval None
<>	156:95d6b41a828b	3320	*/
<>	156:95d6b41a828b	3321	__STATIC_INLINE void LL_USART_DisableIT_EOB(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3322	{
<>	156:95d6b41a828b	3323	CLEAR_BIT(USARTx->CR1, USART_CR1_EOBIE);
<>	156:95d6b41a828b	3324	}
<>	156:95d6b41a828b	3325	#endif
<>	156:95d6b41a828b	3326
<>	156:95d6b41a828b	3327	#if defined(USART_LIN_SUPPORT)
<>	156:95d6b41a828b	3328	/**
<>	156:95d6b41a828b	3329	* @brief Disable LIN Break Detection Interrupt
<>	156:95d6b41a828b	3330	* @note Macro @ref IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	3331	* LIN feature is supported by the USARTx instance.
<>	156:95d6b41a828b	3332	* @rmtoll CR2 LBDIE LL_USART_DisableIT_LBD
<>	156:95d6b41a828b	3333	* @param USARTx USART Instance
<>	156:95d6b41a828b	3334	* @retval None
<>	156:95d6b41a828b	3335	*/
<>	156:95d6b41a828b	3336	__STATIC_INLINE void LL_USART_DisableIT_LBD(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3337	{
<>	156:95d6b41a828b	3338	CLEAR_BIT(USARTx->CR2, USART_CR2_LBDIE);
<>	156:95d6b41a828b	3339	}
<>	156:95d6b41a828b	3340	#endif
<>	156:95d6b41a828b	3341
<>	156:95d6b41a828b	3342	/**
<>	156:95d6b41a828b	3343	* @brief Disable Error Interrupt
<>	156:95d6b41a828b	3344	* @note When set, Error Interrupt Enable Bit is enabling interrupt generation in case of a framing
<>	156:95d6b41a828b	3345	* error, overrun error or noise flag (FE=1 or ORE=1 or NF=1 in the USARTx_ISR register).
<>	156:95d6b41a828b	3346	* 0: Interrupt is inhibited
<>	156:95d6b41a828b	3347	* 1: An interrupt is generated when FE=1 or ORE=1 or NF=1 in the USARTx_ISR register.
<>	156:95d6b41a828b	3348	* @rmtoll CR3 EIE LL_USART_DisableIT_ERROR
<>	156:95d6b41a828b	3349	* @param USARTx USART Instance
<>	156:95d6b41a828b	3350	* @retval None
<>	156:95d6b41a828b	3351	*/
<>	156:95d6b41a828b	3352	__STATIC_INLINE void LL_USART_DisableIT_ERROR(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3353	{
<>	156:95d6b41a828b	3354	CLEAR_BIT(USARTx->CR3, USART_CR3_EIE);
<>	156:95d6b41a828b	3355	}
<>	156:95d6b41a828b	3356
<>	156:95d6b41a828b	3357	/**
<>	156:95d6b41a828b	3358	* @brief Disable CTS Interrupt
<>	156:95d6b41a828b	3359	* @note Macro @ref IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	3360	* Hardware Flow control feature is supported by the USARTx instance.
<>	156:95d6b41a828b	3361	* @rmtoll CR3 CTSIE LL_USART_DisableIT_CTS
<>	156:95d6b41a828b	3362	* @param USARTx USART Instance
<>	156:95d6b41a828b	3363	* @retval None
<>	156:95d6b41a828b	3364	*/
<>	156:95d6b41a828b	3365	__STATIC_INLINE void LL_USART_DisableIT_CTS(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3366	{
<>	156:95d6b41a828b	3367	CLEAR_BIT(USARTx->CR3, USART_CR3_CTSIE);
<>	156:95d6b41a828b	3368	}
<>	156:95d6b41a828b	3369
<>	156:95d6b41a828b	3370	#if defined(USART_WUSM_SUPPORT)
<>	156:95d6b41a828b	3371	/**
<>	156:95d6b41a828b	3372	* @brief Disable Wake Up from Stop Mode Interrupt
<>	156:95d6b41a828b	3373	* @note Macro @ref IS_UART_WAKEUP_FROMSTOP_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	3374	* Wake-up from Stop mode feature is supported by the USARTx instance.
<>	156:95d6b41a828b	3375	* @rmtoll CR3 WUFIE LL_USART_DisableIT_WKUP
<>	156:95d6b41a828b	3376	* @param USARTx USART Instance
<>	156:95d6b41a828b	3377	* @retval None
<>	156:95d6b41a828b	3378	*/
<>	156:95d6b41a828b	3379	__STATIC_INLINE void LL_USART_DisableIT_WKUP(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3380	{
<>	156:95d6b41a828b	3381	CLEAR_BIT(USARTx->CR3, USART_CR3_WUFIE);
<>	156:95d6b41a828b	3382	}
<>	156:95d6b41a828b	3383	#endif
<>	156:95d6b41a828b	3384
<>	156:95d6b41a828b	3385
<>	156:95d6b41a828b	3386	/**
<>	156:95d6b41a828b	3387	* @brief Check if the USART IDLE Interrupt source is enabled or disabled.
<>	156:95d6b41a828b	3388	* @rmtoll CR1 IDLEIE LL_USART_IsEnabledIT_IDLE
<>	156:95d6b41a828b	3389	* @param USARTx USART Instance
<>	156:95d6b41a828b	3390	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	3391	*/
<>	156:95d6b41a828b	3392	__STATIC_INLINE uint32_t LL_USART_IsEnabledIT_IDLE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3393	{
<>	156:95d6b41a828b	3394	return (READ_BIT(USARTx->CR1, USART_CR1_IDLEIE) == (USART_CR1_IDLEIE));
<>	156:95d6b41a828b	3395	}
<>	156:95d6b41a828b	3396
<>	156:95d6b41a828b	3397	/**
<>	156:95d6b41a828b	3398	* @brief Check if the USART RX Not Empty Interrupt is enabled or disabled.
<>	156:95d6b41a828b	3399	* @rmtoll CR1 RXNEIE LL_USART_IsEnabledIT_RXNE
<>	156:95d6b41a828b	3400	* @param USARTx USART Instance
<>	156:95d6b41a828b	3401	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	3402	*/
<>	156:95d6b41a828b	3403	__STATIC_INLINE uint32_t LL_USART_IsEnabledIT_RXNE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3404	{
<>	156:95d6b41a828b	3405	return (READ_BIT(USARTx->CR1, USART_CR1_RXNEIE) == (USART_CR1_RXNEIE));
<>	156:95d6b41a828b	3406	}
<>	156:95d6b41a828b	3407
<>	156:95d6b41a828b	3408	/**
<>	156:95d6b41a828b	3409	* @brief Check if the USART Transmission Complete Interrupt is enabled or disabled.
<>	156:95d6b41a828b	3410	* @rmtoll CR1 TCIE LL_USART_IsEnabledIT_TC
<>	156:95d6b41a828b	3411	* @param USARTx USART Instance
<>	156:95d6b41a828b	3412	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	3413	*/
<>	156:95d6b41a828b	3414	__STATIC_INLINE uint32_t LL_USART_IsEnabledIT_TC(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3415	{
<>	156:95d6b41a828b	3416	return (READ_BIT(USARTx->CR1, USART_CR1_TCIE) == (USART_CR1_TCIE));
<>	156:95d6b41a828b	3417	}
<>	156:95d6b41a828b	3418
<>	156:95d6b41a828b	3419	/**
<>	156:95d6b41a828b	3420	* @brief Check if the USART TX Empty Interrupt is enabled or disabled.
<>	156:95d6b41a828b	3421	* @rmtoll CR1 TXEIE LL_USART_IsEnabledIT_TXE
<>	156:95d6b41a828b	3422	* @param USARTx USART Instance
<>	156:95d6b41a828b	3423	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	3424	*/
<>	156:95d6b41a828b	3425	__STATIC_INLINE uint32_t LL_USART_IsEnabledIT_TXE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3426	{
<>	156:95d6b41a828b	3427	return (READ_BIT(USARTx->CR1, USART_CR1_TXEIE) == (USART_CR1_TXEIE));
<>	156:95d6b41a828b	3428	}
<>	156:95d6b41a828b	3429
<>	156:95d6b41a828b	3430	/**
<>	156:95d6b41a828b	3431	* @brief Check if the USART Parity Error Interrupt is enabled or disabled.
<>	156:95d6b41a828b	3432	* @rmtoll CR1 PEIE LL_USART_IsEnabledIT_PE
<>	156:95d6b41a828b	3433	* @param USARTx USART Instance
<>	156:95d6b41a828b	3434	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	3435	*/
<>	156:95d6b41a828b	3436	__STATIC_INLINE uint32_t LL_USART_IsEnabledIT_PE(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3437	{
<>	156:95d6b41a828b	3438	return (READ_BIT(USARTx->CR1, USART_CR1_PEIE) == (USART_CR1_PEIE));
<>	156:95d6b41a828b	3439	}
<>	156:95d6b41a828b	3440
<>	156:95d6b41a828b	3441	/**
<>	156:95d6b41a828b	3442	* @brief Check if the USART Character Match Interrupt is enabled or disabled.
<>	156:95d6b41a828b	3443	* @rmtoll CR1 CMIE LL_USART_IsEnabledIT_CM
<>	156:95d6b41a828b	3444	* @param USARTx USART Instance
<>	156:95d6b41a828b	3445	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	3446	*/
<>	156:95d6b41a828b	3447	__STATIC_INLINE uint32_t LL_USART_IsEnabledIT_CM(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3448	{
<>	156:95d6b41a828b	3449	return (READ_BIT(USARTx->CR1, USART_CR1_CMIE) == (USART_CR1_CMIE));
<>	156:95d6b41a828b	3450	}
<>	156:95d6b41a828b	3451
<>	156:95d6b41a828b	3452	/**
<>	156:95d6b41a828b	3453	* @brief Check if the USART Receiver Timeout Interrupt is enabled or disabled.
<>	156:95d6b41a828b	3454	* @rmtoll CR1 RTOIE LL_USART_IsEnabledIT_RTO
<>	156:95d6b41a828b	3455	* @param USARTx USART Instance
<>	156:95d6b41a828b	3456	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	3457	*/
<>	156:95d6b41a828b	3458	__STATIC_INLINE uint32_t LL_USART_IsEnabledIT_RTO(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3459	{
<>	156:95d6b41a828b	3460	return (READ_BIT(USARTx->CR1, USART_CR1_RTOIE) == (USART_CR1_RTOIE));
<>	156:95d6b41a828b	3461	}
<>	156:95d6b41a828b	3462
<>	156:95d6b41a828b	3463	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	3464	/**
<>	156:95d6b41a828b	3465	* @brief Check if the USART End Of Block Interrupt is enabled or disabled.
<>	156:95d6b41a828b	3466	* @note Macro @ref IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	3467	* Smartcard feature is supported by the USARTx instance.
<>	156:95d6b41a828b	3468	* @rmtoll CR1 EOBIE LL_USART_IsEnabledIT_EOB
<>	156:95d6b41a828b	3469	* @param USARTx USART Instance
<>	156:95d6b41a828b	3470	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	3471	*/
<>	156:95d6b41a828b	3472	__STATIC_INLINE uint32_t LL_USART_IsEnabledIT_EOB(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3473	{
<>	156:95d6b41a828b	3474	return (READ_BIT(USARTx->CR1, USART_CR1_EOBIE) == (USART_CR1_EOBIE));
<>	156:95d6b41a828b	3475	}
<>	156:95d6b41a828b	3476	#endif
<>	156:95d6b41a828b	3477
<>	156:95d6b41a828b	3478	#if defined(USART_LIN_SUPPORT)
<>	156:95d6b41a828b	3479	/**
<>	156:95d6b41a828b	3480	* @brief Check if the USART LIN Break Detection Interrupt is enabled or disabled.
<>	156:95d6b41a828b	3481	* @note Macro @ref IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	3482	* LIN feature is supported by the USARTx instance.
<>	156:95d6b41a828b	3483	* @rmtoll CR2 LBDIE LL_USART_IsEnabledIT_LBD
<>	156:95d6b41a828b	3484	* @param USARTx USART Instance
<>	156:95d6b41a828b	3485	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	3486	*/
<>	156:95d6b41a828b	3487	__STATIC_INLINE uint32_t LL_USART_IsEnabledIT_LBD(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3488	{
<>	156:95d6b41a828b	3489	return (READ_BIT(USARTx->CR2, USART_CR2_LBDIE) == (USART_CR2_LBDIE));
<>	156:95d6b41a828b	3490	}
<>	156:95d6b41a828b	3491	#endif
<>	156:95d6b41a828b	3492
<>	156:95d6b41a828b	3493	/**
<>	156:95d6b41a828b	3494	* @brief Check if the USART Error Interrupt is enabled or disabled.
<>	156:95d6b41a828b	3495	* @rmtoll CR3 EIE LL_USART_IsEnabledIT_ERROR
<>	156:95d6b41a828b	3496	* @param USARTx USART Instance
<>	156:95d6b41a828b	3497	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	3498	*/
<>	156:95d6b41a828b	3499	__STATIC_INLINE uint32_t LL_USART_IsEnabledIT_ERROR(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3500	{
<>	156:95d6b41a828b	3501	return (READ_BIT(USARTx->CR3, USART_CR3_EIE) == (USART_CR3_EIE));
<>	156:95d6b41a828b	3502	}
<>	156:95d6b41a828b	3503
<>	156:95d6b41a828b	3504	/**
<>	156:95d6b41a828b	3505	* @brief Check if the USART CTS Interrupt is enabled or disabled.
<>	156:95d6b41a828b	3506	* @note Macro @ref IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	3507	* Hardware Flow control feature is supported by the USARTx instance.
<>	156:95d6b41a828b	3508	* @rmtoll CR3 CTSIE LL_USART_IsEnabledIT_CTS
<>	156:95d6b41a828b	3509	* @param USARTx USART Instance
<>	156:95d6b41a828b	3510	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	3511	*/
<>	156:95d6b41a828b	3512	__STATIC_INLINE uint32_t LL_USART_IsEnabledIT_CTS(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3513	{
<>	156:95d6b41a828b	3514	return (READ_BIT(USARTx->CR3, USART_CR3_CTSIE) == (USART_CR3_CTSIE));
<>	156:95d6b41a828b	3515	}
<>	156:95d6b41a828b	3516
<>	156:95d6b41a828b	3517	#if defined(USART_WUSM_SUPPORT)
<>	156:95d6b41a828b	3518	/**
<>	156:95d6b41a828b	3519	* @brief Check if the USART Wake Up from Stop Mode Interrupt is enabled or disabled.
<>	156:95d6b41a828b	3520	* @note Macro @ref IS_UART_WAKEUP_FROMSTOP_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	3521	* Wake-up from Stop mode feature is supported by the USARTx instance.
<>	156:95d6b41a828b	3522	* @rmtoll CR3 WUFIE LL_USART_IsEnabledIT_WKUP
<>	156:95d6b41a828b	3523	* @param USARTx USART Instance
<>	156:95d6b41a828b	3524	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	3525	*/
<>	156:95d6b41a828b	3526	__STATIC_INLINE uint32_t LL_USART_IsEnabledIT_WKUP(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3527	{
<>	156:95d6b41a828b	3528	return (READ_BIT(USARTx->CR3, USART_CR3_WUFIE) == (USART_CR3_WUFIE));
<>	156:95d6b41a828b	3529	}
<>	156:95d6b41a828b	3530	#endif
<>	156:95d6b41a828b	3531
<>	156:95d6b41a828b	3532
<>	156:95d6b41a828b	3533	/**
<>	156:95d6b41a828b	3534	* @}
<>	156:95d6b41a828b	3535	*/
<>	156:95d6b41a828b	3536
<>	156:95d6b41a828b	3537	/** @defgroup USART_LL_EF_DMA_Management DMA_Management
<>	156:95d6b41a828b	3538	* @{
<>	156:95d6b41a828b	3539	*/
<>	156:95d6b41a828b	3540
<>	156:95d6b41a828b	3541	/**
<>	156:95d6b41a828b	3542	* @brief Enable DMA Mode for reception
<>	156:95d6b41a828b	3543	* @rmtoll CR3 DMAR LL_USART_EnableDMAReq_RX
<>	156:95d6b41a828b	3544	* @param USARTx USART Instance
<>	156:95d6b41a828b	3545	* @retval None
<>	156:95d6b41a828b	3546	*/
<>	156:95d6b41a828b	3547	__STATIC_INLINE void LL_USART_EnableDMAReq_RX(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3548	{
<>	156:95d6b41a828b	3549	SET_BIT(USARTx->CR3, USART_CR3_DMAR);
<>	156:95d6b41a828b	3550	}
<>	156:95d6b41a828b	3551
<>	156:95d6b41a828b	3552	/**
<>	156:95d6b41a828b	3553	* @brief Disable DMA Mode for reception
<>	156:95d6b41a828b	3554	* @rmtoll CR3 DMAR LL_USART_DisableDMAReq_RX
<>	156:95d6b41a828b	3555	* @param USARTx USART Instance
<>	156:95d6b41a828b	3556	* @retval None
<>	156:95d6b41a828b	3557	*/
<>	156:95d6b41a828b	3558	__STATIC_INLINE void LL_USART_DisableDMAReq_RX(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3559	{
<>	156:95d6b41a828b	3560	CLEAR_BIT(USARTx->CR3, USART_CR3_DMAR);
<>	156:95d6b41a828b	3561	}
<>	156:95d6b41a828b	3562
<>	156:95d6b41a828b	3563	/**
<>	156:95d6b41a828b	3564	* @brief Check if DMA Mode is enabled for reception
<>	156:95d6b41a828b	3565	* @rmtoll CR3 DMAR LL_USART_IsEnabledDMAReq_RX
<>	156:95d6b41a828b	3566	* @param USARTx USART Instance
<>	156:95d6b41a828b	3567	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	3568	*/
<>	156:95d6b41a828b	3569	__STATIC_INLINE uint32_t LL_USART_IsEnabledDMAReq_RX(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3570	{
<>	156:95d6b41a828b	3571	return (READ_BIT(USARTx->CR3, USART_CR3_DMAR) == (USART_CR3_DMAR));
<>	156:95d6b41a828b	3572	}
<>	156:95d6b41a828b	3573
<>	156:95d6b41a828b	3574	/**
<>	156:95d6b41a828b	3575	* @brief Enable DMA Mode for transmission
<>	156:95d6b41a828b	3576	* @rmtoll CR3 DMAT LL_USART_EnableDMAReq_TX
<>	156:95d6b41a828b	3577	* @param USARTx USART Instance
<>	156:95d6b41a828b	3578	* @retval None
<>	156:95d6b41a828b	3579	*/
<>	156:95d6b41a828b	3580	__STATIC_INLINE void LL_USART_EnableDMAReq_TX(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3581	{
<>	156:95d6b41a828b	3582	SET_BIT(USARTx->CR3, USART_CR3_DMAT);
<>	156:95d6b41a828b	3583	}
<>	156:95d6b41a828b	3584
<>	156:95d6b41a828b	3585	/**
<>	156:95d6b41a828b	3586	* @brief Disable DMA Mode for transmission
<>	156:95d6b41a828b	3587	* @rmtoll CR3 DMAT LL_USART_DisableDMAReq_TX
<>	156:95d6b41a828b	3588	* @param USARTx USART Instance
<>	156:95d6b41a828b	3589	* @retval None
<>	156:95d6b41a828b	3590	*/
<>	156:95d6b41a828b	3591	__STATIC_INLINE void LL_USART_DisableDMAReq_TX(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3592	{
<>	156:95d6b41a828b	3593	CLEAR_BIT(USARTx->CR3, USART_CR3_DMAT);
<>	156:95d6b41a828b	3594	}
<>	156:95d6b41a828b	3595
<>	156:95d6b41a828b	3596	/**
<>	156:95d6b41a828b	3597	* @brief Check if DMA Mode is enabled for transmission
<>	156:95d6b41a828b	3598	* @rmtoll CR3 DMAT LL_USART_IsEnabledDMAReq_TX
<>	156:95d6b41a828b	3599	* @param USARTx USART Instance
<>	156:95d6b41a828b	3600	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	3601	*/
<>	156:95d6b41a828b	3602	__STATIC_INLINE uint32_t LL_USART_IsEnabledDMAReq_TX(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3603	{
<>	156:95d6b41a828b	3604	return (READ_BIT(USARTx->CR3, USART_CR3_DMAT) == (USART_CR3_DMAT));
<>	156:95d6b41a828b	3605	}
<>	156:95d6b41a828b	3606
<>	156:95d6b41a828b	3607	/**
<>	156:95d6b41a828b	3608	* @brief Enable DMA Disabling on Reception Error
<>	156:95d6b41a828b	3609	* @rmtoll CR3 DDRE LL_USART_EnableDMADeactOnRxErr
<>	156:95d6b41a828b	3610	* @param USARTx USART Instance
<>	156:95d6b41a828b	3611	* @retval None
<>	156:95d6b41a828b	3612	*/
<>	156:95d6b41a828b	3613	__STATIC_INLINE void LL_USART_EnableDMADeactOnRxErr(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3614	{
<>	156:95d6b41a828b	3615	SET_BIT(USARTx->CR3, USART_CR3_DDRE);
<>	156:95d6b41a828b	3616	}
<>	156:95d6b41a828b	3617
<>	156:95d6b41a828b	3618	/**
<>	156:95d6b41a828b	3619	* @brief Disable DMA Disabling on Reception Error
<>	156:95d6b41a828b	3620	* @rmtoll CR3 DDRE LL_USART_DisableDMADeactOnRxErr
<>	156:95d6b41a828b	3621	* @param USARTx USART Instance
<>	156:95d6b41a828b	3622	* @retval None
<>	156:95d6b41a828b	3623	*/
<>	156:95d6b41a828b	3624	__STATIC_INLINE void LL_USART_DisableDMADeactOnRxErr(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3625	{
<>	156:95d6b41a828b	3626	CLEAR_BIT(USARTx->CR3, USART_CR3_DDRE);
<>	156:95d6b41a828b	3627	}
<>	156:95d6b41a828b	3628
<>	156:95d6b41a828b	3629	/**
<>	156:95d6b41a828b	3630	* @brief Indicate if DMA Disabling on Reception Error is disabled
<>	156:95d6b41a828b	3631	* @rmtoll CR3 DDRE LL_USART_IsEnabledDMADeactOnRxErr
<>	156:95d6b41a828b	3632	* @param USARTx USART Instance
<>	156:95d6b41a828b	3633	* @retval State of bit (1 or 0).
<>	156:95d6b41a828b	3634	*/
<>	156:95d6b41a828b	3635	__STATIC_INLINE uint32_t LL_USART_IsEnabledDMADeactOnRxErr(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3636	{
<>	156:95d6b41a828b	3637	return (READ_BIT(USARTx->CR3, USART_CR3_DDRE) == (USART_CR3_DDRE));
<>	156:95d6b41a828b	3638	}
<>	156:95d6b41a828b	3639
<>	156:95d6b41a828b	3640	/**
<>	156:95d6b41a828b	3641	* @brief Get the data register address used for DMA transfer
<>	156:95d6b41a828b	3642	* @rmtoll RDR RDR LL_USART_DMA_GetRegAddr\n
<>	156:95d6b41a828b	3643	* @rmtoll TDR TDR LL_USART_DMA_GetRegAddr
<>	156:95d6b41a828b	3644	* @param USARTx USART Instance
<>	156:95d6b41a828b	3645	* @param Direction This parameter can be one of the following values:
<>	156:95d6b41a828b	3646	* @arg @ref LL_USART_DMA_REG_DATA_TRANSMIT
<>	156:95d6b41a828b	3647	* @arg @ref LL_USART_DMA_REG_DATA_RECEIVE
<>	156:95d6b41a828b	3648	* @retval Address of data register
<>	156:95d6b41a828b	3649	*/
<>	156:95d6b41a828b	3650	__STATIC_INLINE uint32_t LL_USART_DMA_GetRegAddr(USART_TypeDef *USARTx, uint32_t Direction)
<>	156:95d6b41a828b	3651	{
<>	156:95d6b41a828b	3652	register uint32_t data_reg_addr = 0U;
<>	156:95d6b41a828b	3653
<>	156:95d6b41a828b	3654	if (Direction == LL_USART_DMA_REG_DATA_TRANSMIT)
<>	156:95d6b41a828b	3655	{
<>	156:95d6b41a828b	3656	/* return address of TDR register */
<>	156:95d6b41a828b	3657	data_reg_addr = (uint32_t) &(USARTx->TDR);
<>	156:95d6b41a828b	3658	}
<>	156:95d6b41a828b	3659	else
<>	156:95d6b41a828b	3660	{
<>	156:95d6b41a828b	3661	/* return address of RDR register */
<>	156:95d6b41a828b	3662	data_reg_addr = (uint32_t) &(USARTx->RDR);
<>	156:95d6b41a828b	3663	}
<>	156:95d6b41a828b	3664
<>	156:95d6b41a828b	3665	return data_reg_addr;
<>	156:95d6b41a828b	3666	}
<>	156:95d6b41a828b	3667
<>	156:95d6b41a828b	3668	/**
<>	156:95d6b41a828b	3669	* @}
<>	156:95d6b41a828b	3670	*/
<>	156:95d6b41a828b	3671
<>	156:95d6b41a828b	3672	/** @defgroup USART_LL_EF_Data_Management Data_Management
<>	156:95d6b41a828b	3673	* @{
<>	156:95d6b41a828b	3674	*/
<>	156:95d6b41a828b	3675
<>	156:95d6b41a828b	3676	/**
<>	156:95d6b41a828b	3677	* @brief Read Receiver Data register (Receive Data value, 8 bits)
<>	156:95d6b41a828b	3678	* @rmtoll RDR RDR LL_USART_ReceiveData8
<>	156:95d6b41a828b	3679	* @param USARTx USART Instance
<>	156:95d6b41a828b	3680	* @retval Value between Min_Data=0x00 and Max_Data=0xFF
<>	156:95d6b41a828b	3681	*/
<>	156:95d6b41a828b	3682	__STATIC_INLINE uint8_t LL_USART_ReceiveData8(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3683	{
<>	156:95d6b41a828b	3684	return (uint8_t)(READ_BIT(USARTx->RDR, USART_RDR_RDR));
<>	156:95d6b41a828b	3685	}
<>	156:95d6b41a828b	3686
<>	156:95d6b41a828b	3687	/**
<>	156:95d6b41a828b	3688	* @brief Read Receiver Data register (Receive Data value, 9 bits)
<>	156:95d6b41a828b	3689	* @rmtoll RDR RDR LL_USART_ReceiveData9
<>	156:95d6b41a828b	3690	* @param USARTx USART Instance
<>	156:95d6b41a828b	3691	* @retval Value between Min_Data=0x00 and Max_Data=0x1FF
<>	156:95d6b41a828b	3692	*/
<>	156:95d6b41a828b	3693	__STATIC_INLINE uint16_t LL_USART_ReceiveData9(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3694	{
<>	156:95d6b41a828b	3695	return (uint16_t)(READ_BIT(USARTx->RDR, USART_RDR_RDR));
<>	156:95d6b41a828b	3696	}
<>	156:95d6b41a828b	3697
<>	156:95d6b41a828b	3698	/**
<>	156:95d6b41a828b	3699	* @brief Write in Transmitter Data Register (Transmit Data value, 8 bits)
<>	156:95d6b41a828b	3700	* @rmtoll TDR TDR LL_USART_TransmitData8
<>	156:95d6b41a828b	3701	* @param USARTx USART Instance
<>	156:95d6b41a828b	3702	* @param Value between Min_Data=0x00 and Max_Data=0xFF
<>	156:95d6b41a828b	3703	* @retval None
<>	156:95d6b41a828b	3704	*/
<>	156:95d6b41a828b	3705	__STATIC_INLINE void LL_USART_TransmitData8(USART_TypeDef *USARTx, uint8_t Value)
<>	156:95d6b41a828b	3706	{
<>	156:95d6b41a828b	3707	USARTx->TDR = Value;
<>	156:95d6b41a828b	3708	}
<>	156:95d6b41a828b	3709
<>	156:95d6b41a828b	3710	/**
<>	156:95d6b41a828b	3711	* @brief Write in Transmitter Data Register (Transmit Data value, 9 bits)
<>	156:95d6b41a828b	3712	* @rmtoll TDR TDR LL_USART_TransmitData9
<>	156:95d6b41a828b	3713	* @param USARTx USART Instance
<>	156:95d6b41a828b	3714	* @param Value between Min_Data=0x00 and Max_Data=0x1FF
<>	156:95d6b41a828b	3715	* @retval None
<>	156:95d6b41a828b	3716	*/
<>	156:95d6b41a828b	3717	__STATIC_INLINE void LL_USART_TransmitData9(USART_TypeDef *USARTx, uint16_t Value)
<>	156:95d6b41a828b	3718	{
<>	156:95d6b41a828b	3719	USARTx->TDR = Value & 0x1FFU;
<>	156:95d6b41a828b	3720	}
<>	156:95d6b41a828b	3721
<>	156:95d6b41a828b	3722	/**
<>	156:95d6b41a828b	3723	* @}
<>	156:95d6b41a828b	3724	*/
<>	156:95d6b41a828b	3725
<>	156:95d6b41a828b	3726	/** @defgroup USART_LL_EF_Execution Execution
<>	156:95d6b41a828b	3727	* @{
<>	156:95d6b41a828b	3728	*/
<>	156:95d6b41a828b	3729
<>	156:95d6b41a828b	3730	/**
<>	156:95d6b41a828b	3731	* @brief Request an Automatic Baud Rate measurement on next received data frame
<>	156:95d6b41a828b	3732	* @note Macro @ref IS_USART_AUTOBAUDRATE_DETECTION_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	3733	* Auto Baud Rate detection feature is supported by the USARTx instance.
<>	156:95d6b41a828b	3734	* @rmtoll RQR ABRRQ LL_USART_RequestAutoBaudRate
<>	156:95d6b41a828b	3735	* @param USARTx USART Instance
<>	156:95d6b41a828b	3736	* @retval None
<>	156:95d6b41a828b	3737	*/
<>	156:95d6b41a828b	3738	__STATIC_INLINE void LL_USART_RequestAutoBaudRate(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3739	{
<>	156:95d6b41a828b	3740	SET_BIT(USARTx->RQR, USART_RQR_ABRRQ);
<>	156:95d6b41a828b	3741	}
<>	156:95d6b41a828b	3742
<>	156:95d6b41a828b	3743	/**
<>	156:95d6b41a828b	3744	* @brief Request Break sending
<>	156:95d6b41a828b	3745	* @rmtoll RQR SBKRQ LL_USART_RequestBreakSending
<>	156:95d6b41a828b	3746	* @param USARTx USART Instance
<>	156:95d6b41a828b	3747	* @retval None
<>	156:95d6b41a828b	3748	*/
<>	156:95d6b41a828b	3749	__STATIC_INLINE void LL_USART_RequestBreakSending(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3750	{
<>	156:95d6b41a828b	3751	SET_BIT(USARTx->RQR, USART_RQR_SBKRQ);
<>	156:95d6b41a828b	3752	}
<>	156:95d6b41a828b	3753
<>	156:95d6b41a828b	3754	/**
<>	156:95d6b41a828b	3755	* @brief Put USART in mute mode and set the RWU flag
<>	156:95d6b41a828b	3756	* @rmtoll RQR MMRQ LL_USART_RequestEnterMuteMode
<>	156:95d6b41a828b	3757	* @param USARTx USART Instance
<>	156:95d6b41a828b	3758	* @retval None
<>	156:95d6b41a828b	3759	*/
<>	156:95d6b41a828b	3760	__STATIC_INLINE void LL_USART_RequestEnterMuteMode(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3761	{
<>	156:95d6b41a828b	3762	SET_BIT(USARTx->RQR, USART_RQR_MMRQ);
<>	156:95d6b41a828b	3763	}
<>	156:95d6b41a828b	3764
<>	156:95d6b41a828b	3765	/**
<>	156:95d6b41a828b	3766	* @brief Request a Receive Data flush
<>	156:95d6b41a828b	3767	* @rmtoll RQR RXFRQ LL_USART_RequestRxDataFlush
<>	156:95d6b41a828b	3768	* @param USARTx USART Instance
<>	156:95d6b41a828b	3769	* @retval None
<>	156:95d6b41a828b	3770	*/
<>	156:95d6b41a828b	3771	__STATIC_INLINE void LL_USART_RequestRxDataFlush(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3772	{
<>	156:95d6b41a828b	3773	SET_BIT(USARTx->RQR, USART_RQR_RXFRQ);
<>	156:95d6b41a828b	3774	}
<>	156:95d6b41a828b	3775
<>	156:95d6b41a828b	3776	#if defined(USART_SMARTCARD_SUPPORT)
<>	156:95d6b41a828b	3777	/**
<>	156:95d6b41a828b	3778	* @brief Request a Transmit data flush
<>	156:95d6b41a828b	3779	* @note Macro @ref IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
<>	156:95d6b41a828b	3780	* Smartcard feature is supported by the USARTx instance.
<>	156:95d6b41a828b	3781	* @rmtoll RQR TXFRQ LL_USART_RequestTxDataFlush
<>	156:95d6b41a828b	3782	* @param USARTx USART Instance
<>	156:95d6b41a828b	3783	* @retval None
<>	156:95d6b41a828b	3784	*/
<>	156:95d6b41a828b	3785	__STATIC_INLINE void LL_USART_RequestTxDataFlush(USART_TypeDef *USARTx)
<>	156:95d6b41a828b	3786	{
<>	156:95d6b41a828b	3787	SET_BIT(USARTx->RQR, USART_RQR_TXFRQ);
<>	156:95d6b41a828b	3788	}
<>	156:95d6b41a828b	3789	#endif
<>	156:95d6b41a828b	3790
<>	156:95d6b41a828b	3791	/**
<>	156:95d6b41a828b	3792	* @}
<>	156:95d6b41a828b	3793	*/
<>	156:95d6b41a828b	3794
<>	156:95d6b41a828b	3795	#if defined(USE_FULL_LL_DRIVER)
<>	156:95d6b41a828b	3796	/** @defgroup USART_LL_EF_Init Initialization and de-initialization functions
<>	156:95d6b41a828b	3797	* @{
<>	156:95d6b41a828b	3798	*/
<>	156:95d6b41a828b	3799	ErrorStatus LL_USART_DeInit(USART_TypeDef *USARTx);
<>	156:95d6b41a828b	3800	ErrorStatus LL_USART_Init(USART_TypeDef USARTx, LL_USART_InitTypeDef USART_InitStruct);
<>	156:95d6b41a828b	3801	void LL_USART_StructInit(LL_USART_InitTypeDef *USART_InitStruct);
<>	156:95d6b41a828b	3802	ErrorStatus LL_USART_ClockInit(USART_TypeDef USARTx, LL_USART_ClockInitTypeDef USART_ClockInitStruct);
<>	156:95d6b41a828b	3803	void LL_USART_ClockStructInit(LL_USART_ClockInitTypeDef *USART_ClockInitStruct);
<>	156:95d6b41a828b	3804	/**
<>	156:95d6b41a828b	3805	* @}
<>	156:95d6b41a828b	3806	*/
<>	156:95d6b41a828b	3807	#endif /* USE_FULL_LL_DRIVER */
<>	156:95d6b41a828b	3808
<>	156:95d6b41a828b	3809	/**
<>	156:95d6b41a828b	3810	* @}
<>	156:95d6b41a828b	3811	*/
<>	156:95d6b41a828b	3812
<>	156:95d6b41a828b	3813	/**
<>	156:95d6b41a828b	3814	* @}
<>	156:95d6b41a828b	3815	*/
<>	156:95d6b41a828b	3816
<>	156:95d6b41a828b	3817	#endif /* USART1 \|\| USART2\|\| USART3 \|\| USART4 \|\| USART5 \|\| USART6 \|\| USART7 \|\| USART8 */
<>	156:95d6b41a828b	3818
<>	156:95d6b41a828b	3819	/**
<>	156:95d6b41a828b	3820	* @}
<>	156:95d6b41a828b	3821	*/
<>	156:95d6b41a828b	3822
<>	156:95d6b41a828b	3823	#ifdef __cplusplus
<>	156:95d6b41a828b	3824	}
<>	156:95d6b41a828b	3825	#endif
<>	156:95d6b41a828b	3826
<>	156:95d6b41a828b	3827	#endif /* __STM32F0xx_LL_USART_H */
<>	156:95d6b41a828b	3828
<>	156:95d6b41a828b	3829	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/