Subversion Repositories DashDisplay

Rev

Rev 56 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /**
  2.   ******************************************************************************
  3.   * @file    stm32l1xx_ll_usart.h
  4.   * @author  MCD Application Team
  5.   * @brief   Header file of USART LL module.
  6.   ******************************************************************************
  7.   * @attention
  8.   *
  9.   * Copyright (c) 2016 STMicroelectronics.
  10.   * All rights reserved.
  11.   *
  12.   * This software is licensed under terms that can be found in the LICENSE file
  13.   * in the root directory of this software component.
  14.   * If no LICENSE file comes with this software, it is provided AS-IS.
  15.   *
  16.   ******************************************************************************
  17.   */
  18.  
  19. /* Define to prevent recursive inclusion -------------------------------------*/
  20. #ifndef __STM32L1xx_LL_USART_H
  21. #define __STM32L1xx_LL_USART_H
  22.  
  23. #ifdef __cplusplus
  24. extern "C" {
  25. #endif
  26.  
  27. /* Includes ------------------------------------------------------------------*/
  28. #include "stm32l1xx.h"
  29.  
  30. /** @addtogroup STM32L1xx_LL_Driver
  31.   * @{
  32.   */
  33.  
  34. #if defined (USART1) || defined (USART2) || defined (USART3) || defined (UART4) || defined (UART5)
  35.  
  36. /** @defgroup USART_LL USART
  37.   * @{
  38.   */
  39.  
  40. /* Private types -------------------------------------------------------------*/
  41. /* Private variables ---------------------------------------------------------*/
  42.  
  43. /* Private constants ---------------------------------------------------------*/
  44. /** @defgroup USART_LL_Private_Constants USART Private Constants
  45.   * @{
  46.   */
  47.  
  48. /* Defines used for the bit position in the register and perform offsets*/
  49. #define USART_POSITION_GTPR_GT                  USART_GTPR_GT_Pos
  50. /**
  51.   * @}
  52.   */
  53.  
  54. /* Private macros ------------------------------------------------------------*/
  55. #if defined(USE_FULL_LL_DRIVER)
  56. /** @defgroup USART_LL_Private_Macros USART Private Macros
  57.   * @{
  58.   */
  59. /**
  60.   * @}
  61.   */
  62. #endif /*USE_FULL_LL_DRIVER*/
  63.  
  64. /* Exported types ------------------------------------------------------------*/
  65. #if defined(USE_FULL_LL_DRIVER)
  66. /** @defgroup USART_LL_ES_INIT USART Exported Init structures
  67.   * @{
  68.   */
  69.  
  70. /**
  71.   * @brief LL USART Init Structure definition
  72.   */
  73. typedef struct
  74. {
  75.   uint32_t BaudRate;                  /*!< This field defines expected Usart communication baud rate.
  76.  
  77.                                            This feature can be modified afterwards using unitary function @ref LL_USART_SetBaudRate().*/
  78.  
  79.   uint32_t DataWidth;                 /*!< Specifies the number of data bits transmitted or received in a frame.
  80.                                            This parameter can be a value of @ref USART_LL_EC_DATAWIDTH.
  81.  
  82.                                            This feature can be modified afterwards using unitary function @ref LL_USART_SetDataWidth().*/
  83.  
  84.   uint32_t StopBits;                  /*!< Specifies the number of stop bits transmitted.
  85.                                            This parameter can be a value of @ref USART_LL_EC_STOPBITS.
  86.  
  87.                                            This feature can be modified afterwards using unitary function @ref LL_USART_SetStopBitsLength().*/
  88.  
  89.   uint32_t Parity;                    /*!< Specifies the parity mode.
  90.                                            This parameter can be a value of @ref USART_LL_EC_PARITY.
  91.  
  92.                                            This feature can be modified afterwards using unitary function @ref LL_USART_SetParity().*/
  93.  
  94.   uint32_t TransferDirection;         /*!< Specifies whether the Receive and/or Transmit mode is enabled or disabled.
  95.                                            This parameter can be a value of @ref USART_LL_EC_DIRECTION.
  96.  
  97.                                            This feature can be modified afterwards using unitary function @ref LL_USART_SetTransferDirection().*/
  98.  
  99.   uint32_t HardwareFlowControl;       /*!< Specifies whether the hardware flow control mode is enabled or disabled.
  100.                                            This parameter can be a value of @ref USART_LL_EC_HWCONTROL.
  101.  
  102.                                            This feature can be modified afterwards using unitary function @ref LL_USART_SetHWFlowCtrl().*/
  103.  
  104.   uint32_t OverSampling;              /*!< Specifies whether USART oversampling mode is 16 or 8.
  105.                                            This parameter can be a value of @ref USART_LL_EC_OVERSAMPLING.
  106.  
  107.                                            This feature can be modified afterwards using unitary function @ref LL_USART_SetOverSampling().*/
  108.  
  109. } LL_USART_InitTypeDef;
  110.  
  111. /**
  112.   * @brief LL USART Clock Init Structure definition
  113.   */
  114. typedef struct
  115. {
  116.   uint32_t ClockOutput;               /*!< Specifies whether the USART clock is enabled or disabled.
  117.                                            This parameter can be a value of @ref USART_LL_EC_CLOCK.
  118.  
  119.                                            USART HW configuration can be modified afterwards using unitary functions
  120.                                            @ref LL_USART_EnableSCLKOutput() or @ref LL_USART_DisableSCLKOutput().
  121.                                            For more details, refer to description of this function. */
  122.  
  123.   uint32_t ClockPolarity;             /*!< Specifies the steady state of the serial clock.
  124.                                            This parameter can be a value of @ref USART_LL_EC_POLARITY.
  125.  
  126.                                            USART HW configuration can be modified afterwards using unitary functions @ref LL_USART_SetClockPolarity().
  127.                                            For more details, refer to description of this function. */
  128.  
  129.   uint32_t ClockPhase;                /*!< Specifies the clock transition on which the bit capture is made.
  130.                                            This parameter can be a value of @ref USART_LL_EC_PHASE.
  131.  
  132.                                            USART HW configuration can be modified afterwards using unitary functions @ref LL_USART_SetClockPhase().
  133.                                            For more details, refer to description of this function. */
  134.  
  135.   uint32_t LastBitClockPulse;         /*!< Specifies whether the clock pulse corresponding to the last transmitted
  136.                                            data bit (MSB) has to be output on the SCLK pin in synchronous mode.
  137.                                            This parameter can be a value of @ref USART_LL_EC_LASTCLKPULSE.
  138.  
  139.                                            USART HW configuration can be modified afterwards using unitary functions @ref LL_USART_SetLastClkPulseOutput().
  140.                                            For more details, refer to description of this function. */
  141.  
  142. } LL_USART_ClockInitTypeDef;
  143.  
  144. /**
  145.   * @}
  146.   */
  147. #endif /* USE_FULL_LL_DRIVER */
  148.  
  149. /* Exported constants --------------------------------------------------------*/
  150. /** @defgroup USART_LL_Exported_Constants USART Exported Constants
  151.   * @{
  152.   */
  153.  
  154. /** @defgroup USART_LL_EC_GET_FLAG Get Flags Defines
  155.   * @brief    Flags defines which can be used with LL_USART_ReadReg function
  156.   * @{
  157.   */
  158. #define LL_USART_SR_PE                          USART_SR_PE                   /*!< Parity error flag */
  159. #define LL_USART_SR_FE                          USART_SR_FE                   /*!< Framing error flag */
  160. #define LL_USART_SR_NE                          USART_SR_NE                   /*!< Noise detected flag */
  161. #define LL_USART_SR_ORE                         USART_SR_ORE                  /*!< Overrun error flag */
  162. #define LL_USART_SR_IDLE                        USART_SR_IDLE                 /*!< Idle line detected flag */
  163. #define LL_USART_SR_RXNE                        USART_SR_RXNE                 /*!< Read data register not empty flag */
  164. #define LL_USART_SR_TC                          USART_SR_TC                   /*!< Transmission complete flag */
  165. #define LL_USART_SR_TXE                         USART_SR_TXE                  /*!< Transmit data register empty flag */
  166. #define LL_USART_SR_LBD                         USART_SR_LBD                  /*!< LIN break detection flag */
  167. #define LL_USART_SR_CTS                         USART_SR_CTS                  /*!< CTS flag */
  168. /**
  169.   * @}
  170.   */
  171.  
  172. /** @defgroup USART_LL_EC_IT IT Defines
  173.   * @brief    IT defines which can be used with LL_USART_ReadReg and  LL_USART_WriteReg functions
  174.   * @{
  175.   */
  176. #define LL_USART_CR1_IDLEIE                     USART_CR1_IDLEIE              /*!< IDLE interrupt enable */
  177. #define LL_USART_CR1_RXNEIE                     USART_CR1_RXNEIE              /*!< Read data register not empty interrupt enable */
  178. #define LL_USART_CR1_TCIE                       USART_CR1_TCIE                /*!< Transmission complete interrupt enable */
  179. #define LL_USART_CR1_TXEIE                      USART_CR1_TXEIE               /*!< Transmit data register empty interrupt enable */
  180. #define LL_USART_CR1_PEIE                       USART_CR1_PEIE                /*!< Parity error */
  181. #define LL_USART_CR2_LBDIE                      USART_CR2_LBDIE               /*!< LIN break detection interrupt enable */
  182. #define LL_USART_CR3_EIE                        USART_CR3_EIE                 /*!< Error interrupt enable */
  183. #define LL_USART_CR3_CTSIE                      USART_CR3_CTSIE               /*!< CTS interrupt enable */
  184. /**
  185.   * @}
  186.   */
  187.  
  188. /** @defgroup USART_LL_EC_DIRECTION Communication Direction
  189.   * @{
  190.   */
  191. #define LL_USART_DIRECTION_NONE                 0x00000000U                        /*!< Transmitter and Receiver are disabled */
  192. #define LL_USART_DIRECTION_RX                   USART_CR1_RE                       /*!< Transmitter is disabled and Receiver is enabled */
  193. #define LL_USART_DIRECTION_TX                   USART_CR1_TE                       /*!< Transmitter is enabled and Receiver is disabled */
  194. #define LL_USART_DIRECTION_TX_RX                (USART_CR1_TE |USART_CR1_RE)       /*!< Transmitter and Receiver are enabled */
  195. /**
  196.   * @}
  197.   */
  198.  
  199. /** @defgroup USART_LL_EC_PARITY Parity Control
  200.   * @{
  201.   */
  202. #define LL_USART_PARITY_NONE                    0x00000000U                          /*!< Parity control disabled */
  203. #define LL_USART_PARITY_EVEN                    USART_CR1_PCE                        /*!< Parity control enabled and Even Parity is selected */
  204. #define LL_USART_PARITY_ODD                     (USART_CR1_PCE | USART_CR1_PS)       /*!< Parity control enabled and Odd Parity is selected */
  205. /**
  206.   * @}
  207.   */
  208.  
  209. /** @defgroup USART_LL_EC_WAKEUP Wakeup
  210.   * @{
  211.   */
  212. #define LL_USART_WAKEUP_IDLELINE                0x00000000U           /*!<  USART wake up from Mute mode on Idle Line */
  213. #define LL_USART_WAKEUP_ADDRESSMARK             USART_CR1_WAKE        /*!<  USART wake up from Mute mode on Address Mark */
  214. /**
  215.   * @}
  216.   */
  217.  
  218. /** @defgroup USART_LL_EC_DATAWIDTH Datawidth
  219.   * @{
  220.   */
  221. #define LL_USART_DATAWIDTH_8B                   0x00000000U             /*!< 8 bits word length : Start bit, 8 data bits, n stop bits */
  222. #define LL_USART_DATAWIDTH_9B                   USART_CR1_M             /*!< 9 bits word length : Start bit, 9 data bits, n stop bits */
  223. /**
  224.   * @}
  225.   */
  226.  
  227. /** @defgroup USART_LL_EC_OVERSAMPLING Oversampling
  228.   * @{
  229.   */
  230. #define LL_USART_OVERSAMPLING_16                0x00000000U            /*!< Oversampling by 16 */
  231. #define LL_USART_OVERSAMPLING_8                 USART_CR1_OVER8        /*!< Oversampling by 8 */
  232. /**
  233.   * @}
  234.   */
  235.  
  236. #if defined(USE_FULL_LL_DRIVER)
  237. /** @defgroup USART_LL_EC_CLOCK Clock Signal
  238.   * @{
  239.   */
  240.  
  241. #define LL_USART_CLOCK_DISABLE                  0x00000000U            /*!< Clock signal not provided */
  242. #define LL_USART_CLOCK_ENABLE                   USART_CR2_CLKEN        /*!< Clock signal provided */
  243. /**
  244.   * @}
  245.   */
  246. #endif /*USE_FULL_LL_DRIVER*/
  247.  
  248. /** @defgroup USART_LL_EC_LASTCLKPULSE Last Clock Pulse
  249.   * @{
  250.   */
  251. #define LL_USART_LASTCLKPULSE_NO_OUTPUT         0x00000000U           /*!< The clock pulse of the last data bit is not output to the SCLK pin */
  252. #define LL_USART_LASTCLKPULSE_OUTPUT            USART_CR2_LBCL        /*!< The clock pulse of the last data bit is output to the SCLK pin */
  253. /**
  254.   * @}
  255.   */
  256.  
  257. /** @defgroup USART_LL_EC_PHASE Clock Phase
  258.   * @{
  259.   */
  260. #define LL_USART_PHASE_1EDGE                    0x00000000U           /*!< The first clock transition is the first data capture edge */
  261. #define LL_USART_PHASE_2EDGE                    USART_CR2_CPHA        /*!< The second clock transition is the first data capture edge */
  262. /**
  263.   * @}
  264.   */
  265.  
  266. /** @defgroup USART_LL_EC_POLARITY Clock Polarity
  267.   * @{
  268.   */
  269. #define LL_USART_POLARITY_LOW                   0x00000000U           /*!< Steady low value on SCLK pin outside transmission window*/
  270. #define LL_USART_POLARITY_HIGH                  USART_CR2_CPOL        /*!< Steady high value on SCLK pin outside transmission window */
  271. /**
  272.   * @}
  273.   */
  274.  
  275. /** @defgroup USART_LL_EC_STOPBITS Stop Bits
  276.   * @{
  277.   */
  278. #define LL_USART_STOPBITS_0_5                   USART_CR2_STOP_0                           /*!< 0.5 stop bit */
  279. #define LL_USART_STOPBITS_1                     0x00000000U                                /*!< 1 stop bit */
  280. #define LL_USART_STOPBITS_1_5                   (USART_CR2_STOP_0 | USART_CR2_STOP_1)      /*!< 1.5 stop bits */
  281. #define LL_USART_STOPBITS_2                     USART_CR2_STOP_1                           /*!< 2 stop bits */
  282. /**
  283.   * @}
  284.   */
  285.  
  286. /** @defgroup USART_LL_EC_HWCONTROL Hardware Control
  287.   * @{
  288.   */
  289. #define LL_USART_HWCONTROL_NONE                 0x00000000U                          /*!< CTS and RTS hardware flow control disabled */
  290. #define LL_USART_HWCONTROL_RTS                  USART_CR3_RTSE                       /*!< RTS output enabled, data is only requested when there is space in the receive buffer */
  291. #define LL_USART_HWCONTROL_CTS                  USART_CR3_CTSE                       /*!< CTS mode enabled, data is only transmitted when the nCTS input is asserted (tied to 0) */
  292. #define LL_USART_HWCONTROL_RTS_CTS              (USART_CR3_RTSE | USART_CR3_CTSE)    /*!< CTS and RTS hardware flow control enabled */
  293. /**
  294.   * @}
  295.   */
  296.  
  297. /** @defgroup USART_LL_EC_IRDA_POWER IrDA Power
  298.   * @{
  299.   */
  300. #define LL_USART_IRDA_POWER_NORMAL              0x00000000U           /*!< IrDA normal power mode */
  301. #define LL_USART_IRDA_POWER_LOW                 USART_CR3_IRLP        /*!< IrDA low power mode */
  302. /**
  303.   * @}
  304.   */
  305.  
  306. /** @defgroup USART_LL_EC_LINBREAK_DETECT LIN Break Detection Length
  307.   * @{
  308.   */
  309. #define LL_USART_LINBREAK_DETECT_10B            0x00000000U           /*!< 10-bit break detection method selected */
  310. #define LL_USART_LINBREAK_DETECT_11B            USART_CR2_LBDL        /*!< 11-bit break detection method selected */
  311. /**
  312.   * @}
  313.   */
  314.  
  315. /**
  316.   * @}
  317.   */
  318.  
  319. /* Exported macro ------------------------------------------------------------*/
  320. /** @defgroup USART_LL_Exported_Macros USART Exported Macros
  321.   * @{
  322.   */
  323.  
  324. /** @defgroup USART_LL_EM_WRITE_READ Common Write and read registers Macros
  325.   * @{
  326.   */
  327.  
  328. /**
  329.   * @brief  Write a value in USART register
  330.   * @param  __INSTANCE__ USART Instance
  331.   * @param  __REG__ Register to be written
  332.   * @param  __VALUE__ Value to be written in the register
  333.   * @retval None
  334.   */
  335. #define LL_USART_WriteReg(__INSTANCE__, __REG__, __VALUE__) WRITE_REG(__INSTANCE__->__REG__, (__VALUE__))
  336.  
  337. /**
  338.   * @brief  Read a value in USART register
  339.   * @param  __INSTANCE__ USART Instance
  340.   * @param  __REG__ Register to be read
  341.   * @retval Register value
  342.   */
  343. #define LL_USART_ReadReg(__INSTANCE__, __REG__) READ_REG(__INSTANCE__->__REG__)
  344. /**
  345.   * @}
  346.   */
  347.  
  348. /** @defgroup USART_LL_EM_Exported_Macros_Helper Exported Macros Helper
  349.   * @{
  350.   */
  351.  
  352. /**
  353.   * @brief  Compute USARTDIV value according to Peripheral Clock and
  354.   *         expected Baud Rate in 8 bits sampling mode (32 bits value of USARTDIV is returned)
  355.   * @param  __PERIPHCLK__ Peripheral Clock frequency used for USART instance
  356.   * @param  __BAUDRATE__ Baud rate value to achieve
  357.   * @retval USARTDIV value to be used for BRR register filling in OverSampling_8 case
  358.   */
  359. #define __LL_USART_DIV_SAMPLING8_100(__PERIPHCLK__, __BAUDRATE__)      (((__PERIPHCLK__)*25)/(2*(__BAUDRATE__)))
  360. #define __LL_USART_DIVMANT_SAMPLING8(__PERIPHCLK__, __BAUDRATE__)      (__LL_USART_DIV_SAMPLING8_100((__PERIPHCLK__), (__BAUDRATE__))/100)
  361. #define __LL_USART_DIVFRAQ_SAMPLING8(__PERIPHCLK__, __BAUDRATE__)      (((__LL_USART_DIV_SAMPLING8_100((__PERIPHCLK__), (__BAUDRATE__)) - (__LL_USART_DIVMANT_SAMPLING8((__PERIPHCLK__), (__BAUDRATE__)) * 100)) * 8\
  362.                                                                          + 50) / 100)
  363. /* UART BRR = mantissa + overflow + fraction
  364.             = (UART DIVMANT << 4) + ((UART DIVFRAQ & 0xF8) << 1) + (UART DIVFRAQ & 0x07) */
  365. #define __LL_USART_DIV_SAMPLING8(__PERIPHCLK__, __BAUDRATE__)             (((__LL_USART_DIVMANT_SAMPLING8((__PERIPHCLK__), (__BAUDRATE__)) << 4) + \
  366.                                                                             ((__LL_USART_DIVFRAQ_SAMPLING8((__PERIPHCLK__), (__BAUDRATE__)) & 0xF8) << 1)) + \
  367.                                                                            (__LL_USART_DIVFRAQ_SAMPLING8((__PERIPHCLK__), (__BAUDRATE__)) & 0x07))
  368.  
  369. /**
  370.   * @brief  Compute USARTDIV value according to Peripheral Clock and
  371.   *         expected Baud Rate in 16 bits sampling mode (32 bits value of USARTDIV is returned)
  372.   * @param  __PERIPHCLK__ Peripheral Clock frequency used for USART instance
  373.   * @param  __BAUDRATE__ Baud rate value to achieve
  374.   * @retval USARTDIV value to be used for BRR register filling in OverSampling_16 case
  375.   */
  376. #define __LL_USART_DIV_SAMPLING16_100(__PERIPHCLK__, __BAUDRATE__)     (((__PERIPHCLK__)*25)/(4*(__BAUDRATE__)))
  377. #define __LL_USART_DIVMANT_SAMPLING16(__PERIPHCLK__, __BAUDRATE__)     (__LL_USART_DIV_SAMPLING16_100((__PERIPHCLK__), (__BAUDRATE__))/100)
  378. #define __LL_USART_DIVFRAQ_SAMPLING16(__PERIPHCLK__, __BAUDRATE__)     ((((__LL_USART_DIV_SAMPLING16_100((__PERIPHCLK__), (__BAUDRATE__)) - (__LL_USART_DIVMANT_SAMPLING16((__PERIPHCLK__), (__BAUDRATE__)) * 100)) * 16)\
  379.                                                                          + 50) / 100)
  380. /* USART BRR = mantissa + overflow + fraction
  381.             = (USART DIVMANT << 4) + (USART DIVFRAQ & 0xF0) + (USART DIVFRAQ & 0x0F) */
  382. #define __LL_USART_DIV_SAMPLING16(__PERIPHCLK__, __BAUDRATE__)            (((__LL_USART_DIVMANT_SAMPLING16((__PERIPHCLK__), (__BAUDRATE__)) << 4) + \
  383.                                                                             (__LL_USART_DIVFRAQ_SAMPLING16((__PERIPHCLK__), (__BAUDRATE__)) & 0xF0)) + \
  384.                                                                            (__LL_USART_DIVFRAQ_SAMPLING16((__PERIPHCLK__), (__BAUDRATE__)) & 0x0F))
  385.  
  386. /**
  387.   * @}
  388.   */
  389.  
  390. /**
  391.   * @}
  392.   */
  393.  
  394. /* Exported functions --------------------------------------------------------*/
  395.  
  396. /** @defgroup USART_LL_Exported_Functions USART Exported Functions
  397.   * @{
  398.   */
  399.  
  400. /** @defgroup USART_LL_EF_Configuration Configuration functions
  401.   * @{
  402.   */
  403.  
  404. /**
  405.   * @brief  USART Enable
  406.   * @rmtoll CR1          UE            LL_USART_Enable
  407.   * @param  USARTx USART Instance
  408.   * @retval None
  409.   */
  410. __STATIC_INLINE void LL_USART_Enable(USART_TypeDef *USARTx)
  411. {
  412.   SET_BIT(USARTx->CR1, USART_CR1_UE);
  413. }
  414.  
  415. /**
  416.   * @brief  USART Disable (all USART prescalers and outputs are disabled)
  417.   * @note   When USART is disabled, USART prescalers and outputs are stopped immediately,
  418.   *         and current operations are discarded. The configuration of the USART is kept, but all the status
  419.   *         flags, in the USARTx_SR are set to their default values.
  420.   * @rmtoll CR1          UE            LL_USART_Disable
  421.   * @param  USARTx USART Instance
  422.   * @retval None
  423.   */
  424. __STATIC_INLINE void LL_USART_Disable(USART_TypeDef *USARTx)
  425. {
  426.   CLEAR_BIT(USARTx->CR1, USART_CR1_UE);
  427. }
  428.  
  429. /**
  430.   * @brief  Indicate if USART is enabled
  431.   * @rmtoll CR1          UE            LL_USART_IsEnabled
  432.   * @param  USARTx USART Instance
  433.   * @retval State of bit (1 or 0).
  434.   */
  435. __STATIC_INLINE uint32_t LL_USART_IsEnabled(const USART_TypeDef *USARTx)
  436. {
  437.   return (READ_BIT(USARTx->CR1, USART_CR1_UE) == (USART_CR1_UE));
  438. }
  439.  
  440. /**
  441.   * @brief  Receiver Enable (Receiver is enabled and begins searching for a start bit)
  442.   * @rmtoll CR1          RE            LL_USART_EnableDirectionRx
  443.   * @param  USARTx USART Instance
  444.   * @retval None
  445.   */
  446. __STATIC_INLINE void LL_USART_EnableDirectionRx(USART_TypeDef *USARTx)
  447. {
  448.   ATOMIC_SET_BIT(USARTx->CR1, USART_CR1_RE);
  449. }
  450.  
  451. /**
  452.   * @brief  Receiver Disable
  453.   * @rmtoll CR1          RE            LL_USART_DisableDirectionRx
  454.   * @param  USARTx USART Instance
  455.   * @retval None
  456.   */
  457. __STATIC_INLINE void LL_USART_DisableDirectionRx(USART_TypeDef *USARTx)
  458. {
  459.   ATOMIC_CLEAR_BIT(USARTx->CR1, USART_CR1_RE);
  460. }
  461.  
  462. /**
  463.   * @brief  Transmitter Enable
  464.   * @rmtoll CR1          TE            LL_USART_EnableDirectionTx
  465.   * @param  USARTx USART Instance
  466.   * @retval None
  467.   */
  468. __STATIC_INLINE void LL_USART_EnableDirectionTx(USART_TypeDef *USARTx)
  469. {
  470.   ATOMIC_SET_BIT(USARTx->CR1, USART_CR1_TE);
  471. }
  472.  
  473. /**
  474.   * @brief  Transmitter Disable
  475.   * @rmtoll CR1          TE            LL_USART_DisableDirectionTx
  476.   * @param  USARTx USART Instance
  477.   * @retval None
  478.   */
  479. __STATIC_INLINE void LL_USART_DisableDirectionTx(USART_TypeDef *USARTx)
  480. {
  481.   ATOMIC_CLEAR_BIT(USARTx->CR1, USART_CR1_TE);
  482. }
  483.  
  484. /**
  485.   * @brief  Configure simultaneously enabled/disabled states
  486.   *         of Transmitter and Receiver
  487.   * @rmtoll CR1          RE            LL_USART_SetTransferDirection\n
  488.   *         CR1          TE            LL_USART_SetTransferDirection
  489.   * @param  USARTx USART Instance
  490.   * @param  TransferDirection This parameter can be one of the following values:
  491.   *         @arg @ref LL_USART_DIRECTION_NONE
  492.   *         @arg @ref LL_USART_DIRECTION_RX
  493.   *         @arg @ref LL_USART_DIRECTION_TX
  494.   *         @arg @ref LL_USART_DIRECTION_TX_RX
  495.   * @retval None
  496.   */
  497. __STATIC_INLINE void LL_USART_SetTransferDirection(USART_TypeDef *USARTx, uint32_t TransferDirection)
  498. {
  499.   ATOMIC_MODIFY_REG(USARTx->CR1, USART_CR1_RE | USART_CR1_TE, TransferDirection);
  500. }
  501.  
  502. /**
  503.   * @brief  Return enabled/disabled states of Transmitter and Receiver
  504.   * @rmtoll CR1          RE            LL_USART_GetTransferDirection\n
  505.   *         CR1          TE            LL_USART_GetTransferDirection
  506.   * @param  USARTx USART Instance
  507.   * @retval Returned value can be one of the following values:
  508.   *         @arg @ref LL_USART_DIRECTION_NONE
  509.   *         @arg @ref LL_USART_DIRECTION_RX
  510.   *         @arg @ref LL_USART_DIRECTION_TX
  511.   *         @arg @ref LL_USART_DIRECTION_TX_RX
  512.   */
  513. __STATIC_INLINE uint32_t LL_USART_GetTransferDirection(const USART_TypeDef *USARTx)
  514. {
  515.   return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_RE | USART_CR1_TE));
  516. }
  517.  
  518. /**
  519.   * @brief  Configure Parity (enabled/disabled and parity mode if enabled).
  520.   * @note   This function selects if hardware parity control (generation and detection) is enabled or disabled.
  521.   *         When the parity control is enabled (Odd or Even), computed parity bit is inserted at the MSB position
  522.   *         (9th or 8th bit depending on data width) and parity is checked on the received data.
  523.   * @rmtoll CR1          PS            LL_USART_SetParity\n
  524.   *         CR1          PCE           LL_USART_SetParity
  525.   * @param  USARTx USART Instance
  526.   * @param  Parity This parameter can be one of the following values:
  527.   *         @arg @ref LL_USART_PARITY_NONE
  528.   *         @arg @ref LL_USART_PARITY_EVEN
  529.   *         @arg @ref LL_USART_PARITY_ODD
  530.   * @retval None
  531.   */
  532. __STATIC_INLINE void LL_USART_SetParity(USART_TypeDef *USARTx, uint32_t Parity)
  533. {
  534.   MODIFY_REG(USARTx->CR1, USART_CR1_PS | USART_CR1_PCE, Parity);
  535. }
  536.  
  537. /**
  538.   * @brief  Return Parity configuration (enabled/disabled and parity mode if enabled)
  539.   * @rmtoll CR1          PS            LL_USART_GetParity\n
  540.   *         CR1          PCE           LL_USART_GetParity
  541.   * @param  USARTx USART Instance
  542.   * @retval Returned value can be one of the following values:
  543.   *         @arg @ref LL_USART_PARITY_NONE
  544.   *         @arg @ref LL_USART_PARITY_EVEN
  545.   *         @arg @ref LL_USART_PARITY_ODD
  546.   */
  547. __STATIC_INLINE uint32_t LL_USART_GetParity(const USART_TypeDef *USARTx)
  548. {
  549.   return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_PS | USART_CR1_PCE));
  550. }
  551.  
  552. /**
  553.   * @brief  Set Receiver Wake Up method from Mute mode.
  554.   * @rmtoll CR1          WAKE          LL_USART_SetWakeUpMethod
  555.   * @param  USARTx USART Instance
  556.   * @param  Method This parameter can be one of the following values:
  557.   *         @arg @ref LL_USART_WAKEUP_IDLELINE
  558.   *         @arg @ref LL_USART_WAKEUP_ADDRESSMARK
  559.   * @retval None
  560.   */
  561. __STATIC_INLINE void LL_USART_SetWakeUpMethod(USART_TypeDef *USARTx, uint32_t Method)
  562. {
  563.   MODIFY_REG(USARTx->CR1, USART_CR1_WAKE, Method);
  564. }
  565.  
  566. /**
  567.   * @brief  Return Receiver Wake Up method from Mute mode
  568.   * @rmtoll CR1          WAKE          LL_USART_GetWakeUpMethod
  569.   * @param  USARTx USART Instance
  570.   * @retval Returned value can be one of the following values:
  571.   *         @arg @ref LL_USART_WAKEUP_IDLELINE
  572.   *         @arg @ref LL_USART_WAKEUP_ADDRESSMARK
  573.   */
  574. __STATIC_INLINE uint32_t LL_USART_GetWakeUpMethod(const USART_TypeDef *USARTx)
  575. {
  576.   return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_WAKE));
  577. }
  578.  
  579. /**
  580.   * @brief  Set Word length (i.e. nb of data bits, excluding start and stop bits)
  581.   * @rmtoll CR1          M             LL_USART_SetDataWidth
  582.   * @param  USARTx USART Instance
  583.   * @param  DataWidth This parameter can be one of the following values:
  584.   *         @arg @ref LL_USART_DATAWIDTH_8B
  585.   *         @arg @ref LL_USART_DATAWIDTH_9B
  586.   * @retval None
  587.   */
  588. __STATIC_INLINE void LL_USART_SetDataWidth(USART_TypeDef *USARTx, uint32_t DataWidth)
  589. {
  590.   MODIFY_REG(USARTx->CR1, USART_CR1_M, DataWidth);
  591. }
  592.  
  593. /**
  594.   * @brief  Return Word length (i.e. nb of data bits, excluding start and stop bits)
  595.   * @rmtoll CR1          M             LL_USART_GetDataWidth
  596.   * @param  USARTx USART Instance
  597.   * @retval Returned value can be one of the following values:
  598.   *         @arg @ref LL_USART_DATAWIDTH_8B
  599.   *         @arg @ref LL_USART_DATAWIDTH_9B
  600.   */
  601. __STATIC_INLINE uint32_t LL_USART_GetDataWidth(const USART_TypeDef *USARTx)
  602. {
  603.   return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_M));
  604. }
  605.  
  606. /**
  607.   * @brief  Set Oversampling to 8-bit or 16-bit mode
  608.   * @rmtoll CR1          OVER8         LL_USART_SetOverSampling
  609.   * @param  USARTx USART Instance
  610.   * @param  OverSampling This parameter can be one of the following values:
  611.   *         @arg @ref LL_USART_OVERSAMPLING_16
  612.   *         @arg @ref LL_USART_OVERSAMPLING_8
  613.   * @retval None
  614.   */
  615. __STATIC_INLINE void LL_USART_SetOverSampling(USART_TypeDef *USARTx, uint32_t OverSampling)
  616. {
  617.   MODIFY_REG(USARTx->CR1, USART_CR1_OVER8, OverSampling);
  618. }
  619.  
  620. /**
  621.   * @brief  Return Oversampling mode
  622.   * @rmtoll CR1          OVER8         LL_USART_GetOverSampling
  623.   * @param  USARTx USART Instance
  624.   * @retval Returned value can be one of the following values:
  625.   *         @arg @ref LL_USART_OVERSAMPLING_16
  626.   *         @arg @ref LL_USART_OVERSAMPLING_8
  627.   */
  628. __STATIC_INLINE uint32_t LL_USART_GetOverSampling(const USART_TypeDef *USARTx)
  629. {
  630.   return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_OVER8));
  631. }
  632.  
  633. /**
  634.   * @brief  Configure if Clock pulse of the last data bit is output to the SCLK pin or not
  635.   * @note   Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
  636.   *         Synchronous mode is supported by the USARTx instance.
  637.   * @rmtoll CR2          LBCL          LL_USART_SetLastClkPulseOutput
  638.   * @param  USARTx USART Instance
  639.   * @param  LastBitClockPulse This parameter can be one of the following values:
  640.   *         @arg @ref LL_USART_LASTCLKPULSE_NO_OUTPUT
  641.   *         @arg @ref LL_USART_LASTCLKPULSE_OUTPUT
  642.   * @retval None
  643.   */
  644. __STATIC_INLINE void LL_USART_SetLastClkPulseOutput(USART_TypeDef *USARTx, uint32_t LastBitClockPulse)
  645. {
  646.   MODIFY_REG(USARTx->CR2, USART_CR2_LBCL, LastBitClockPulse);
  647. }
  648.  
  649. /**
  650.   * @brief  Retrieve Clock pulse of the last data bit output configuration
  651.   *         (Last bit Clock pulse output to the SCLK pin or not)
  652.   * @note   Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
  653.   *         Synchronous mode is supported by the USARTx instance.
  654.   * @rmtoll CR2          LBCL          LL_USART_GetLastClkPulseOutput
  655.   * @param  USARTx USART Instance
  656.   * @retval Returned value can be one of the following values:
  657.   *         @arg @ref LL_USART_LASTCLKPULSE_NO_OUTPUT
  658.   *         @arg @ref LL_USART_LASTCLKPULSE_OUTPUT
  659.   */
  660. __STATIC_INLINE uint32_t LL_USART_GetLastClkPulseOutput(const USART_TypeDef *USARTx)
  661. {
  662.   return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_LBCL));
  663. }
  664.  
  665. /**
  666.   * @brief  Select the phase of the clock output on the SCLK pin in synchronous mode
  667.   * @note   Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
  668.   *         Synchronous mode is supported by the USARTx instance.
  669.   * @rmtoll CR2          CPHA          LL_USART_SetClockPhase
  670.   * @param  USARTx USART Instance
  671.   * @param  ClockPhase This parameter can be one of the following values:
  672.   *         @arg @ref LL_USART_PHASE_1EDGE
  673.   *         @arg @ref LL_USART_PHASE_2EDGE
  674.   * @retval None
  675.   */
  676. __STATIC_INLINE void LL_USART_SetClockPhase(USART_TypeDef *USARTx, uint32_t ClockPhase)
  677. {
  678.   MODIFY_REG(USARTx->CR2, USART_CR2_CPHA, ClockPhase);
  679. }
  680.  
  681. /**
  682.   * @brief  Return phase of the clock output on the SCLK pin in synchronous mode
  683.   * @note   Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
  684.   *         Synchronous mode is supported by the USARTx instance.
  685.   * @rmtoll CR2          CPHA          LL_USART_GetClockPhase
  686.   * @param  USARTx USART Instance
  687.   * @retval Returned value can be one of the following values:
  688.   *         @arg @ref LL_USART_PHASE_1EDGE
  689.   *         @arg @ref LL_USART_PHASE_2EDGE
  690.   */
  691. __STATIC_INLINE uint32_t LL_USART_GetClockPhase(const USART_TypeDef *USARTx)
  692. {
  693.   return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_CPHA));
  694. }
  695.  
  696. /**
  697.   * @brief  Select the polarity of the clock output on the SCLK pin in synchronous mode
  698.   * @note   Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
  699.   *         Synchronous mode is supported by the USARTx instance.
  700.   * @rmtoll CR2          CPOL          LL_USART_SetClockPolarity
  701.   * @param  USARTx USART Instance
  702.   * @param  ClockPolarity This parameter can be one of the following values:
  703.   *         @arg @ref LL_USART_POLARITY_LOW
  704.   *         @arg @ref LL_USART_POLARITY_HIGH
  705.   * @retval None
  706.   */
  707. __STATIC_INLINE void LL_USART_SetClockPolarity(USART_TypeDef *USARTx, uint32_t ClockPolarity)
  708. {
  709.   MODIFY_REG(USARTx->CR2, USART_CR2_CPOL, ClockPolarity);
  710. }
  711.  
  712. /**
  713.   * @brief  Return polarity of the clock output on the SCLK pin in synchronous mode
  714.   * @note   Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
  715.   *         Synchronous mode is supported by the USARTx instance.
  716.   * @rmtoll CR2          CPOL          LL_USART_GetClockPolarity
  717.   * @param  USARTx USART Instance
  718.   * @retval Returned value can be one of the following values:
  719.   *         @arg @ref LL_USART_POLARITY_LOW
  720.   *         @arg @ref LL_USART_POLARITY_HIGH
  721.   */
  722. __STATIC_INLINE uint32_t LL_USART_GetClockPolarity(const USART_TypeDef *USARTx)
  723. {
  724.   return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_CPOL));
  725. }
  726.  
  727. /**
  728.   * @brief  Configure Clock signal format (Phase Polarity and choice about output of last bit clock pulse)
  729.   * @note   Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
  730.   *         Synchronous mode is supported by the USARTx instance.
  731.   * @note   Call of this function is equivalent to following function call sequence :
  732.   *         - Clock Phase configuration using @ref LL_USART_SetClockPhase() function
  733.   *         - Clock Polarity configuration using @ref LL_USART_SetClockPolarity() function
  734.   *         - Output of Last bit Clock pulse configuration using @ref LL_USART_SetLastClkPulseOutput() function
  735.   * @rmtoll CR2          CPHA          LL_USART_ConfigClock\n
  736.   *         CR2          CPOL          LL_USART_ConfigClock\n
  737.   *         CR2          LBCL          LL_USART_ConfigClock
  738.   * @param  USARTx USART Instance
  739.   * @param  Phase This parameter can be one of the following values:
  740.   *         @arg @ref LL_USART_PHASE_1EDGE
  741.   *         @arg @ref LL_USART_PHASE_2EDGE
  742.   * @param  Polarity This parameter can be one of the following values:
  743.   *         @arg @ref LL_USART_POLARITY_LOW
  744.   *         @arg @ref LL_USART_POLARITY_HIGH
  745.   * @param  LBCPOutput This parameter can be one of the following values:
  746.   *         @arg @ref LL_USART_LASTCLKPULSE_NO_OUTPUT
  747.   *         @arg @ref LL_USART_LASTCLKPULSE_OUTPUT
  748.   * @retval None
  749.   */
  750. __STATIC_INLINE void LL_USART_ConfigClock(USART_TypeDef *USARTx, uint32_t Phase, uint32_t Polarity, uint32_t LBCPOutput)
  751. {
  752.   MODIFY_REG(USARTx->CR2, USART_CR2_CPHA | USART_CR2_CPOL | USART_CR2_LBCL, Phase | Polarity | LBCPOutput);
  753. }
  754.  
  755. /**
  756.   * @brief  Enable Clock output on SCLK pin
  757.   * @note   Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
  758.   *         Synchronous mode is supported by the USARTx instance.
  759.   * @rmtoll CR2          CLKEN         LL_USART_EnableSCLKOutput
  760.   * @param  USARTx USART Instance
  761.   * @retval None
  762.   */
  763. __STATIC_INLINE void LL_USART_EnableSCLKOutput(USART_TypeDef *USARTx)
  764. {
  765.   SET_BIT(USARTx->CR2, USART_CR2_CLKEN);
  766. }
  767.  
  768. /**
  769.   * @brief  Disable Clock output on SCLK pin
  770.   * @note   Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
  771.   *         Synchronous mode is supported by the USARTx instance.
  772.   * @rmtoll CR2          CLKEN         LL_USART_DisableSCLKOutput
  773.   * @param  USARTx USART Instance
  774.   * @retval None
  775.   */
  776. __STATIC_INLINE void LL_USART_DisableSCLKOutput(USART_TypeDef *USARTx)
  777. {
  778.   CLEAR_BIT(USARTx->CR2, USART_CR2_CLKEN);
  779. }
  780.  
  781. /**
  782.   * @brief  Indicate if Clock output on SCLK pin is enabled
  783.   * @note   Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
  784.   *         Synchronous mode is supported by the USARTx instance.
  785.   * @rmtoll CR2          CLKEN         LL_USART_IsEnabledSCLKOutput
  786.   * @param  USARTx USART Instance
  787.   * @retval State of bit (1 or 0).
  788.   */
  789. __STATIC_INLINE uint32_t LL_USART_IsEnabledSCLKOutput(const USART_TypeDef *USARTx)
  790. {
  791.   return (READ_BIT(USARTx->CR2, USART_CR2_CLKEN) == (USART_CR2_CLKEN));
  792. }
  793.  
  794. /**
  795.   * @brief  Set the length of the stop bits
  796.   * @rmtoll CR2          STOP          LL_USART_SetStopBitsLength
  797.   * @param  USARTx USART Instance
  798.   * @param  StopBits This parameter can be one of the following values:
  799.   *         @arg @ref LL_USART_STOPBITS_0_5
  800.   *         @arg @ref LL_USART_STOPBITS_1
  801.   *         @arg @ref LL_USART_STOPBITS_1_5
  802.   *         @arg @ref LL_USART_STOPBITS_2
  803.   * @retval None
  804.   */
  805. __STATIC_INLINE void LL_USART_SetStopBitsLength(USART_TypeDef *USARTx, uint32_t StopBits)
  806. {
  807.   MODIFY_REG(USARTx->CR2, USART_CR2_STOP, StopBits);
  808. }
  809.  
  810. /**
  811.   * @brief  Retrieve the length of the stop bits
  812.   * @rmtoll CR2          STOP          LL_USART_GetStopBitsLength
  813.   * @param  USARTx USART Instance
  814.   * @retval Returned value can be one of the following values:
  815.   *         @arg @ref LL_USART_STOPBITS_0_5
  816.   *         @arg @ref LL_USART_STOPBITS_1
  817.   *         @arg @ref LL_USART_STOPBITS_1_5
  818.   *         @arg @ref LL_USART_STOPBITS_2
  819.   */
  820. __STATIC_INLINE uint32_t LL_USART_GetStopBitsLength(const USART_TypeDef *USARTx)
  821. {
  822.   return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_STOP));
  823. }
  824.  
  825. /**
  826.   * @brief  Configure Character frame format (Datawidth, Parity control, Stop Bits)
  827.   * @note   Call of this function is equivalent to following function call sequence :
  828.   *         - Data Width configuration using @ref LL_USART_SetDataWidth() function
  829.   *         - Parity Control and mode configuration using @ref LL_USART_SetParity() function
  830.   *         - Stop bits configuration using @ref LL_USART_SetStopBitsLength() function
  831.   * @rmtoll CR1          PS            LL_USART_ConfigCharacter\n
  832.   *         CR1          PCE           LL_USART_ConfigCharacter\n
  833.   *         CR1          M             LL_USART_ConfigCharacter\n
  834.   *         CR2          STOP          LL_USART_ConfigCharacter
  835.   * @param  USARTx USART Instance
  836.   * @param  DataWidth This parameter can be one of the following values:
  837.   *         @arg @ref LL_USART_DATAWIDTH_8B
  838.   *         @arg @ref LL_USART_DATAWIDTH_9B
  839.   * @param  Parity This parameter can be one of the following values:
  840.   *         @arg @ref LL_USART_PARITY_NONE
  841.   *         @arg @ref LL_USART_PARITY_EVEN
  842.   *         @arg @ref LL_USART_PARITY_ODD
  843.   * @param  StopBits This parameter can be one of the following values:
  844.   *         @arg @ref LL_USART_STOPBITS_0_5
  845.   *         @arg @ref LL_USART_STOPBITS_1
  846.   *         @arg @ref LL_USART_STOPBITS_1_5
  847.   *         @arg @ref LL_USART_STOPBITS_2
  848.   * @retval None
  849.   */
  850. __STATIC_INLINE void LL_USART_ConfigCharacter(USART_TypeDef *USARTx, uint32_t DataWidth, uint32_t Parity,
  851.                                               uint32_t StopBits)
  852. {
  853.   MODIFY_REG(USARTx->CR1, USART_CR1_PS | USART_CR1_PCE | USART_CR1_M, Parity | DataWidth);
  854.   MODIFY_REG(USARTx->CR2, USART_CR2_STOP, StopBits);
  855. }
  856.  
  857. /**
  858.   * @brief  Set Address of the USART node.
  859.   * @note   This is used in multiprocessor communication during Mute mode or Stop mode,
  860.   *         for wake up with address mark detection.
  861.   * @rmtoll CR2          ADD           LL_USART_SetNodeAddress
  862.   * @param  USARTx USART Instance
  863.   * @param  NodeAddress 4 bit Address of the USART node.
  864.   * @retval None
  865.   */
  866. __STATIC_INLINE void LL_USART_SetNodeAddress(USART_TypeDef *USARTx, uint32_t NodeAddress)
  867. {
  868.   MODIFY_REG(USARTx->CR2, USART_CR2_ADD, (NodeAddress & USART_CR2_ADD));
  869. }
  870.  
  871. /**
  872.   * @brief  Return 4 bit Address of the USART node as set in ADD field of CR2.
  873.   * @note   only 4bits (b3-b0) of returned value are relevant (b31-b4 are not relevant)
  874.   * @rmtoll CR2          ADD           LL_USART_GetNodeAddress
  875.   * @param  USARTx USART Instance
  876.   * @retval Address of the USART node (Value between Min_Data=0 and Max_Data=255)
  877.   */
  878. __STATIC_INLINE uint32_t LL_USART_GetNodeAddress(const USART_TypeDef *USARTx)
  879. {
  880.   return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_ADD));
  881. }
  882.  
  883. /**
  884.   * @brief  Enable RTS HW Flow Control
  885.   * @note   Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
  886.   *         Hardware Flow control feature is supported by the USARTx instance.
  887.   * @rmtoll CR3          RTSE          LL_USART_EnableRTSHWFlowCtrl
  888.   * @param  USARTx USART Instance
  889.   * @retval None
  890.   */
  891. __STATIC_INLINE void LL_USART_EnableRTSHWFlowCtrl(USART_TypeDef *USARTx)
  892. {
  893.   SET_BIT(USARTx->CR3, USART_CR3_RTSE);
  894. }
  895.  
  896. /**
  897.   * @brief  Disable RTS HW Flow Control
  898.   * @note   Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
  899.   *         Hardware Flow control feature is supported by the USARTx instance.
  900.   * @rmtoll CR3          RTSE          LL_USART_DisableRTSHWFlowCtrl
  901.   * @param  USARTx USART Instance
  902.   * @retval None
  903.   */
  904. __STATIC_INLINE void LL_USART_DisableRTSHWFlowCtrl(USART_TypeDef *USARTx)
  905. {
  906.   CLEAR_BIT(USARTx->CR3, USART_CR3_RTSE);
  907. }
  908.  
  909. /**
  910.   * @brief  Enable CTS HW Flow Control
  911.   * @note   Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
  912.   *         Hardware Flow control feature is supported by the USARTx instance.
  913.   * @rmtoll CR3          CTSE          LL_USART_EnableCTSHWFlowCtrl
  914.   * @param  USARTx USART Instance
  915.   * @retval None
  916.   */
  917. __STATIC_INLINE void LL_USART_EnableCTSHWFlowCtrl(USART_TypeDef *USARTx)
  918. {
  919.   SET_BIT(USARTx->CR3, USART_CR3_CTSE);
  920. }
  921.  
  922. /**
  923.   * @brief  Disable CTS HW Flow Control
  924.   * @note   Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
  925.   *         Hardware Flow control feature is supported by the USARTx instance.
  926.   * @rmtoll CR3          CTSE          LL_USART_DisableCTSHWFlowCtrl
  927.   * @param  USARTx USART Instance
  928.   * @retval None
  929.   */
  930. __STATIC_INLINE void LL_USART_DisableCTSHWFlowCtrl(USART_TypeDef *USARTx)
  931. {
  932.   CLEAR_BIT(USARTx->CR3, USART_CR3_CTSE);
  933. }
  934.  
  935. /**
  936.   * @brief  Configure HW Flow Control mode (both CTS and RTS)
  937.   * @note   Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
  938.   *         Hardware Flow control feature is supported by the USARTx instance.
  939.   * @rmtoll CR3          RTSE          LL_USART_SetHWFlowCtrl\n
  940.   *         CR3          CTSE          LL_USART_SetHWFlowCtrl
  941.   * @param  USARTx USART Instance
  942.   * @param  HardwareFlowControl This parameter can be one of the following values:
  943.   *         @arg @ref LL_USART_HWCONTROL_NONE
  944.   *         @arg @ref LL_USART_HWCONTROL_RTS
  945.   *         @arg @ref LL_USART_HWCONTROL_CTS
  946.   *         @arg @ref LL_USART_HWCONTROL_RTS_CTS
  947.   * @retval None
  948.   */
  949. __STATIC_INLINE void LL_USART_SetHWFlowCtrl(USART_TypeDef *USARTx, uint32_t HardwareFlowControl)
  950. {
  951.   MODIFY_REG(USARTx->CR3, USART_CR3_RTSE | USART_CR3_CTSE, HardwareFlowControl);
  952. }
  953.  
  954. /**
  955.   * @brief  Return HW Flow Control configuration (both CTS and RTS)
  956.   * @note   Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
  957.   *         Hardware Flow control feature is supported by the USARTx instance.
  958.   * @rmtoll CR3          RTSE          LL_USART_GetHWFlowCtrl\n
  959.   *         CR3          CTSE          LL_USART_GetHWFlowCtrl
  960.   * @param  USARTx USART Instance
  961.   * @retval Returned value can be one of the following values:
  962.   *         @arg @ref LL_USART_HWCONTROL_NONE
  963.   *         @arg @ref LL_USART_HWCONTROL_RTS
  964.   *         @arg @ref LL_USART_HWCONTROL_CTS
  965.   *         @arg @ref LL_USART_HWCONTROL_RTS_CTS
  966.   */
  967. __STATIC_INLINE uint32_t LL_USART_GetHWFlowCtrl(const USART_TypeDef *USARTx)
  968. {
  969.   return (uint32_t)(READ_BIT(USARTx->CR3, USART_CR3_RTSE | USART_CR3_CTSE));
  970. }
  971.  
  972. /**
  973.   * @brief  Enable One bit sampling method
  974.   * @rmtoll CR3          ONEBIT        LL_USART_EnableOneBitSamp
  975.   * @param  USARTx USART Instance
  976.   * @retval None
  977.   */
  978. __STATIC_INLINE void LL_USART_EnableOneBitSamp(USART_TypeDef *USARTx)
  979. {
  980.   SET_BIT(USARTx->CR3, USART_CR3_ONEBIT);
  981. }
  982.  
  983. /**
  984.   * @brief  Disable One bit sampling method
  985.   * @rmtoll CR3          ONEBIT        LL_USART_DisableOneBitSamp
  986.   * @param  USARTx USART Instance
  987.   * @retval None
  988.   */
  989. __STATIC_INLINE void LL_USART_DisableOneBitSamp(USART_TypeDef *USARTx)
  990. {
  991.   CLEAR_BIT(USARTx->CR3, USART_CR3_ONEBIT);
  992. }
  993.  
  994. /**
  995.   * @brief  Indicate if One bit sampling method is enabled
  996.   * @rmtoll CR3          ONEBIT        LL_USART_IsEnabledOneBitSamp
  997.   * @param  USARTx USART Instance
  998.   * @retval State of bit (1 or 0).
  999.   */
  1000. __STATIC_INLINE uint32_t LL_USART_IsEnabledOneBitSamp(const USART_TypeDef *USARTx)
  1001. {
  1002.   return (READ_BIT(USARTx->CR3, USART_CR3_ONEBIT) == (USART_CR3_ONEBIT));
  1003. }
  1004.  
  1005. /**
  1006.   * @brief  Configure USART BRR register for achieving expected Baud Rate value.
  1007.   * @note   Compute and set USARTDIV value in BRR Register (full BRR content)
  1008.   *         according to used Peripheral Clock, Oversampling mode, and expected Baud Rate values
  1009.   * @note   Peripheral clock and Baud rate values provided as function parameters should be valid
  1010.   *         (Baud rate value != 0)
  1011.   * @rmtoll BRR          BRR           LL_USART_SetBaudRate
  1012.   * @param  USARTx USART Instance
  1013.   * @param  PeriphClk Peripheral Clock
  1014.   * @param  OverSampling This parameter can be one of the following values:
  1015.   *         @arg @ref LL_USART_OVERSAMPLING_16
  1016.   *         @arg @ref LL_USART_OVERSAMPLING_8
  1017.   * @param  BaudRate Baud Rate
  1018.   * @retval None
  1019.   */
  1020. __STATIC_INLINE void LL_USART_SetBaudRate(USART_TypeDef *USARTx, uint32_t PeriphClk, uint32_t OverSampling,
  1021.                                           uint32_t BaudRate)
  1022. {
  1023.   if (OverSampling == LL_USART_OVERSAMPLING_8)
  1024.   {
  1025.     USARTx->BRR = (uint16_t)(__LL_USART_DIV_SAMPLING8(PeriphClk, BaudRate));
  1026.   }
  1027.   else
  1028.   {
  1029.     USARTx->BRR = (uint16_t)(__LL_USART_DIV_SAMPLING16(PeriphClk, BaudRate));
  1030.   }
  1031. }
  1032.  
  1033. /**
  1034.   * @brief  Return current Baud Rate value, according to USARTDIV present in BRR register
  1035.   *         (full BRR content), and to used Peripheral Clock and Oversampling mode values
  1036.   * @note   In case of non-initialized or invalid value stored in BRR register, value 0 will be returned.
  1037.   * @rmtoll BRR          BRR           LL_USART_GetBaudRate
  1038.   * @param  USARTx USART Instance
  1039.   * @param  PeriphClk Peripheral Clock
  1040.   * @param  OverSampling This parameter can be one of the following values:
  1041.   *         @arg @ref LL_USART_OVERSAMPLING_16
  1042.   *         @arg @ref LL_USART_OVERSAMPLING_8
  1043.   * @retval Baud Rate
  1044.   */
  1045. __STATIC_INLINE uint32_t LL_USART_GetBaudRate(const USART_TypeDef *USARTx, uint32_t PeriphClk, uint32_t OverSampling)
  1046. {
  1047.   uint32_t usartdiv = 0x0U;
  1048.   uint32_t brrresult = 0x0U;
  1049.  
  1050.   usartdiv = USARTx->BRR;
  1051.  
  1052.   if (OverSampling == LL_USART_OVERSAMPLING_8)
  1053.   {
  1054.     if ((usartdiv & 0xFFF7U) != 0U)
  1055.     {
  1056.       usartdiv = (uint16_t)((usartdiv & 0xFFF0U) | ((usartdiv & 0x0007U) << 1U)) ;
  1057.       brrresult = (PeriphClk * 2U) / usartdiv;
  1058.     }
  1059.   }
  1060.   else
  1061.   {
  1062.     if ((usartdiv & 0xFFFFU) != 0U)
  1063.     {
  1064.       brrresult = PeriphClk / usartdiv;
  1065.     }
  1066.   }
  1067.   return (brrresult);
  1068. }
  1069.  
  1070. /**
  1071.   * @}
  1072.   */
  1073.  
  1074. /** @defgroup USART_LL_EF_Configuration_IRDA Configuration functions related to Irda feature
  1075.   * @{
  1076.   */
  1077.  
  1078. /**
  1079.   * @brief  Enable IrDA mode
  1080.   * @note   Macro IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
  1081.   *         IrDA feature is supported by the USARTx instance.
  1082.   * @rmtoll CR3          IREN          LL_USART_EnableIrda
  1083.   * @param  USARTx USART Instance
  1084.   * @retval None
  1085.   */
  1086. __STATIC_INLINE void LL_USART_EnableIrda(USART_TypeDef *USARTx)
  1087. {
  1088.   SET_BIT(USARTx->CR3, USART_CR3_IREN);
  1089. }
  1090.  
  1091. /**
  1092.   * @brief  Disable IrDA mode
  1093.   * @note   Macro IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
  1094.   *         IrDA feature is supported by the USARTx instance.
  1095.   * @rmtoll CR3          IREN          LL_USART_DisableIrda
  1096.   * @param  USARTx USART Instance
  1097.   * @retval None
  1098.   */
  1099. __STATIC_INLINE void LL_USART_DisableIrda(USART_TypeDef *USARTx)
  1100. {
  1101.   CLEAR_BIT(USARTx->CR3, USART_CR3_IREN);
  1102. }
  1103.  
  1104. /**
  1105.   * @brief  Indicate if IrDA mode is enabled
  1106.   * @note   Macro IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
  1107.   *         IrDA feature is supported by the USARTx instance.
  1108.   * @rmtoll CR3          IREN          LL_USART_IsEnabledIrda
  1109.   * @param  USARTx USART Instance
  1110.   * @retval State of bit (1 or 0).
  1111.   */
  1112. __STATIC_INLINE uint32_t LL_USART_IsEnabledIrda(const USART_TypeDef *USARTx)
  1113. {
  1114.   return (READ_BIT(USARTx->CR3, USART_CR3_IREN) == (USART_CR3_IREN));
  1115. }
  1116.  
  1117. /**
  1118.   * @brief  Configure IrDA Power Mode (Normal or Low Power)
  1119.   * @note   Macro IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
  1120.   *         IrDA feature is supported by the USARTx instance.
  1121.   * @rmtoll CR3          IRLP          LL_USART_SetIrdaPowerMode
  1122.   * @param  USARTx USART Instance
  1123.   * @param  PowerMode This parameter can be one of the following values:
  1124.   *         @arg @ref LL_USART_IRDA_POWER_NORMAL
  1125.   *         @arg @ref LL_USART_IRDA_POWER_LOW
  1126.   * @retval None
  1127.   */
  1128. __STATIC_INLINE void LL_USART_SetIrdaPowerMode(USART_TypeDef *USARTx, uint32_t PowerMode)
  1129. {
  1130.   MODIFY_REG(USARTx->CR3, USART_CR3_IRLP, PowerMode);
  1131. }
  1132.  
  1133. /**
  1134.   * @brief  Retrieve IrDA Power Mode configuration (Normal or Low Power)
  1135.   * @note   Macro IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
  1136.   *         IrDA feature is supported by the USARTx instance.
  1137.   * @rmtoll CR3          IRLP          LL_USART_GetIrdaPowerMode
  1138.   * @param  USARTx USART Instance
  1139.   * @retval Returned value can be one of the following values:
  1140.   *         @arg @ref LL_USART_IRDA_POWER_NORMAL
  1141.   *         @arg @ref LL_USART_PHASE_2EDGE
  1142.   */
  1143. __STATIC_INLINE uint32_t LL_USART_GetIrdaPowerMode(const USART_TypeDef *USARTx)
  1144. {
  1145.   return (uint32_t)(READ_BIT(USARTx->CR3, USART_CR3_IRLP));
  1146. }
  1147.  
  1148. /**
  1149.   * @brief  Set Irda prescaler value, used for dividing the USART clock source
  1150.   *         to achieve the Irda Low Power frequency (8 bits value)
  1151.   * @note   Macro IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
  1152.   *         IrDA feature is supported by the USARTx instance.
  1153.   * @rmtoll GTPR         PSC           LL_USART_SetIrdaPrescaler
  1154.   * @param  USARTx USART Instance
  1155.   * @param  PrescalerValue Value between Min_Data=0x00 and Max_Data=0xFF
  1156.   * @retval None
  1157.   */
  1158. __STATIC_INLINE void LL_USART_SetIrdaPrescaler(USART_TypeDef *USARTx, uint32_t PrescalerValue)
  1159. {
  1160.   MODIFY_REG(USARTx->GTPR, USART_GTPR_PSC, PrescalerValue);
  1161. }
  1162.  
  1163. /**
  1164.   * @brief  Return Irda prescaler value, used for dividing the USART clock source
  1165.   *         to achieve the Irda Low Power frequency (8 bits value)
  1166.   * @note   Macro IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
  1167.   *         IrDA feature is supported by the USARTx instance.
  1168.   * @rmtoll GTPR         PSC           LL_USART_GetIrdaPrescaler
  1169.   * @param  USARTx USART Instance
  1170.   * @retval Irda prescaler value (Value between Min_Data=0x00 and Max_Data=0xFF)
  1171.   */
  1172. __STATIC_INLINE uint32_t LL_USART_GetIrdaPrescaler(const USART_TypeDef *USARTx)
  1173. {
  1174.   return (uint32_t)(READ_BIT(USARTx->GTPR, USART_GTPR_PSC));
  1175. }
  1176.  
  1177. /**
  1178.   * @}
  1179.   */
  1180.  
  1181. /** @defgroup USART_LL_EF_Configuration_Smartcard Configuration functions related to Smartcard feature
  1182.   * @{
  1183.   */
  1184.  
  1185. /**
  1186.   * @brief  Enable Smartcard NACK transmission
  1187.   * @note   Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
  1188.   *         Smartcard feature is supported by the USARTx instance.
  1189.   * @rmtoll CR3          NACK          LL_USART_EnableSmartcardNACK
  1190.   * @param  USARTx USART Instance
  1191.   * @retval None
  1192.   */
  1193. __STATIC_INLINE void LL_USART_EnableSmartcardNACK(USART_TypeDef *USARTx)
  1194. {
  1195.   SET_BIT(USARTx->CR3, USART_CR3_NACK);
  1196. }
  1197.  
  1198. /**
  1199.   * @brief  Disable Smartcard NACK transmission
  1200.   * @note   Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
  1201.   *         Smartcard feature is supported by the USARTx instance.
  1202.   * @rmtoll CR3          NACK          LL_USART_DisableSmartcardNACK
  1203.   * @param  USARTx USART Instance
  1204.   * @retval None
  1205.   */
  1206. __STATIC_INLINE void LL_USART_DisableSmartcardNACK(USART_TypeDef *USARTx)
  1207. {
  1208.   CLEAR_BIT(USARTx->CR3, USART_CR3_NACK);
  1209. }
  1210.  
  1211. /**
  1212.   * @brief  Indicate if Smartcard NACK transmission is enabled
  1213.   * @note   Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
  1214.   *         Smartcard feature is supported by the USARTx instance.
  1215.   * @rmtoll CR3          NACK          LL_USART_IsEnabledSmartcardNACK
  1216.   * @param  USARTx USART Instance
  1217.   * @retval State of bit (1 or 0).
  1218.   */
  1219. __STATIC_INLINE uint32_t LL_USART_IsEnabledSmartcardNACK(const USART_TypeDef *USARTx)
  1220. {
  1221.   return (READ_BIT(USARTx->CR3, USART_CR3_NACK) == (USART_CR3_NACK));
  1222. }
  1223.  
  1224. /**
  1225.   * @brief  Enable Smartcard mode
  1226.   * @note   Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
  1227.   *         Smartcard feature is supported by the USARTx instance.
  1228.   * @rmtoll CR3          SCEN          LL_USART_EnableSmartcard
  1229.   * @param  USARTx USART Instance
  1230.   * @retval None
  1231.   */
  1232. __STATIC_INLINE void LL_USART_EnableSmartcard(USART_TypeDef *USARTx)
  1233. {
  1234.   SET_BIT(USARTx->CR3, USART_CR3_SCEN);
  1235. }
  1236.  
  1237. /**
  1238.   * @brief  Disable Smartcard mode
  1239.   * @note   Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
  1240.   *         Smartcard feature is supported by the USARTx instance.
  1241.   * @rmtoll CR3          SCEN          LL_USART_DisableSmartcard
  1242.   * @param  USARTx USART Instance
  1243.   * @retval None
  1244.   */
  1245. __STATIC_INLINE void LL_USART_DisableSmartcard(USART_TypeDef *USARTx)
  1246. {
  1247.   CLEAR_BIT(USARTx->CR3, USART_CR3_SCEN);
  1248. }
  1249.  
  1250. /**
  1251.   * @brief  Indicate if Smartcard mode is enabled
  1252.   * @note   Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
  1253.   *         Smartcard feature is supported by the USARTx instance.
  1254.   * @rmtoll CR3          SCEN          LL_USART_IsEnabledSmartcard
  1255.   * @param  USARTx USART Instance
  1256.   * @retval State of bit (1 or 0).
  1257.   */
  1258. __STATIC_INLINE uint32_t LL_USART_IsEnabledSmartcard(const USART_TypeDef *USARTx)
  1259. {
  1260.   return (READ_BIT(USARTx->CR3, USART_CR3_SCEN) == (USART_CR3_SCEN));
  1261. }
  1262.  
  1263. /**
  1264.   * @brief  Set Smartcard prescaler value, used for dividing the USART clock
  1265.   *         source to provide the SMARTCARD Clock (5 bits value)
  1266.   * @note   Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
  1267.   *         Smartcard feature is supported by the USARTx instance.
  1268.   * @rmtoll GTPR         PSC           LL_USART_SetSmartcardPrescaler
  1269.   * @param  USARTx USART Instance
  1270.   * @param  PrescalerValue Value between Min_Data=0 and Max_Data=31
  1271.   * @retval None
  1272.   */
  1273. __STATIC_INLINE void LL_USART_SetSmartcardPrescaler(USART_TypeDef *USARTx, uint32_t PrescalerValue)
  1274. {
  1275.   MODIFY_REG(USARTx->GTPR, USART_GTPR_PSC, PrescalerValue);
  1276. }
  1277.  
  1278. /**
  1279.   * @brief  Return Smartcard prescaler value, used for dividing the USART clock
  1280.   *         source to provide the SMARTCARD Clock (5 bits value)
  1281.   * @note   Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
  1282.   *         Smartcard feature is supported by the USARTx instance.
  1283.   * @rmtoll GTPR         PSC           LL_USART_GetSmartcardPrescaler
  1284.   * @param  USARTx USART Instance
  1285.   * @retval Smartcard prescaler value (Value between Min_Data=0 and Max_Data=31)
  1286.   */
  1287. __STATIC_INLINE uint32_t LL_USART_GetSmartcardPrescaler(const USART_TypeDef *USARTx)
  1288. {
  1289.   return (uint32_t)(READ_BIT(USARTx->GTPR, USART_GTPR_PSC));
  1290. }
  1291.  
  1292. /**
  1293.   * @brief  Set Smartcard Guard time value, expressed in nb of baud clocks periods
  1294.   *         (GT[7:0] bits : Guard time value)
  1295.   * @note   Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
  1296.   *         Smartcard feature is supported by the USARTx instance.
  1297.   * @rmtoll GTPR         GT            LL_USART_SetSmartcardGuardTime
  1298.   * @param  USARTx USART Instance
  1299.   * @param  GuardTime Value between Min_Data=0x00 and Max_Data=0xFF
  1300.   * @retval None
  1301.   */
  1302. __STATIC_INLINE void LL_USART_SetSmartcardGuardTime(USART_TypeDef *USARTx, uint32_t GuardTime)
  1303. {
  1304.   MODIFY_REG(USARTx->GTPR, USART_GTPR_GT, GuardTime << USART_POSITION_GTPR_GT);
  1305. }
  1306.  
  1307. /**
  1308.   * @brief  Return Smartcard Guard time value, expressed in nb of baud clocks periods
  1309.   *         (GT[7:0] bits : Guard time value)
  1310.   * @note   Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
  1311.   *         Smartcard feature is supported by the USARTx instance.
  1312.   * @rmtoll GTPR         GT            LL_USART_GetSmartcardGuardTime
  1313.   * @param  USARTx USART Instance
  1314.   * @retval Smartcard Guard time value (Value between Min_Data=0x00 and Max_Data=0xFF)
  1315.   */
  1316. __STATIC_INLINE uint32_t LL_USART_GetSmartcardGuardTime(const USART_TypeDef *USARTx)
  1317. {
  1318.   return (uint32_t)(READ_BIT(USARTx->GTPR, USART_GTPR_GT) >> USART_POSITION_GTPR_GT);
  1319. }
  1320.  
  1321. /**
  1322.   * @}
  1323.   */
  1324.  
  1325. /** @defgroup USART_LL_EF_Configuration_HalfDuplex Configuration functions related to Half Duplex feature
  1326.   * @{
  1327.   */
  1328.  
  1329. /**
  1330.   * @brief  Enable Single Wire Half-Duplex mode
  1331.   * @note   Macro IS_UART_HALFDUPLEX_INSTANCE(USARTx) can be used to check whether or not
  1332.   *         Half-Duplex mode is supported by the USARTx instance.
  1333.   * @rmtoll CR3          HDSEL         LL_USART_EnableHalfDuplex
  1334.   * @param  USARTx USART Instance
  1335.   * @retval None
  1336.   */
  1337. __STATIC_INLINE void LL_USART_EnableHalfDuplex(USART_TypeDef *USARTx)
  1338. {
  1339.   SET_BIT(USARTx->CR3, USART_CR3_HDSEL);
  1340. }
  1341.  
  1342. /**
  1343.   * @brief  Disable Single Wire Half-Duplex mode
  1344.   * @note   Macro IS_UART_HALFDUPLEX_INSTANCE(USARTx) can be used to check whether or not
  1345.   *         Half-Duplex mode is supported by the USARTx instance.
  1346.   * @rmtoll CR3          HDSEL         LL_USART_DisableHalfDuplex
  1347.   * @param  USARTx USART Instance
  1348.   * @retval None
  1349.   */
  1350. __STATIC_INLINE void LL_USART_DisableHalfDuplex(USART_TypeDef *USARTx)
  1351. {
  1352.   CLEAR_BIT(USARTx->CR3, USART_CR3_HDSEL);
  1353. }
  1354.  
  1355. /**
  1356.   * @brief  Indicate if Single Wire Half-Duplex mode is enabled
  1357.   * @note   Macro IS_UART_HALFDUPLEX_INSTANCE(USARTx) can be used to check whether or not
  1358.   *         Half-Duplex mode is supported by the USARTx instance.
  1359.   * @rmtoll CR3          HDSEL         LL_USART_IsEnabledHalfDuplex
  1360.   * @param  USARTx USART Instance
  1361.   * @retval State of bit (1 or 0).
  1362.   */
  1363. __STATIC_INLINE uint32_t LL_USART_IsEnabledHalfDuplex(const USART_TypeDef *USARTx)
  1364. {
  1365.   return (READ_BIT(USARTx->CR3, USART_CR3_HDSEL) == (USART_CR3_HDSEL));
  1366. }
  1367.  
  1368. /**
  1369.   * @}
  1370.   */
  1371.  
  1372. /** @defgroup USART_LL_EF_Configuration_LIN Configuration functions related to LIN feature
  1373.   * @{
  1374.   */
  1375.  
  1376. /**
  1377.   * @brief  Set LIN Break Detection Length
  1378.   * @note   Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
  1379.   *         LIN feature is supported by the USARTx instance.
  1380.   * @rmtoll CR2          LBDL          LL_USART_SetLINBrkDetectionLen
  1381.   * @param  USARTx USART Instance
  1382.   * @param  LINBDLength This parameter can be one of the following values:
  1383.   *         @arg @ref LL_USART_LINBREAK_DETECT_10B
  1384.   *         @arg @ref LL_USART_LINBREAK_DETECT_11B
  1385.   * @retval None
  1386.   */
  1387. __STATIC_INLINE void LL_USART_SetLINBrkDetectionLen(USART_TypeDef *USARTx, uint32_t LINBDLength)
  1388. {
  1389.   MODIFY_REG(USARTx->CR2, USART_CR2_LBDL, LINBDLength);
  1390. }
  1391.  
  1392. /**
  1393.   * @brief  Return LIN Break Detection Length
  1394.   * @note   Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
  1395.   *         LIN feature is supported by the USARTx instance.
  1396.   * @rmtoll CR2          LBDL          LL_USART_GetLINBrkDetectionLen
  1397.   * @param  USARTx USART Instance
  1398.   * @retval Returned value can be one of the following values:
  1399.   *         @arg @ref LL_USART_LINBREAK_DETECT_10B
  1400.   *         @arg @ref LL_USART_LINBREAK_DETECT_11B
  1401.   */
  1402. __STATIC_INLINE uint32_t LL_USART_GetLINBrkDetectionLen(const USART_TypeDef *USARTx)
  1403. {
  1404.   return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_LBDL));
  1405. }
  1406.  
  1407. /**
  1408.   * @brief  Enable LIN mode
  1409.   * @note   Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
  1410.   *         LIN feature is supported by the USARTx instance.
  1411.   * @rmtoll CR2          LINEN         LL_USART_EnableLIN
  1412.   * @param  USARTx USART Instance
  1413.   * @retval None
  1414.   */
  1415. __STATIC_INLINE void LL_USART_EnableLIN(USART_TypeDef *USARTx)
  1416. {
  1417.   SET_BIT(USARTx->CR2, USART_CR2_LINEN);
  1418. }
  1419.  
  1420. /**
  1421.   * @brief  Disable LIN mode
  1422.   * @note   Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
  1423.   *         LIN feature is supported by the USARTx instance.
  1424.   * @rmtoll CR2          LINEN         LL_USART_DisableLIN
  1425.   * @param  USARTx USART Instance
  1426.   * @retval None
  1427.   */
  1428. __STATIC_INLINE void LL_USART_DisableLIN(USART_TypeDef *USARTx)
  1429. {
  1430.   CLEAR_BIT(USARTx->CR2, USART_CR2_LINEN);
  1431. }
  1432.  
  1433. /**
  1434.   * @brief  Indicate if LIN mode is enabled
  1435.   * @note   Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
  1436.   *         LIN feature is supported by the USARTx instance.
  1437.   * @rmtoll CR2          LINEN         LL_USART_IsEnabledLIN
  1438.   * @param  USARTx USART Instance
  1439.   * @retval State of bit (1 or 0).
  1440.   */
  1441. __STATIC_INLINE uint32_t LL_USART_IsEnabledLIN(const USART_TypeDef *USARTx)
  1442. {
  1443.   return (READ_BIT(USARTx->CR2, USART_CR2_LINEN) == (USART_CR2_LINEN));
  1444. }
  1445.  
  1446. /**
  1447.   * @}
  1448.   */
  1449.  
  1450. /** @defgroup USART_LL_EF_AdvancedConfiguration Advanced Configurations services
  1451.   * @{
  1452.   */
  1453.  
  1454. /**
  1455.   * @brief  Perform basic configuration of USART for enabling use in Asynchronous Mode (UART)
  1456.   * @note   In UART mode, the following bits must be kept cleared:
  1457.   *           - LINEN bit in the USART_CR2 register,
  1458.   *           - CLKEN bit in the USART_CR2 register,
  1459.   *           - SCEN bit in the USART_CR3 register,
  1460.   *           - IREN bit in the USART_CR3 register,
  1461.   *           - HDSEL bit in the USART_CR3 register.
  1462.   * @note   Call of this function is equivalent to following function call sequence :
  1463.   *         - Clear LINEN in CR2 using @ref LL_USART_DisableLIN() function
  1464.   *         - Clear CLKEN in CR2 using @ref LL_USART_DisableSCLKOutput() function
  1465.   *         - Clear SCEN in CR3 using @ref LL_USART_DisableSmartcard() function
  1466.   *         - Clear IREN in CR3 using @ref LL_USART_DisableIrda() function
  1467.   *         - Clear HDSEL in CR3 using @ref LL_USART_DisableHalfDuplex() function
  1468.   * @note   Other remaining configurations items related to Asynchronous Mode
  1469.   *         (as Baud Rate, Word length, Parity, ...) should be set using
  1470.   *         dedicated functions
  1471.   * @rmtoll CR2          LINEN         LL_USART_ConfigAsyncMode\n
  1472.   *         CR2          CLKEN         LL_USART_ConfigAsyncMode\n
  1473.   *         CR3          SCEN          LL_USART_ConfigAsyncMode\n
  1474.   *         CR3          IREN          LL_USART_ConfigAsyncMode\n
  1475.   *         CR3          HDSEL         LL_USART_ConfigAsyncMode
  1476.   * @param  USARTx USART Instance
  1477.   * @retval None
  1478.   */
  1479. __STATIC_INLINE void LL_USART_ConfigAsyncMode(USART_TypeDef *USARTx)
  1480. {
  1481.   /* In Asynchronous mode, the following bits must be kept cleared:
  1482.   - LINEN, CLKEN bits in the USART_CR2 register,
  1483.   - SCEN, IREN and HDSEL bits in the USART_CR3 register.*/
  1484.   CLEAR_BIT(USARTx->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));
  1485.   CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN | USART_CR3_IREN | USART_CR3_HDSEL));
  1486. }
  1487.  
  1488. /**
  1489.   * @brief  Perform basic configuration of USART for enabling use in Synchronous Mode
  1490.   * @note   In Synchronous mode, the following bits must be kept cleared:
  1491.   *           - LINEN bit in the USART_CR2 register,
  1492.   *           - SCEN bit in the USART_CR3 register,
  1493.   *           - IREN bit in the USART_CR3 register,
  1494.   *           - HDSEL bit in the USART_CR3 register.
  1495.   *         This function also sets the USART in Synchronous mode.
  1496.   * @note   Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
  1497.   *         Synchronous mode is supported by the USARTx instance.
  1498.   * @note   Call of this function is equivalent to following function call sequence :
  1499.   *         - Clear LINEN in CR2 using @ref LL_USART_DisableLIN() function
  1500.   *         - Clear IREN in CR3 using @ref LL_USART_DisableIrda() function
  1501.   *         - Clear SCEN in CR3 using @ref LL_USART_DisableSmartcard() function
  1502.   *         - Clear HDSEL in CR3 using @ref LL_USART_DisableHalfDuplex() function
  1503.   *         - Set CLKEN in CR2 using @ref LL_USART_EnableSCLKOutput() function
  1504.   * @note   Other remaining configurations items related to Synchronous Mode
  1505.   *         (as Baud Rate, Word length, Parity, Clock Polarity, ...) should be set using
  1506.   *         dedicated functions
  1507.   * @rmtoll CR2          LINEN         LL_USART_ConfigSyncMode\n
  1508.   *         CR2          CLKEN         LL_USART_ConfigSyncMode\n
  1509.   *         CR3          SCEN          LL_USART_ConfigSyncMode\n
  1510.   *         CR3          IREN          LL_USART_ConfigSyncMode\n
  1511.   *         CR3          HDSEL         LL_USART_ConfigSyncMode
  1512.   * @param  USARTx USART Instance
  1513.   * @retval None
  1514.   */
  1515. __STATIC_INLINE void LL_USART_ConfigSyncMode(USART_TypeDef *USARTx)
  1516. {
  1517.   /* In Synchronous mode, the following bits must be kept cleared:
  1518.   - LINEN bit in the USART_CR2 register,
  1519.   - SCEN, IREN and HDSEL bits in the USART_CR3 register.*/
  1520.   CLEAR_BIT(USARTx->CR2, (USART_CR2_LINEN));
  1521.   CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN | USART_CR3_IREN | USART_CR3_HDSEL));
  1522.   /* set the UART/USART in Synchronous mode */
  1523.   SET_BIT(USARTx->CR2, USART_CR2_CLKEN);
  1524. }
  1525.  
  1526. /**
  1527.   * @brief  Perform basic configuration of USART for enabling use in LIN Mode
  1528.   * @note   In LIN mode, the following bits must be kept cleared:
  1529.   *           - STOP and CLKEN bits in the USART_CR2 register,
  1530.   *           - SCEN bit in the USART_CR3 register,
  1531.   *           - IREN bit in the USART_CR3 register,
  1532.   *           - HDSEL bit in the USART_CR3 register.
  1533.   *         This function also set the UART/USART in LIN mode.
  1534.   * @note   Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
  1535.   *         LIN feature is supported by the USARTx instance.
  1536.   * @note   Call of this function is equivalent to following function call sequence :
  1537.   *         - Clear CLKEN in CR2 using @ref LL_USART_DisableSCLKOutput() function
  1538.   *         - Clear STOP in CR2 using @ref LL_USART_SetStopBitsLength() function
  1539.   *         - Clear SCEN in CR3 using @ref LL_USART_DisableSmartcard() function
  1540.   *         - Clear IREN in CR3 using @ref LL_USART_DisableIrda() function
  1541.   *         - Clear HDSEL in CR3 using @ref LL_USART_DisableHalfDuplex() function
  1542.   *         - Set LINEN in CR2 using @ref LL_USART_EnableLIN() function
  1543.   * @note   Other remaining configurations items related to LIN Mode
  1544.   *         (as Baud Rate, Word length, LIN Break Detection Length, ...) should be set using
  1545.   *         dedicated functions
  1546.   * @rmtoll CR2          CLKEN         LL_USART_ConfigLINMode\n
  1547.   *         CR2          STOP          LL_USART_ConfigLINMode\n
  1548.   *         CR2          LINEN         LL_USART_ConfigLINMode\n
  1549.   *         CR3          IREN          LL_USART_ConfigLINMode\n
  1550.   *         CR3          SCEN          LL_USART_ConfigLINMode\n
  1551.   *         CR3          HDSEL         LL_USART_ConfigLINMode
  1552.   * @param  USARTx USART Instance
  1553.   * @retval None
  1554.   */
  1555. __STATIC_INLINE void LL_USART_ConfigLINMode(USART_TypeDef *USARTx)
  1556. {
  1557.   /* In LIN mode, the following bits must be kept cleared:
  1558.   - STOP and CLKEN bits in the USART_CR2 register,
  1559.   - IREN, SCEN and HDSEL bits in the USART_CR3 register.*/
  1560.   CLEAR_BIT(USARTx->CR2, (USART_CR2_CLKEN | USART_CR2_STOP));
  1561.   CLEAR_BIT(USARTx->CR3, (USART_CR3_IREN | USART_CR3_SCEN | USART_CR3_HDSEL));
  1562.   /* Set the UART/USART in LIN mode */
  1563.   SET_BIT(USARTx->CR2, USART_CR2_LINEN);
  1564. }
  1565.  
  1566. /**
  1567.   * @brief  Perform basic configuration of USART for enabling use in Half Duplex Mode
  1568.   * @note   In Half Duplex mode, the following bits must be kept cleared:
  1569.   *           - LINEN bit in the USART_CR2 register,
  1570.   *           - CLKEN bit in the USART_CR2 register,
  1571.   *           - SCEN bit in the USART_CR3 register,
  1572.   *           - IREN bit in the USART_CR3 register,
  1573.   *         This function also sets the UART/USART in Half Duplex mode.
  1574.   * @note   Macro IS_UART_HALFDUPLEX_INSTANCE(USARTx) can be used to check whether or not
  1575.   *         Half-Duplex mode is supported by the USARTx instance.
  1576.   * @note   Call of this function is equivalent to following function call sequence :
  1577.   *         - Clear LINEN in CR2 using @ref LL_USART_DisableLIN() function
  1578.   *         - Clear CLKEN in CR2 using @ref LL_USART_DisableSCLKOutput() function
  1579.   *         - Clear SCEN in CR3 using @ref LL_USART_DisableSmartcard() function
  1580.   *         - Clear IREN in CR3 using @ref LL_USART_DisableIrda() function
  1581.   *         - Set HDSEL in CR3 using @ref LL_USART_EnableHalfDuplex() function
  1582.   * @note   Other remaining configurations items related to Half Duplex Mode
  1583.   *         (as Baud Rate, Word length, Parity, ...) should be set using
  1584.   *         dedicated functions
  1585.   * @rmtoll CR2          LINEN         LL_USART_ConfigHalfDuplexMode\n
  1586.   *         CR2          CLKEN         LL_USART_ConfigHalfDuplexMode\n
  1587.   *         CR3          HDSEL         LL_USART_ConfigHalfDuplexMode\n
  1588.   *         CR3          SCEN          LL_USART_ConfigHalfDuplexMode\n
  1589.   *         CR3          IREN          LL_USART_ConfigHalfDuplexMode
  1590.   * @param  USARTx USART Instance
  1591.   * @retval None
  1592.   */
  1593. __STATIC_INLINE void LL_USART_ConfigHalfDuplexMode(USART_TypeDef *USARTx)
  1594. {
  1595.   /* In Half Duplex mode, the following bits must be kept cleared:
  1596.   - LINEN and CLKEN bits in the USART_CR2 register,
  1597.   - SCEN and IREN bits in the USART_CR3 register.*/
  1598.   CLEAR_BIT(USARTx->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));
  1599.   CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN | USART_CR3_IREN));
  1600.   /* set the UART/USART in Half Duplex mode */
  1601.   SET_BIT(USARTx->CR3, USART_CR3_HDSEL);
  1602. }
  1603.  
  1604. /**
  1605.   * @brief  Perform basic configuration of USART for enabling use in Smartcard Mode
  1606.   * @note   In Smartcard mode, the following bits must be kept cleared:
  1607.   *           - LINEN bit in the USART_CR2 register,
  1608.   *           - IREN bit in the USART_CR3 register,
  1609.   *           - HDSEL bit in the USART_CR3 register.
  1610.   *         This function also configures Stop bits to 1.5 bits and
  1611.   *         sets the USART in Smartcard mode (SCEN bit).
  1612.   *         Clock Output is also enabled (CLKEN).
  1613.   * @note   Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
  1614.   *         Smartcard feature is supported by the USARTx instance.
  1615.   * @note   Call of this function is equivalent to following function call sequence :
  1616.   *         - Clear LINEN in CR2 using @ref LL_USART_DisableLIN() function
  1617.   *         - Clear IREN in CR3 using @ref LL_USART_DisableIrda() function
  1618.   *         - Clear HDSEL in CR3 using @ref LL_USART_DisableHalfDuplex() function
  1619.   *         - Configure STOP in CR2 using @ref LL_USART_SetStopBitsLength() function
  1620.   *         - Set CLKEN in CR2 using @ref LL_USART_EnableSCLKOutput() function
  1621.   *         - Set SCEN in CR3 using @ref LL_USART_EnableSmartcard() function
  1622.   * @note   Other remaining configurations items related to Smartcard Mode
  1623.   *         (as Baud Rate, Word length, Parity, ...) should be set using
  1624.   *         dedicated functions
  1625.   * @rmtoll CR2          LINEN         LL_USART_ConfigSmartcardMode\n
  1626.   *         CR2          STOP          LL_USART_ConfigSmartcardMode\n
  1627.   *         CR2          CLKEN         LL_USART_ConfigSmartcardMode\n
  1628.   *         CR3          HDSEL         LL_USART_ConfigSmartcardMode\n
  1629.   *         CR3          SCEN          LL_USART_ConfigSmartcardMode
  1630.   * @param  USARTx USART Instance
  1631.   * @retval None
  1632.   */
  1633. __STATIC_INLINE void LL_USART_ConfigSmartcardMode(USART_TypeDef *USARTx)
  1634. {
  1635.   /* In Smartcard mode, the following bits must be kept cleared:
  1636.   - LINEN bit in the USART_CR2 register,
  1637.   - IREN and HDSEL bits in the USART_CR3 register.*/
  1638.   CLEAR_BIT(USARTx->CR2, (USART_CR2_LINEN));
  1639.   CLEAR_BIT(USARTx->CR3, (USART_CR3_IREN | USART_CR3_HDSEL));
  1640.   /* Configure Stop bits to 1.5 bits */
  1641.   /* Synchronous mode is activated by default */
  1642.   SET_BIT(USARTx->CR2, (USART_CR2_STOP_0 | USART_CR2_STOP_1 | USART_CR2_CLKEN));
  1643.   /* set the UART/USART in Smartcard mode */
  1644.   SET_BIT(USARTx->CR3, USART_CR3_SCEN);
  1645. }
  1646.  
  1647. /**
  1648.   * @brief  Perform basic configuration of USART for enabling use in Irda Mode
  1649.   * @note   In IRDA mode, the following bits must be kept cleared:
  1650.   *           - LINEN bit in the USART_CR2 register,
  1651.   *           - STOP and CLKEN bits in the USART_CR2 register,
  1652.   *           - SCEN bit in the USART_CR3 register,
  1653.   *           - HDSEL bit in the USART_CR3 register.
  1654.   *         This function also sets the UART/USART in IRDA mode (IREN bit).
  1655.   * @note   Macro IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
  1656.   *         IrDA feature is supported by the USARTx instance.
  1657.   * @note   Call of this function is equivalent to following function call sequence :
  1658.   *         - Clear LINEN in CR2 using @ref LL_USART_DisableLIN() function
  1659.   *         - Clear CLKEN in CR2 using @ref LL_USART_DisableSCLKOutput() function
  1660.   *         - Clear SCEN in CR3 using @ref LL_USART_DisableSmartcard() function
  1661.   *         - Clear HDSEL in CR3 using @ref LL_USART_DisableHalfDuplex() function
  1662.   *         - Configure STOP in CR2 using @ref LL_USART_SetStopBitsLength() function
  1663.   *         - Set IREN in CR3 using @ref LL_USART_EnableIrda() function
  1664.   * @note   Other remaining configurations items related to Irda Mode
  1665.   *         (as Baud Rate, Word length, Power mode, ...) should be set using
  1666.   *         dedicated functions
  1667.   * @rmtoll CR2          LINEN         LL_USART_ConfigIrdaMode\n
  1668.   *         CR2          CLKEN         LL_USART_ConfigIrdaMode\n
  1669.   *         CR2          STOP          LL_USART_ConfigIrdaMode\n
  1670.   *         CR3          SCEN          LL_USART_ConfigIrdaMode\n
  1671.   *         CR3          HDSEL         LL_USART_ConfigIrdaMode\n
  1672.   *         CR3          IREN          LL_USART_ConfigIrdaMode
  1673.   * @param  USARTx USART Instance
  1674.   * @retval None
  1675.   */
  1676. __STATIC_INLINE void LL_USART_ConfigIrdaMode(USART_TypeDef *USARTx)
  1677. {
  1678.   /* In IRDA mode, the following bits must be kept cleared:
  1679.   - LINEN, STOP and CLKEN bits in the USART_CR2 register,
  1680.   - SCEN and HDSEL bits in the USART_CR3 register.*/
  1681.   CLEAR_BIT(USARTx->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN | USART_CR2_STOP));
  1682.   CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL));
  1683.   /* set the UART/USART in IRDA mode */
  1684.   SET_BIT(USARTx->CR3, USART_CR3_IREN);
  1685. }
  1686.  
  1687. /**
  1688.   * @brief  Perform basic configuration of USART for enabling use in Multi processor Mode
  1689.   *         (several USARTs connected in a network, one of the USARTs can be the master,
  1690.   *         its TX output connected to the RX inputs of the other slaves USARTs).
  1691.   * @note   In MultiProcessor mode, the following bits must be kept cleared:
  1692.   *           - LINEN bit in the USART_CR2 register,
  1693.   *           - CLKEN bit in the USART_CR2 register,
  1694.   *           - SCEN bit in the USART_CR3 register,
  1695.   *           - IREN bit in the USART_CR3 register,
  1696.   *           - HDSEL bit in the USART_CR3 register.
  1697.   * @note   Call of this function is equivalent to following function call sequence :
  1698.   *         - Clear LINEN in CR2 using @ref LL_USART_DisableLIN() function
  1699.   *         - Clear CLKEN in CR2 using @ref LL_USART_DisableSCLKOutput() function
  1700.   *         - Clear SCEN in CR3 using @ref LL_USART_DisableSmartcard() function
  1701.   *         - Clear IREN in CR3 using @ref LL_USART_DisableIrda() function
  1702.   *         - Clear HDSEL in CR3 using @ref LL_USART_DisableHalfDuplex() function
  1703.   * @note   Other remaining configurations items related to Multi processor Mode
  1704.   *         (as Baud Rate, Wake Up Method, Node address, ...) should be set using
  1705.   *         dedicated functions
  1706.   * @rmtoll CR2          LINEN         LL_USART_ConfigMultiProcessMode\n
  1707.   *         CR2          CLKEN         LL_USART_ConfigMultiProcessMode\n
  1708.   *         CR3          SCEN          LL_USART_ConfigMultiProcessMode\n
  1709.   *         CR3          HDSEL         LL_USART_ConfigMultiProcessMode\n
  1710.   *         CR3          IREN          LL_USART_ConfigMultiProcessMode
  1711.   * @param  USARTx USART Instance
  1712.   * @retval None
  1713.   */
  1714. __STATIC_INLINE void LL_USART_ConfigMultiProcessMode(USART_TypeDef *USARTx)
  1715. {
  1716.   /* In Multi Processor mode, the following bits must be kept cleared:
  1717.   - LINEN and CLKEN bits in the USART_CR2 register,
  1718.   - IREN, SCEN and HDSEL bits in the USART_CR3 register.*/
  1719.   CLEAR_BIT(USARTx->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));
  1720.   CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN));
  1721. }
  1722.  
  1723. /**
  1724.   * @}
  1725.   */
  1726.  
  1727. /** @defgroup USART_LL_EF_FLAG_Management FLAG_Management
  1728.   * @{
  1729.   */
  1730.  
  1731. /**
  1732.   * @brief  Check if the USART Parity Error Flag is set or not
  1733.   * @rmtoll SR           PE            LL_USART_IsActiveFlag_PE
  1734.   * @param  USARTx USART Instance
  1735.   * @retval State of bit (1 or 0).
  1736.   */
  1737. __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_PE(const USART_TypeDef *USARTx)
  1738. {
  1739.   return (READ_BIT(USARTx->SR, USART_SR_PE) == (USART_SR_PE));
  1740. }
  1741.  
  1742. /**
  1743.   * @brief  Check if the USART Framing Error Flag is set or not
  1744.   * @rmtoll SR           FE            LL_USART_IsActiveFlag_FE
  1745.   * @param  USARTx USART Instance
  1746.   * @retval State of bit (1 or 0).
  1747.   */
  1748. __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_FE(const USART_TypeDef *USARTx)
  1749. {
  1750.   return (READ_BIT(USARTx->SR, USART_SR_FE) == (USART_SR_FE));
  1751. }
  1752.  
  1753. /**
  1754.   * @brief  Check if the USART Noise error detected Flag is set or not
  1755.   * @rmtoll SR           NF            LL_USART_IsActiveFlag_NE
  1756.   * @param  USARTx USART Instance
  1757.   * @retval State of bit (1 or 0).
  1758.   */
  1759. __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_NE(const USART_TypeDef *USARTx)
  1760. {
  1761.   return (READ_BIT(USARTx->SR, USART_SR_NE) == (USART_SR_NE));
  1762. }
  1763.  
  1764. /**
  1765.   * @brief  Check if the USART OverRun Error Flag is set or not
  1766.   * @rmtoll SR           ORE           LL_USART_IsActiveFlag_ORE
  1767.   * @param  USARTx USART Instance
  1768.   * @retval State of bit (1 or 0).
  1769.   */
  1770. __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_ORE(const USART_TypeDef *USARTx)
  1771. {
  1772.   return (READ_BIT(USARTx->SR, USART_SR_ORE) == (USART_SR_ORE));
  1773. }
  1774.  
  1775. /**
  1776.   * @brief  Check if the USART IDLE line detected Flag is set or not
  1777.   * @rmtoll SR           IDLE          LL_USART_IsActiveFlag_IDLE
  1778.   * @param  USARTx USART Instance
  1779.   * @retval State of bit (1 or 0).
  1780.   */
  1781. __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_IDLE(const USART_TypeDef *USARTx)
  1782. {
  1783.   return (READ_BIT(USARTx->SR, USART_SR_IDLE) == (USART_SR_IDLE));
  1784. }
  1785.  
  1786. /**
  1787.   * @brief  Check if the USART Read Data Register Not Empty Flag is set or not
  1788.   * @rmtoll SR           RXNE          LL_USART_IsActiveFlag_RXNE
  1789.   * @param  USARTx USART Instance
  1790.   * @retval State of bit (1 or 0).
  1791.   */
  1792. __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_RXNE(const USART_TypeDef *USARTx)
  1793. {
  1794.   return (READ_BIT(USARTx->SR, USART_SR_RXNE) == (USART_SR_RXNE));
  1795. }
  1796.  
  1797. /**
  1798.   * @brief  Check if the USART Transmission Complete Flag is set or not
  1799.   * @rmtoll SR           TC            LL_USART_IsActiveFlag_TC
  1800.   * @param  USARTx USART Instance
  1801.   * @retval State of bit (1 or 0).
  1802.   */
  1803. __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_TC(const USART_TypeDef *USARTx)
  1804. {
  1805.   return (READ_BIT(USARTx->SR, USART_SR_TC) == (USART_SR_TC));
  1806. }
  1807.  
  1808. /**
  1809.   * @brief  Check if the USART Transmit Data Register Empty Flag is set or not
  1810.   * @rmtoll SR           TXE           LL_USART_IsActiveFlag_TXE
  1811.   * @param  USARTx USART Instance
  1812.   * @retval State of bit (1 or 0).
  1813.   */
  1814. __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_TXE(const USART_TypeDef *USARTx)
  1815. {
  1816.   return (READ_BIT(USARTx->SR, USART_SR_TXE) == (USART_SR_TXE));
  1817. }
  1818.  
  1819. /**
  1820.   * @brief  Check if the USART LIN Break Detection Flag is set or not
  1821.   * @note   Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
  1822.   *         LIN feature is supported by the USARTx instance.
  1823.   * @rmtoll SR           LBD           LL_USART_IsActiveFlag_LBD
  1824.   * @param  USARTx USART Instance
  1825.   * @retval State of bit (1 or 0).
  1826.   */
  1827. __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_LBD(const USART_TypeDef *USARTx)
  1828. {
  1829.   return (READ_BIT(USARTx->SR, USART_SR_LBD) == (USART_SR_LBD));
  1830. }
  1831.  
  1832. /**
  1833.   * @brief  Check if the USART CTS Flag is set or not
  1834.   * @note   Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
  1835.   *         Hardware Flow control feature is supported by the USARTx instance.
  1836.   * @rmtoll SR           CTS           LL_USART_IsActiveFlag_nCTS
  1837.   * @param  USARTx USART Instance
  1838.   * @retval State of bit (1 or 0).
  1839.   */
  1840. __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_nCTS(const USART_TypeDef *USARTx)
  1841. {
  1842.   return (READ_BIT(USARTx->SR, USART_SR_CTS) == (USART_SR_CTS));
  1843. }
  1844.  
  1845. /**
  1846.   * @brief  Check if the USART Send Break Flag is set or not
  1847.   * @rmtoll CR1          SBK           LL_USART_IsActiveFlag_SBK
  1848.   * @param  USARTx USART Instance
  1849.   * @retval State of bit (1 or 0).
  1850.   */
  1851. __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_SBK(const USART_TypeDef *USARTx)
  1852. {
  1853.   return (READ_BIT(USARTx->CR1, USART_CR1_SBK) == (USART_CR1_SBK));
  1854. }
  1855.  
  1856. /**
  1857.   * @brief  Check if the USART Receive Wake Up from mute mode Flag is set or not
  1858.   * @rmtoll CR1          RWU           LL_USART_IsActiveFlag_RWU
  1859.   * @param  USARTx USART Instance
  1860.   * @retval State of bit (1 or 0).
  1861.   */
  1862. __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_RWU(const USART_TypeDef *USARTx)
  1863. {
  1864.   return (READ_BIT(USARTx->CR1, USART_CR1_RWU) == (USART_CR1_RWU));
  1865. }
  1866.  
  1867. /**
  1868.   * @brief  Clear Parity Error Flag
  1869.   * @note   Clearing this flag is done by a read access to the USARTx_SR
  1870.   *         register followed by a read access to the USARTx_DR register.
  1871.   * @note   Please also consider that when clearing this flag, other flags as
  1872.   *         NE, FE, ORE, IDLE would also be cleared.
  1873.   * @rmtoll SR           PE            LL_USART_ClearFlag_PE
  1874.   * @param  USARTx USART Instance
  1875.   * @retval None
  1876.   */
  1877. __STATIC_INLINE void LL_USART_ClearFlag_PE(USART_TypeDef *USARTx)
  1878. {
  1879.   __IO uint32_t tmpreg;
  1880.   tmpreg = USARTx->SR;
  1881.   (void) tmpreg;
  1882.   tmpreg = USARTx->DR;
  1883.   (void) tmpreg;
  1884. }
  1885.  
  1886. /**
  1887.   * @brief  Clear Framing Error Flag
  1888.   * @note   Clearing this flag is done by a read access to the USARTx_SR
  1889.   *         register followed by a read access to the USARTx_DR register.
  1890.   * @note   Please also consider that when clearing this flag, other flags as
  1891.   *         PE, NE, ORE, IDLE would also be cleared.
  1892.   * @rmtoll SR           FE            LL_USART_ClearFlag_FE
  1893.   * @param  USARTx USART Instance
  1894.   * @retval None
  1895.   */
  1896. __STATIC_INLINE void LL_USART_ClearFlag_FE(USART_TypeDef *USARTx)
  1897. {
  1898.   __IO uint32_t tmpreg;
  1899.   tmpreg = USARTx->SR;
  1900.   (void) tmpreg;
  1901.   tmpreg = USARTx->DR;
  1902.   (void) tmpreg;
  1903. }
  1904.  
  1905. /**
  1906.   * @brief  Clear Noise detected Flag
  1907.   * @note   Clearing this flag is done by a read access to the USARTx_SR
  1908.   *         register followed by a read access to the USARTx_DR register.
  1909.   * @note   Please also consider that when clearing this flag, other flags as
  1910.   *         PE, FE, ORE, IDLE would also be cleared.
  1911.   * @rmtoll SR           NF            LL_USART_ClearFlag_NE
  1912.   * @param  USARTx USART Instance
  1913.   * @retval None
  1914.   */
  1915. __STATIC_INLINE void LL_USART_ClearFlag_NE(USART_TypeDef *USARTx)
  1916. {
  1917.   __IO uint32_t tmpreg;
  1918.   tmpreg = USARTx->SR;
  1919.   (void) tmpreg;
  1920.   tmpreg = USARTx->DR;
  1921.   (void) tmpreg;
  1922. }
  1923.  
  1924. /**
  1925.   * @brief  Clear OverRun Error Flag
  1926.   * @note   Clearing this flag is done by a read access to the USARTx_SR
  1927.   *         register followed by a read access to the USARTx_DR register.
  1928.   * @note   Please also consider that when clearing this flag, other flags as
  1929.   *         PE, NE, FE, IDLE would also be cleared.
  1930.   * @rmtoll SR           ORE           LL_USART_ClearFlag_ORE
  1931.   * @param  USARTx USART Instance
  1932.   * @retval None
  1933.   */
  1934. __STATIC_INLINE void LL_USART_ClearFlag_ORE(USART_TypeDef *USARTx)
  1935. {
  1936.   __IO uint32_t tmpreg;
  1937.   tmpreg = USARTx->SR;
  1938.   (void) tmpreg;
  1939.   tmpreg = USARTx->DR;
  1940.   (void) tmpreg;
  1941. }
  1942.  
  1943. /**
  1944.   * @brief  Clear IDLE line detected Flag
  1945.   * @note   Clearing this flag is done by a read access to the USARTx_SR
  1946.   *         register followed by a read access to the USARTx_DR register.
  1947.   * @note   Please also consider that when clearing this flag, other flags as
  1948.   *         PE, NE, FE, ORE would also be cleared.
  1949.   * @rmtoll SR           IDLE          LL_USART_ClearFlag_IDLE
  1950.   * @param  USARTx USART Instance
  1951.   * @retval None
  1952.   */
  1953. __STATIC_INLINE void LL_USART_ClearFlag_IDLE(USART_TypeDef *USARTx)
  1954. {
  1955.   __IO uint32_t tmpreg;
  1956.   tmpreg = USARTx->SR;
  1957.   (void) tmpreg;
  1958.   tmpreg = USARTx->DR;
  1959.   (void) tmpreg;
  1960. }
  1961.  
  1962. /**
  1963.   * @brief  Clear Transmission Complete Flag
  1964.   * @rmtoll SR           TC            LL_USART_ClearFlag_TC
  1965.   * @param  USARTx USART Instance
  1966.   * @retval None
  1967.   */
  1968. __STATIC_INLINE void LL_USART_ClearFlag_TC(USART_TypeDef *USARTx)
  1969. {
  1970.   WRITE_REG(USARTx->SR, ~(USART_SR_TC));
  1971. }
  1972.  
  1973. /**
  1974.   * @brief  Clear RX Not Empty Flag
  1975.   * @rmtoll SR           RXNE          LL_USART_ClearFlag_RXNE
  1976.   * @param  USARTx USART Instance
  1977.   * @retval None
  1978.   */
  1979. __STATIC_INLINE void LL_USART_ClearFlag_RXNE(USART_TypeDef *USARTx)
  1980. {
  1981.   WRITE_REG(USARTx->SR, ~(USART_SR_RXNE));
  1982. }
  1983.  
  1984. /**
  1985.   * @brief  Clear LIN Break Detection Flag
  1986.   * @note   Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
  1987.   *         LIN feature is supported by the USARTx instance.
  1988.   * @rmtoll SR           LBD           LL_USART_ClearFlag_LBD
  1989.   * @param  USARTx USART Instance
  1990.   * @retval None
  1991.   */
  1992. __STATIC_INLINE void LL_USART_ClearFlag_LBD(USART_TypeDef *USARTx)
  1993. {
  1994.   WRITE_REG(USARTx->SR, ~(USART_SR_LBD));
  1995. }
  1996.  
  1997. /**
  1998.   * @brief  Clear CTS Interrupt Flag
  1999.   * @note   Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
  2000.   *         Hardware Flow control feature is supported by the USARTx instance.
  2001.   * @rmtoll SR           CTS           LL_USART_ClearFlag_nCTS
  2002.   * @param  USARTx USART Instance
  2003.   * @retval None
  2004.   */
  2005. __STATIC_INLINE void LL_USART_ClearFlag_nCTS(USART_TypeDef *USARTx)
  2006. {
  2007.   WRITE_REG(USARTx->SR, ~(USART_SR_CTS));
  2008. }
  2009.  
  2010. /**
  2011.   * @}
  2012.   */
  2013.  
  2014. /** @defgroup USART_LL_EF_IT_Management IT_Management
  2015.   * @{
  2016.   */
  2017.  
  2018. /**
  2019.   * @brief  Enable IDLE Interrupt
  2020.   * @rmtoll CR1          IDLEIE        LL_USART_EnableIT_IDLE
  2021.   * @param  USARTx USART Instance
  2022.   * @retval None
  2023.   */
  2024. __STATIC_INLINE void LL_USART_EnableIT_IDLE(USART_TypeDef *USARTx)
  2025. {
  2026.   ATOMIC_SET_BIT(USARTx->CR1, USART_CR1_IDLEIE);
  2027. }
  2028.  
  2029. /**
  2030.   * @brief  Enable RX Not Empty Interrupt
  2031.   * @rmtoll CR1          RXNEIE        LL_USART_EnableIT_RXNE
  2032.   * @param  USARTx USART Instance
  2033.   * @retval None
  2034.   */
  2035. __STATIC_INLINE void LL_USART_EnableIT_RXNE(USART_TypeDef *USARTx)
  2036. {
  2037.   ATOMIC_SET_BIT(USARTx->CR1, USART_CR1_RXNEIE);
  2038. }
  2039.  
  2040. /**
  2041.   * @brief  Enable Transmission Complete Interrupt
  2042.   * @rmtoll CR1          TCIE          LL_USART_EnableIT_TC
  2043.   * @param  USARTx USART Instance
  2044.   * @retval None
  2045.   */
  2046. __STATIC_INLINE void LL_USART_EnableIT_TC(USART_TypeDef *USARTx)
  2047. {
  2048.   ATOMIC_SET_BIT(USARTx->CR1, USART_CR1_TCIE);
  2049. }
  2050.  
  2051. /**
  2052.   * @brief  Enable TX Empty Interrupt
  2053.   * @rmtoll CR1          TXEIE         LL_USART_EnableIT_TXE
  2054.   * @param  USARTx USART Instance
  2055.   * @retval None
  2056.   */
  2057. __STATIC_INLINE void LL_USART_EnableIT_TXE(USART_TypeDef *USARTx)
  2058. {
  2059.   ATOMIC_SET_BIT(USARTx->CR1, USART_CR1_TXEIE);
  2060. }
  2061.  
  2062. /**
  2063.   * @brief  Enable Parity Error Interrupt
  2064.   * @rmtoll CR1          PEIE          LL_USART_EnableIT_PE
  2065.   * @param  USARTx USART Instance
  2066.   * @retval None
  2067.   */
  2068. __STATIC_INLINE void LL_USART_EnableIT_PE(USART_TypeDef *USARTx)
  2069. {
  2070.   ATOMIC_SET_BIT(USARTx->CR1, USART_CR1_PEIE);
  2071. }
  2072.  
  2073. /**
  2074.   * @brief  Enable LIN Break Detection Interrupt
  2075.   * @note   Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
  2076.   *         LIN feature is supported by the USARTx instance.
  2077.   * @rmtoll CR2          LBDIE         LL_USART_EnableIT_LBD
  2078.   * @param  USARTx USART Instance
  2079.   * @retval None
  2080.   */
  2081. __STATIC_INLINE void LL_USART_EnableIT_LBD(USART_TypeDef *USARTx)
  2082. {
  2083.   SET_BIT(USARTx->CR2, USART_CR2_LBDIE);
  2084. }
  2085.  
  2086. /**
  2087.   * @brief  Enable Error Interrupt
  2088.   * @note   When set, Error Interrupt Enable Bit is enabling interrupt generation in case of a framing
  2089.   *         error, overrun error or noise flag (FE=1 or ORE=1 or NF=1 in the USARTx_SR register).
  2090.   *           0: Interrupt is inhibited
  2091.   *           1: An interrupt is generated when FE=1 or ORE=1 or NF=1 in the USARTx_SR register.
  2092.   * @rmtoll CR3          EIE           LL_USART_EnableIT_ERROR
  2093.   * @param  USARTx USART Instance
  2094.   * @retval None
  2095.   */
  2096. __STATIC_INLINE void LL_USART_EnableIT_ERROR(USART_TypeDef *USARTx)
  2097. {
  2098.   ATOMIC_SET_BIT(USARTx->CR3, USART_CR3_EIE);
  2099. }
  2100.  
  2101. /**
  2102.   * @brief  Enable CTS Interrupt
  2103.   * @note   Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
  2104.   *         Hardware Flow control feature is supported by the USARTx instance.
  2105.   * @rmtoll CR3          CTSIE         LL_USART_EnableIT_CTS
  2106.   * @param  USARTx USART Instance
  2107.   * @retval None
  2108.   */
  2109. __STATIC_INLINE void LL_USART_EnableIT_CTS(USART_TypeDef *USARTx)
  2110. {
  2111.   ATOMIC_SET_BIT(USARTx->CR3, USART_CR3_CTSIE);
  2112. }
  2113.  
  2114. /**
  2115.   * @brief  Disable IDLE Interrupt
  2116.   * @rmtoll CR1          IDLEIE        LL_USART_DisableIT_IDLE
  2117.   * @param  USARTx USART Instance
  2118.   * @retval None
  2119.   */
  2120. __STATIC_INLINE void LL_USART_DisableIT_IDLE(USART_TypeDef *USARTx)
  2121. {
  2122.   ATOMIC_CLEAR_BIT(USARTx->CR1, USART_CR1_IDLEIE);
  2123. }
  2124.  
  2125. /**
  2126.   * @brief  Disable RX Not Empty Interrupt
  2127.   * @rmtoll CR1          RXNEIE        LL_USART_DisableIT_RXNE
  2128.   * @param  USARTx USART Instance
  2129.   * @retval None
  2130.   */
  2131. __STATIC_INLINE void LL_USART_DisableIT_RXNE(USART_TypeDef *USARTx)
  2132. {
  2133.   ATOMIC_CLEAR_BIT(USARTx->CR1, USART_CR1_RXNEIE);
  2134. }
  2135.  
  2136. /**
  2137.   * @brief  Disable Transmission Complete Interrupt
  2138.   * @rmtoll CR1          TCIE          LL_USART_DisableIT_TC
  2139.   * @param  USARTx USART Instance
  2140.   * @retval None
  2141.   */
  2142. __STATIC_INLINE void LL_USART_DisableIT_TC(USART_TypeDef *USARTx)
  2143. {
  2144.   ATOMIC_CLEAR_BIT(USARTx->CR1, USART_CR1_TCIE);
  2145. }
  2146.  
  2147. /**
  2148.   * @brief  Disable TX Empty Interrupt
  2149.   * @rmtoll CR1          TXEIE         LL_USART_DisableIT_TXE
  2150.   * @param  USARTx USART Instance
  2151.   * @retval None
  2152.   */
  2153. __STATIC_INLINE void LL_USART_DisableIT_TXE(USART_TypeDef *USARTx)
  2154. {
  2155.   ATOMIC_CLEAR_BIT(USARTx->CR1, USART_CR1_TXEIE);
  2156. }
  2157.  
  2158. /**
  2159.   * @brief  Disable Parity Error Interrupt
  2160.   * @rmtoll CR1          PEIE          LL_USART_DisableIT_PE
  2161.   * @param  USARTx USART Instance
  2162.   * @retval None
  2163.   */
  2164. __STATIC_INLINE void LL_USART_DisableIT_PE(USART_TypeDef *USARTx)
  2165. {
  2166.   ATOMIC_CLEAR_BIT(USARTx->CR1, USART_CR1_PEIE);
  2167. }
  2168.  
  2169. /**
  2170.   * @brief  Disable LIN Break Detection Interrupt
  2171.   * @note   Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
  2172.   *         LIN feature is supported by the USARTx instance.
  2173.   * @rmtoll CR2          LBDIE         LL_USART_DisableIT_LBD
  2174.   * @param  USARTx USART Instance
  2175.   * @retval None
  2176.   */
  2177. __STATIC_INLINE void LL_USART_DisableIT_LBD(USART_TypeDef *USARTx)
  2178. {
  2179.   CLEAR_BIT(USARTx->CR2, USART_CR2_LBDIE);
  2180. }
  2181.  
  2182. /**
  2183.   * @brief  Disable Error Interrupt
  2184.   * @note   When set, Error Interrupt Enable Bit is enabling interrupt generation in case of a framing
  2185.   *         error, overrun error or noise flag (FE=1 or ORE=1 or NF=1 in the USARTx_SR register).
  2186.   *           0: Interrupt is inhibited
  2187.   *           1: An interrupt is generated when FE=1 or ORE=1 or NF=1 in the USARTx_SR register.
  2188.   * @rmtoll CR3          EIE           LL_USART_DisableIT_ERROR
  2189.   * @param  USARTx USART Instance
  2190.   * @retval None
  2191.   */
  2192. __STATIC_INLINE void LL_USART_DisableIT_ERROR(USART_TypeDef *USARTx)
  2193. {
  2194.   ATOMIC_CLEAR_BIT(USARTx->CR3, USART_CR3_EIE);
  2195. }
  2196.  
  2197. /**
  2198.   * @brief  Disable CTS Interrupt
  2199.   * @note   Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
  2200.   *         Hardware Flow control feature is supported by the USARTx instance.
  2201.   * @rmtoll CR3          CTSIE         LL_USART_DisableIT_CTS
  2202.   * @param  USARTx USART Instance
  2203.   * @retval None
  2204.   */
  2205. __STATIC_INLINE void LL_USART_DisableIT_CTS(USART_TypeDef *USARTx)
  2206. {
  2207.   ATOMIC_CLEAR_BIT(USARTx->CR3, USART_CR3_CTSIE);
  2208. }
  2209.  
  2210. /**
  2211.   * @brief  Check if the USART IDLE Interrupt  source is enabled or disabled.
  2212.   * @rmtoll CR1          IDLEIE        LL_USART_IsEnabledIT_IDLE
  2213.   * @param  USARTx USART Instance
  2214.   * @retval State of bit (1 or 0).
  2215.   */
  2216. __STATIC_INLINE uint32_t LL_USART_IsEnabledIT_IDLE(const USART_TypeDef *USARTx)
  2217. {
  2218.   return (READ_BIT(USARTx->CR1, USART_CR1_IDLEIE) == (USART_CR1_IDLEIE));
  2219. }
  2220.  
  2221. /**
  2222.   * @brief  Check if the USART RX Not Empty Interrupt is enabled or disabled.
  2223.   * @rmtoll CR1          RXNEIE        LL_USART_IsEnabledIT_RXNE
  2224.   * @param  USARTx USART Instance
  2225.   * @retval State of bit (1 or 0).
  2226.   */
  2227. __STATIC_INLINE uint32_t LL_USART_IsEnabledIT_RXNE(const USART_TypeDef *USARTx)
  2228. {
  2229.   return (READ_BIT(USARTx->CR1, USART_CR1_RXNEIE) == (USART_CR1_RXNEIE));
  2230. }
  2231.  
  2232. /**
  2233.   * @brief  Check if the USART Transmission Complete Interrupt is enabled or disabled.
  2234.   * @rmtoll CR1          TCIE          LL_USART_IsEnabledIT_TC
  2235.   * @param  USARTx USART Instance
  2236.   * @retval State of bit (1 or 0).
  2237.   */
  2238. __STATIC_INLINE uint32_t LL_USART_IsEnabledIT_TC(const USART_TypeDef *USARTx)
  2239. {
  2240.   return (READ_BIT(USARTx->CR1, USART_CR1_TCIE) == (USART_CR1_TCIE));
  2241. }
  2242.  
  2243. /**
  2244.   * @brief  Check if the USART TX Empty Interrupt is enabled or disabled.
  2245.   * @rmtoll CR1          TXEIE         LL_USART_IsEnabledIT_TXE
  2246.   * @param  USARTx USART Instance
  2247.   * @retval State of bit (1 or 0).
  2248.   */
  2249. __STATIC_INLINE uint32_t LL_USART_IsEnabledIT_TXE(const USART_TypeDef *USARTx)
  2250. {
  2251.   return (READ_BIT(USARTx->CR1, USART_CR1_TXEIE) == (USART_CR1_TXEIE));
  2252. }
  2253.  
  2254. /**
  2255.   * @brief  Check if the USART Parity Error Interrupt is enabled or disabled.
  2256.   * @rmtoll CR1          PEIE          LL_USART_IsEnabledIT_PE
  2257.   * @param  USARTx USART Instance
  2258.   * @retval State of bit (1 or 0).
  2259.   */
  2260. __STATIC_INLINE uint32_t LL_USART_IsEnabledIT_PE(const USART_TypeDef *USARTx)
  2261. {
  2262.   return (READ_BIT(USARTx->CR1, USART_CR1_PEIE) == (USART_CR1_PEIE));
  2263. }
  2264.  
  2265. /**
  2266.   * @brief  Check if the USART LIN Break Detection Interrupt is enabled or disabled.
  2267.   * @note   Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
  2268.   *         LIN feature is supported by the USARTx instance.
  2269.   * @rmtoll CR2          LBDIE         LL_USART_IsEnabledIT_LBD
  2270.   * @param  USARTx USART Instance
  2271.   * @retval State of bit (1 or 0).
  2272.   */
  2273. __STATIC_INLINE uint32_t LL_USART_IsEnabledIT_LBD(const USART_TypeDef *USARTx)
  2274. {
  2275.   return (READ_BIT(USARTx->CR2, USART_CR2_LBDIE) == (USART_CR2_LBDIE));
  2276. }
  2277.  
  2278. /**
  2279.   * @brief  Check if the USART Error Interrupt is enabled or disabled.
  2280.   * @rmtoll CR3          EIE           LL_USART_IsEnabledIT_ERROR
  2281.   * @param  USARTx USART Instance
  2282.   * @retval State of bit (1 or 0).
  2283.   */
  2284. __STATIC_INLINE uint32_t LL_USART_IsEnabledIT_ERROR(const USART_TypeDef *USARTx)
  2285. {
  2286.   return (READ_BIT(USARTx->CR3, USART_CR3_EIE) == (USART_CR3_EIE));
  2287. }
  2288.  
  2289. /**
  2290.   * @brief  Check if the USART CTS Interrupt is enabled or disabled.
  2291.   * @note   Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
  2292.   *         Hardware Flow control feature is supported by the USARTx instance.
  2293.   * @rmtoll CR3          CTSIE         LL_USART_IsEnabledIT_CTS
  2294.   * @param  USARTx USART Instance
  2295.   * @retval State of bit (1 or 0).
  2296.   */
  2297. __STATIC_INLINE uint32_t LL_USART_IsEnabledIT_CTS(const USART_TypeDef *USARTx)
  2298. {
  2299.   return (READ_BIT(USARTx->CR3, USART_CR3_CTSIE) == (USART_CR3_CTSIE));
  2300. }
  2301.  
  2302. /**
  2303.   * @}
  2304.   */
  2305.  
  2306. /** @defgroup USART_LL_EF_DMA_Management DMA_Management
  2307.   * @{
  2308.   */
  2309.  
  2310. /**
  2311.   * @brief  Enable DMA Mode for reception
  2312.   * @rmtoll CR3          DMAR          LL_USART_EnableDMAReq_RX
  2313.   * @param  USARTx USART Instance
  2314.   * @retval None
  2315.   */
  2316. __STATIC_INLINE void LL_USART_EnableDMAReq_RX(USART_TypeDef *USARTx)
  2317. {
  2318.   ATOMIC_SET_BIT(USARTx->CR3, USART_CR3_DMAR);
  2319. }
  2320.  
  2321. /**
  2322.   * @brief  Disable DMA Mode for reception
  2323.   * @rmtoll CR3          DMAR          LL_USART_DisableDMAReq_RX
  2324.   * @param  USARTx USART Instance
  2325.   * @retval None
  2326.   */
  2327. __STATIC_INLINE void LL_USART_DisableDMAReq_RX(USART_TypeDef *USARTx)
  2328. {
  2329.   ATOMIC_CLEAR_BIT(USARTx->CR3, USART_CR3_DMAR);
  2330. }
  2331.  
  2332. /**
  2333.   * @brief  Check if DMA Mode is enabled for reception
  2334.   * @rmtoll CR3          DMAR          LL_USART_IsEnabledDMAReq_RX
  2335.   * @param  USARTx USART Instance
  2336.   * @retval State of bit (1 or 0).
  2337.   */
  2338. __STATIC_INLINE uint32_t LL_USART_IsEnabledDMAReq_RX(const USART_TypeDef *USARTx)
  2339. {
  2340.   return (READ_BIT(USARTx->CR3, USART_CR3_DMAR) == (USART_CR3_DMAR));
  2341. }
  2342.  
  2343. /**
  2344.   * @brief  Enable DMA Mode for transmission
  2345.   * @rmtoll CR3          DMAT          LL_USART_EnableDMAReq_TX
  2346.   * @param  USARTx USART Instance
  2347.   * @retval None
  2348.   */
  2349. __STATIC_INLINE void LL_USART_EnableDMAReq_TX(USART_TypeDef *USARTx)
  2350. {
  2351.   ATOMIC_SET_BIT(USARTx->CR3, USART_CR3_DMAT);
  2352. }
  2353.  
  2354. /**
  2355.   * @brief  Disable DMA Mode for transmission
  2356.   * @rmtoll CR3          DMAT          LL_USART_DisableDMAReq_TX
  2357.   * @param  USARTx USART Instance
  2358.   * @retval None
  2359.   */
  2360. __STATIC_INLINE void LL_USART_DisableDMAReq_TX(USART_TypeDef *USARTx)
  2361. {
  2362.   ATOMIC_CLEAR_BIT(USARTx->CR3, USART_CR3_DMAT);
  2363. }
  2364.  
  2365. /**
  2366.   * @brief  Check if DMA Mode is enabled for transmission
  2367.   * @rmtoll CR3          DMAT          LL_USART_IsEnabledDMAReq_TX
  2368.   * @param  USARTx USART Instance
  2369.   * @retval State of bit (1 or 0).
  2370.   */
  2371. __STATIC_INLINE uint32_t LL_USART_IsEnabledDMAReq_TX(const USART_TypeDef *USARTx)
  2372. {
  2373.   return (READ_BIT(USARTx->CR3, USART_CR3_DMAT) == (USART_CR3_DMAT));
  2374. }
  2375.  
  2376. /**
  2377.   * @brief  Get the data register address used for DMA transfer
  2378.   * @rmtoll DR           DR            LL_USART_DMA_GetRegAddr
  2379.   * @note   Address of Data Register is valid for both Transmit and Receive transfers.
  2380.   * @param  USARTx USART Instance
  2381.   * @retval Address of data register
  2382.   */
  2383. __STATIC_INLINE uint32_t LL_USART_DMA_GetRegAddr(const USART_TypeDef *USARTx)
  2384. {
  2385.   /* return address of DR register */
  2386.   return ((uint32_t) &(USARTx->DR));
  2387. }
  2388.  
  2389. /**
  2390.   * @}
  2391.   */
  2392.  
  2393. /** @defgroup USART_LL_EF_Data_Management Data_Management
  2394.   * @{
  2395.   */
  2396.  
  2397. /**
  2398.   * @brief  Read Receiver Data register (Receive Data value, 8 bits)
  2399.   * @rmtoll DR           DR            LL_USART_ReceiveData8
  2400.   * @param  USARTx USART Instance
  2401.   * @retval Value between Min_Data=0x00 and Max_Data=0xFF
  2402.   */
  2403. __STATIC_INLINE uint8_t LL_USART_ReceiveData8(const USART_TypeDef *USARTx)
  2404. {
  2405.   return (uint8_t)(READ_BIT(USARTx->DR, USART_DR_DR));
  2406. }
  2407.  
  2408. /**
  2409.   * @brief  Read Receiver Data register (Receive Data value, 9 bits)
  2410.   * @rmtoll DR           DR            LL_USART_ReceiveData9
  2411.   * @param  USARTx USART Instance
  2412.   * @retval Value between Min_Data=0x00 and Max_Data=0x1FF
  2413.   */
  2414. __STATIC_INLINE uint16_t LL_USART_ReceiveData9(const USART_TypeDef *USARTx)
  2415. {
  2416.   return (uint16_t)(READ_BIT(USARTx->DR, USART_DR_DR));
  2417. }
  2418.  
  2419. /**
  2420.   * @brief  Write in Transmitter Data Register (Transmit Data value, 8 bits)
  2421.   * @rmtoll DR           DR            LL_USART_TransmitData8
  2422.   * @param  USARTx USART Instance
  2423.   * @param  Value between Min_Data=0x00 and Max_Data=0xFF
  2424.   * @retval None
  2425.   */
  2426. __STATIC_INLINE void LL_USART_TransmitData8(USART_TypeDef *USARTx, uint8_t Value)
  2427. {
  2428.   USARTx->DR = Value;
  2429. }
  2430.  
  2431. /**
  2432.   * @brief  Write in Transmitter Data Register (Transmit Data value, 9 bits)
  2433.   * @rmtoll DR           DR            LL_USART_TransmitData9
  2434.   * @param  USARTx USART Instance
  2435.   * @param  Value between Min_Data=0x00 and Max_Data=0x1FF
  2436.   * @retval None
  2437.   */
  2438. __STATIC_INLINE void LL_USART_TransmitData9(USART_TypeDef *USARTx, uint16_t Value)
  2439. {
  2440.   USARTx->DR = Value & 0x1FFU;
  2441. }
  2442.  
  2443. /**
  2444.   * @}
  2445.   */
  2446.  
  2447. /** @defgroup USART_LL_EF_Execution Execution
  2448.   * @{
  2449.   */
  2450.  
  2451. /**
  2452.   * @brief  Request Break sending
  2453.   * @rmtoll CR1          SBK           LL_USART_RequestBreakSending
  2454.   * @param  USARTx USART Instance
  2455.   * @retval None
  2456.   */
  2457. __STATIC_INLINE void LL_USART_RequestBreakSending(USART_TypeDef *USARTx)
  2458. {
  2459.   SET_BIT(USARTx->CR1, USART_CR1_SBK);
  2460. }
  2461.  
  2462. /**
  2463.   * @brief  Put USART in Mute mode
  2464.   * @rmtoll CR1          RWU           LL_USART_RequestEnterMuteMode
  2465.   * @param  USARTx USART Instance
  2466.   * @retval None
  2467.   */
  2468. __STATIC_INLINE void LL_USART_RequestEnterMuteMode(USART_TypeDef *USARTx)
  2469. {
  2470.   SET_BIT(USARTx->CR1, USART_CR1_RWU);
  2471. }
  2472.  
  2473. /**
  2474.   * @brief  Put USART in Active mode
  2475.   * @rmtoll CR1          RWU           LL_USART_RequestExitMuteMode
  2476.   * @param  USARTx USART Instance
  2477.   * @retval None
  2478.   */
  2479. __STATIC_INLINE void LL_USART_RequestExitMuteMode(USART_TypeDef *USARTx)
  2480. {
  2481.   CLEAR_BIT(USARTx->CR1, USART_CR1_RWU);
  2482. }
  2483.  
  2484. /**
  2485.   * @}
  2486.   */
  2487.  
  2488. #if defined(USE_FULL_LL_DRIVER)
  2489. /** @defgroup USART_LL_EF_Init Initialization and de-initialization functions
  2490.   * @{
  2491.   */
  2492. ErrorStatus LL_USART_DeInit(const USART_TypeDef *USARTx);
  2493. ErrorStatus LL_USART_Init(USART_TypeDef *USARTx, const LL_USART_InitTypeDef *USART_InitStruct);
  2494. void        LL_USART_StructInit(LL_USART_InitTypeDef *USART_InitStruct);
  2495. ErrorStatus LL_USART_ClockInit(USART_TypeDef *USARTx, const LL_USART_ClockInitTypeDef *USART_ClockInitStruct);
  2496. void        LL_USART_ClockStructInit(LL_USART_ClockInitTypeDef *USART_ClockInitStruct);
  2497. /**
  2498.   * @}
  2499.   */
  2500. #endif /* USE_FULL_LL_DRIVER */
  2501.  
  2502. /**
  2503.   * @}
  2504.   */
  2505.  
  2506. /**
  2507.   * @}
  2508.   */
  2509.  
  2510. #endif /* USART1 || USART2|| USART3 || UART4 || UART5 */
  2511.  
  2512. /**
  2513.   * @}
  2514.   */
  2515.  
  2516. #ifdef __cplusplus
  2517. }
  2518. #endif
  2519.  
  2520. #endif /* __STM32L1xx_LL_USART_H */
  2521.  
  2522.