mbed - The official Mbed 2 C/C++ SDK provides the softwa…

Users » mbed_official » Code » mbed

mbed official / mbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Dependents: hello SerialTestv11 SerialTestv12 Sierpinski ... more

mbed 2

This is the mbed 2 library. If you'd like to learn about Mbed OS please see the mbed-os docs.

TARGET_NUCLEO_F030R8/TARGET_STM/TARGET_STM32F0/device/stm32f0xx_ll_usart.h@143:86740a56073b, 2017-05-26 (annotated)

Committer:: AnnaBridge
Date:: Fri May 26 12:30:20 2017 +0100
Revision:: 143:86740a56073b
Parent:: 134:ad3be0349dc5
Child:: 160:5571c4ff569f

Release 143 of the mbed library.

Who changed what in which revision?

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