TUKS-COURSE-TIMER

TUKS MCU Introductory course » Code » TUKS-COURSE-TIMER

TUKS MCU Introductory course / TUKS-COURSE-TIMER

HAL_L476/stm32l4xx_ll_usart.h@1:d0dfbce63a89, 2017-02-24 (annotated)

Committer:: elmot
Date:: Fri Feb 24 21:13:56 2017 +0000
Revision:: 1:d0dfbce63a89

Ready-to-copy

Who changed what in which revision?

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

Repository toolbox

Repository details

Type:	Program
Created:	25 Feb 2017
Imports:	20
Forks:	1
Commits:	3
Dependents:	0
Dependencies:	0
Followers:	10

The code in this repository is Apache licensed.

Important changes to repositories hosted on mbed.com

HAL_L476/stm32l4xx_ll_usart.h@1:d0dfbce63a89, 2017-02-24 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Important changes to repositories hosted on mbed.com

HAL_L476/stm32l4xx_ll_usart.h@1:d0dfbce63a89, 2017-02-24 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning