WebSVN – FuelGauge – Blame – /trunk/Drivers/STM32F0xx_HAL_Driver/Inc/stm32f0xx_ll_usart.h

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

Subversion Repositories FuelGauge

(root)/trunk/Drivers/STM32F0xx_HAL_Driver/Inc/stm32f0xx_ll_usart.h – Rev 6