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@189:f392fc9709a3, 2019-02-20 (annotated)

Committer:: AnnaBridge
Date:: Wed Feb 20 22:31:08 2019 +0000
Revision:: 189:f392fc9709a3
Parent:: 180:96ed750bd169

mbed library release version 165

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