Subversion Repositories FuelGauge

/**

  ******************************************************************************

  * @file    stm32f0xx_ll_usart.h

  * @author  MCD Application Team

  * @brief   Header file of USART LL module.

  ******************************************************************************

  * @attention

  *

  * <h2><center>&copy; Copyright (c) 2016 STMicroelectronics.

  * All rights reserved.</center></h2>

  *

  * This software component is licensed by ST under BSD 3-Clause license,

  * the "License"; You may not use this file except in compliance with the

  * License. You may obtain a copy of the License at:

  *                        opensource.org/licenses/BSD-3-Clause

  *

  ******************************************************************************

  */

/* Define to prevent recursive inclusion -------------------------------------*/

#ifndef STM32F0xx_LL_USART_H

#define STM32F0xx_LL_USART_H

#ifdef __cplusplus

extern "C" {

#endif

/* Includes ------------------------------------------------------------------*/

#include "stm32f0xx.h"

/** @addtogroup STM32F0xx_LL_Driver

  * @{

  */

#if defined (USART1) || defined (USART2) || defined (USART3) || defined (UART4) || defined (UART5) || defined (USART6) || defined (USART7) || defined (USART8)

/** @defgroup USART_LL USART

  * @{

  */

/* Private types -------------------------------------------------------------*/

/* Private variables ---------------------------------------------------------*/

/* Private constants ---------------------------------------------------------*/

/* Private macros ------------------------------------------------------------*/

#if defined(USE_FULL_LL_DRIVER)

/** @defgroup USART_LL_Private_Macros USART Private Macros

  * @{

  */

/**

  * @}

  */

#endif /*USE_FULL_LL_DRIVER*/

/* Exported types ------------------------------------------------------------*/

#if defined(USE_FULL_LL_DRIVER)

/** @defgroup USART_LL_ES_INIT USART Exported Init structures

  * @{

  */

/**

  * @brief LL USART Init Structure definition

  */

typedef struct

{

  uint32_t BaudRate;                  /*!< This field defines expected Usart communication baud rate.

                                           This feature can be modified afterwards using unitary function @ref LL_USART_SetBaudRate().*/

  uint32_t DataWidth;                 /*!< Specifies the number of data bits transmitted or received in a frame.

                                           This parameter can be a value of @ref USART_LL_EC_DATAWIDTH.

                                           This feature can be modified afterwards using unitary function @ref LL_USART_SetDataWidth().*/

  uint32_t StopBits;                  /*!< Specifies the number of stop bits transmitted.

                                           This parameter can be a value of @ref USART_LL_EC_STOPBITS.

                                           This feature can be modified afterwards using unitary function @ref LL_USART_SetStopBitsLength().*/

  uint32_t Parity;                    /*!< Specifies the parity mode.

                                           This parameter can be a value of @ref USART_LL_EC_PARITY.

                                           This feature can be modified afterwards using unitary function @ref LL_USART_SetParity().*/

  uint32_t TransferDirection;         /*!< Specifies whether the Receive and/or Transmit mode is enabled or disabled.

                                           This parameter can be a value of @ref USART_LL_EC_DIRECTION.

                                           This feature can be modified afterwards using unitary function @ref LL_USART_SetTransferDirection().*/

  uint32_t HardwareFlowControl;       /*!< Specifies whether the hardware flow control mode is enabled or disabled.

                                           This parameter can be a value of @ref USART_LL_EC_HWCONTROL.

                                           This feature can be modified afterwards using unitary function @ref LL_USART_SetHWFlowCtrl().*/

  uint32_t OverSampling;              /*!< Specifies whether USART oversampling mode is 16 or 8.

                                           This parameter can be a value of @ref USART_LL_EC_OVERSAMPLING.

                                           This feature can be modified afterwards using unitary function @ref LL_USART_SetOverSampling().*/

} LL_USART_InitTypeDef;

/**

  * @brief LL USART Clock Init Structure definition

  */

typedef struct

{

  uint32_t ClockOutput;               /*!< Specifies whether the USART clock is enabled or disabled.

                                           This parameter can be a value of @ref USART_LL_EC_CLOCK.

                                           USART HW configuration can be modified afterwards using unitary functions

                                           @ref LL_USART_EnableSCLKOutput() or @ref LL_USART_DisableSCLKOutput().

                                           For more details, refer to description of this function. */

  uint32_t ClockPolarity;             /*!< Specifies the steady state of the serial clock.

                                           This parameter can be a value of @ref USART_LL_EC_POLARITY.

                                           USART HW configuration can be modified afterwards using unitary functions @ref LL_USART_SetClockPolarity().

                                           For more details, refer to description of this function. */

  uint32_t ClockPhase;                /*!< Specifies the clock transition on which the bit capture is made.

                                           This parameter can be a value of @ref USART_LL_EC_PHASE.

                                           USART HW configuration can be modified afterwards using unitary functions @ref LL_USART_SetClockPhase().

                                           For more details, refer to description of this function. */

  uint32_t LastBitClockPulse;         /*!< Specifies whether the clock pulse corresponding to the last transmitted

                                           data bit (MSB) has to be output on the SCLK pin in synchronous mode.

                                           This parameter can be a value of @ref USART_LL_EC_LASTCLKPULSE.

                                           USART HW configuration can be modified afterwards using unitary functions @ref LL_USART_SetLastClkPulseOutput().

                                           For more details, refer to description of this function. */

} LL_USART_ClockInitTypeDef;

/**

  * @}

  */

#endif /* USE_FULL_LL_DRIVER */

/* Exported constants --------------------------------------------------------*/

/** @defgroup USART_LL_Exported_Constants USART Exported Constants

  * @{

  */

/** @defgroup USART_LL_EC_CLEAR_FLAG Clear Flags Defines

  * @brief    Flags defines which can be used with LL_USART_WriteReg function

  * @{

  */

#define LL_USART_ICR_PECF                       USART_ICR_PECF                /*!< Parity error flag */

#define LL_USART_ICR_FECF                       USART_ICR_FECF                /*!< Framing error flag */

#define LL_USART_ICR_NCF                        USART_ICR_NCF                 /*!< Noise error detected flag */

#define LL_USART_ICR_ORECF                      USART_ICR_ORECF               /*!< Overrun error flag */

#define LL_USART_ICR_IDLECF                     USART_ICR_IDLECF              /*!< Idle line detected flag */

#define LL_USART_ICR_TCCF                       USART_ICR_TCCF                /*!< Transmission complete flag */

#if defined USART_LIN_SUPPORT

#define LL_USART_ICR_LBDCF                      USART_ICR_LBDCF               /*!< LIN break detection flag */

#endif /* USART_LIN_SUPPORT */

#define LL_USART_ICR_CTSCF                      USART_ICR_CTSCF               /*!< CTS flag */

#define LL_USART_ICR_RTOCF                      USART_ICR_RTOCF               /*!< Receiver timeout flag */

#if defined USART_SMARTCARD_SUPPORT

#define LL_USART_ICR_EOBCF                      USART_ICR_EOBCF               /*!< End of block flag */

#endif /* USART_SMARTCARD_SUPPORT */

#define LL_USART_ICR_CMCF                       USART_ICR_CMCF                /*!< Character match flag */

#if defined(USART_CR1_UESM)

#define LL_USART_ICR_WUCF                       USART_ICR_WUCF                /*!< Wakeup from Stop mode flag */

#endif /* USART_CR1_UESM */

/**

  * @}

  */

/** @defgroup USART_LL_EC_GET_FLAG Get Flags Defines

  * @brief    Flags defines which can be used with LL_USART_ReadReg function

  * @{

  */

#define LL_USART_ISR_PE                         USART_ISR_PE                  /*!< Parity error flag */

#define LL_USART_ISR_FE                         USART_ISR_FE                  /*!< Framing error flag */

#define LL_USART_ISR_NE                         USART_ISR_NE                  /*!< Noise detected flag */

#define LL_USART_ISR_ORE                        USART_ISR_ORE                 /*!< Overrun error flag */

#define LL_USART_ISR_IDLE                       USART_ISR_IDLE                /*!< Idle line detected flag */

#define LL_USART_ISR_RXNE                       USART_ISR_RXNE                /*!< Read data register not empty flag */

#define LL_USART_ISR_TC                         USART_ISR_TC                  /*!< Transmission complete flag */

#define LL_USART_ISR_TXE                        USART_ISR_TXE                 /*!< Transmit data register empty flag */

#if defined USART_LIN_SUPPORT

#define LL_USART_ISR_LBDF                       USART_ISR_LBDF                /*!< LIN break detection flag */

#endif /* USART_LIN_SUPPORT */

#define LL_USART_ISR_CTSIF                      USART_ISR_CTSIF               /*!< CTS interrupt flag */

#define LL_USART_ISR_CTS                        USART_ISR_CTS                 /*!< CTS flag */

#define LL_USART_ISR_RTOF                       USART_ISR_RTOF                /*!< Receiver timeout flag */

#if defined USART_SMARTCARD_SUPPORT

#define LL_USART_ISR_EOBF                       USART_ISR_EOBF                /*!< End of block flag */

#endif /* USART_SMARTCARD_SUPPORT */

#define LL_USART_ISR_ABRE                       USART_ISR_ABRE                /*!< Auto baud rate error flag */

#define LL_USART_ISR_ABRF                       USART_ISR_ABRF                /*!< Auto baud rate flag */

#define LL_USART_ISR_BUSY                       USART_ISR_BUSY                /*!< Busy flag */

#define LL_USART_ISR_CMF                        USART_ISR_CMF                 /*!< Character match flag */

#define LL_USART_ISR_SBKF                       USART_ISR_SBKF                /*!< Send break flag */

#define LL_USART_ISR_RWU                        USART_ISR_RWU                 /*!< Receiver wakeup from Mute mode flag */

#if defined(USART_CR1_UESM)

#define LL_USART_ISR_WUF                        USART_ISR_WUF                 /*!< Wakeup from Stop mode flag */

#endif /* USART_CR1_UESM */

#define LL_USART_ISR_TEACK                      USART_ISR_TEACK               /*!< Transmit enable acknowledge flag */

#define LL_USART_ISR_REACK                      USART_ISR_REACK               /*!< Receive enable acknowledge flag */

/**

  * @}

  */

/** @defgroup USART_LL_EC_IT IT Defines

  * @brief    IT defines which can be used with LL_USART_ReadReg and  LL_USART_WriteReg functions

  * @{

  */

#define LL_USART_CR1_IDLEIE                     USART_CR1_IDLEIE              /*!< IDLE interrupt enable */

#define LL_USART_CR1_RXNEIE                     USART_CR1_RXNEIE              /*!< Read data register not empty interrupt enable */

#define LL_USART_CR1_TCIE                       USART_CR1_TCIE                /*!< Transmission complete interrupt enable */

#define LL_USART_CR1_TXEIE                      USART_CR1_TXEIE               /*!< Transmit data register empty interrupt enable */

#define LL_USART_CR1_PEIE                       USART_CR1_PEIE                /*!< Parity error */

#define LL_USART_CR1_CMIE                       USART_CR1_CMIE                /*!< Character match interrupt enable */

#define LL_USART_CR1_RTOIE                      USART_CR1_RTOIE               /*!< Receiver timeout interrupt enable */

#if defined(USART_SMARTCARD_SUPPORT)

#define LL_USART_CR1_EOBIE                      USART_CR1_EOBIE               /*!< End of Block interrupt enable */

#endif /* USART_SMARTCARD_SUPPORT */

#if defined(USART_LIN_SUPPORT)

#define LL_USART_CR2_LBDIE                      USART_CR2_LBDIE               /*!< LIN break detection interrupt enable */

#endif /* USART_LIN_SUPPORT */

#define LL_USART_CR3_EIE                        USART_CR3_EIE                 /*!< Error interrupt enable */

#define LL_USART_CR3_CTSIE                      USART_CR3_CTSIE               /*!< CTS interrupt enable */

#if defined(USART_CR1_UESM)

#define LL_USART_CR3_WUFIE                      USART_CR3_WUFIE               /*!< Wakeup from Stop mode interrupt enable */

#endif /* USART_CR1_UESM */

/**

  * @}

  */

/** @defgroup USART_LL_EC_DIRECTION Communication Direction

  * @{

  */

#define LL_USART_DIRECTION_NONE                 0x00000000U                        /*!< Transmitter and Receiver are disabled */

#define LL_USART_DIRECTION_RX                   USART_CR1_RE                       /*!< Transmitter is disabled and Receiver is enabled */

#define LL_USART_DIRECTION_TX                   USART_CR1_TE                       /*!< Transmitter is enabled and Receiver is disabled */

#define LL_USART_DIRECTION_TX_RX                (USART_CR1_TE |USART_CR1_RE)       /*!< Transmitter and Receiver are enabled */

/**

  * @}

  */

/** @defgroup USART_LL_EC_PARITY Parity Control

  * @{

  */

#define LL_USART_PARITY_NONE                    0x00000000U                          /*!< Parity control disabled */

#define LL_USART_PARITY_EVEN                    USART_CR1_PCE                        /*!< Parity control enabled and Even Parity is selected */

#define LL_USART_PARITY_ODD                     (USART_CR1_PCE | USART_CR1_PS)       /*!< Parity control enabled and Odd Parity is selected */

/**

  * @}

  */

/** @defgroup USART_LL_EC_WAKEUP Wakeup

  * @{

  */

#define LL_USART_WAKEUP_IDLELINE                0x00000000U           /*!<  USART wake up from Mute mode on Idle Line */

#define LL_USART_WAKEUP_ADDRESSMARK             USART_CR1_WAKE        /*!<  USART wake up from Mute mode on Address Mark */

/**

  * @}

  */

/** @defgroup USART_LL_EC_DATAWIDTH Datawidth

  * @{

  */

#if defined(USART_7BITS_SUPPORT)

#define LL_USART_DATAWIDTH_7B                   USART_CR1_M1            /*!< 7 bits word length : Start bit, 7 data bits, n stop bits */

#define LL_USART_DATAWIDTH_8B                   0x00000000U             /*!< 8 bits word length : Start bit, 8 data bits, n stop bits */

#define LL_USART_DATAWIDTH_9B                   USART_CR1_M0            /*!< 9 bits word length : Start bit, 9 data bits, n stop bits */

#else

#define LL_USART_DATAWIDTH_8B                   0x00000000U             /*!< 8 bits word length : Start bit, 8 data bits, n stop bits */

#define LL_USART_DATAWIDTH_9B                   USART_CR1_M             /*!< 9 bits word length : Start bit, 9 data bits, n stop bits */

#endif/* USART_7BITS_SUPPORT */

/**

  * @}

  */

/** @defgroup USART_LL_EC_OVERSAMPLING Oversampling

  * @{

  */

#define LL_USART_OVERSAMPLING_16                0x00000000U            /*!< Oversampling by 16 */

#define LL_USART_OVERSAMPLING_8                 USART_CR1_OVER8        /*!< Oversampling by 8 */

/**

  * @}

  */

#if defined(USE_FULL_LL_DRIVER)

/** @defgroup USART_LL_EC_CLOCK Clock Signal

  * @{

  */

#define LL_USART_CLOCK_DISABLE                  0x00000000U            /*!< Clock signal not provided */

#define LL_USART_CLOCK_ENABLE                   USART_CR2_CLKEN        /*!< Clock signal provided */

/**

  * @}

  */

#endif /*USE_FULL_LL_DRIVER*/

/** @defgroup USART_LL_EC_LASTCLKPULSE Last Clock Pulse

  * @{

  */

#define LL_USART_LASTCLKPULSE_NO_OUTPUT         0x00000000U           /*!< The clock pulse of the last data bit is not output to the SCLK pin */

#define LL_USART_LASTCLKPULSE_OUTPUT            USART_CR2_LBCL        /*!< The clock pulse of the last data bit is output to the SCLK pin */

/**

  * @}

  */

/** @defgroup USART_LL_EC_PHASE Clock Phase

  * @{

  */

#define LL_USART_PHASE_1EDGE                    0x00000000U           /*!< The first clock transition is the first data capture edge */

#define LL_USART_PHASE_2EDGE                    USART_CR2_CPHA        /*!< The second clock transition is the first data capture edge */

/**

  * @}

  */

/** @defgroup USART_LL_EC_POLARITY Clock Polarity

  * @{

  */

#define LL_USART_POLARITY_LOW                   0x00000000U           /*!< Steady low value on SCLK pin outside transmission window*/

#define LL_USART_POLARITY_HIGH                  USART_CR2_CPOL        /*!< Steady high value on SCLK pin outside transmission window */

/**

  * @}

  */

/** @defgroup USART_LL_EC_STOPBITS Stop Bits

  * @{

  */

#if defined(USART_SMARTCARD_SUPPORT)

#define LL_USART_STOPBITS_0_5                   USART_CR2_STOP_0                           /*!< 0.5 stop bit */

#endif /* USART_SMARTCARD_SUPPORT */

#define LL_USART_STOPBITS_1                     0x00000000U                                /*!< 1 stop bit */

#if defined(USART_SMARTCARD_SUPPORT)

#define LL_USART_STOPBITS_1_5                   (USART_CR2_STOP_0 | USART_CR2_STOP_1)      /*!< 1.5 stop bits */

#endif /* USART_SMARTCARD_SUPPORT */

#define LL_USART_STOPBITS_2                     USART_CR2_STOP_1                           /*!< 2 stop bits */

/**

  * @}

  */

/** @defgroup USART_LL_EC_TXRX TX RX Pins Swap

  * @{

  */

#define LL_USART_TXRX_STANDARD                  0x00000000U           /*!< TX/RX pins are used as defined in standard pinout */

#define LL_USART_TXRX_SWAPPED                   (USART_CR2_SWAP)      /*!< TX and RX pins functions are swapped.             */

/**

  * @}

  */

/** @defgroup USART_LL_EC_RXPIN_LEVEL RX Pin Active Level Inversion

  * @{

  */

#define LL_USART_RXPIN_LEVEL_STANDARD           0x00000000U           /*!< RX pin signal works using the standard logic levels */

#define LL_USART_RXPIN_LEVEL_INVERTED           (USART_CR2_RXINV)     /*!< RX pin signal values are inverted.                  */

/**

  * @}

  */

/** @defgroup USART_LL_EC_TXPIN_LEVEL TX Pin Active Level Inversion

  * @{

  */

#define LL_USART_TXPIN_LEVEL_STANDARD           0x00000000U           /*!< TX pin signal works using the standard logic levels */

#define LL_USART_TXPIN_LEVEL_INVERTED           (USART_CR2_TXINV)     /*!< TX pin signal values are inverted.                  */

/**

  * @}

  */

/** @defgroup USART_LL_EC_BINARY_LOGIC Binary Data Inversion

  * @{

  */

#define LL_USART_BINARY_LOGIC_POSITIVE          0x00000000U           /*!< Logical data from the data register are send/received in positive/direct logic. (1=H, 0=L) */

#define LL_USART_BINARY_LOGIC_NEGATIVE          USART_CR2_DATAINV     /*!< Logical data from the data register are send/received in negative/inverse logic. (1=L, 0=H). The parity bit is also inverted. */

/**

  * @}

  */

/** @defgroup USART_LL_EC_BITORDER Bit Order

  * @{

  */

#define LL_USART_BITORDER_LSBFIRST              0x00000000U           /*!< data is transmitted/received with data bit 0 first, following the start bit */

#define LL_USART_BITORDER_MSBFIRST              USART_CR2_MSBFIRST    /*!< data is transmitted/received with the MSB first, following the start bit */

/**

  * @}

  */

/** @defgroup USART_LL_EC_AUTOBAUD_DETECT_ON Autobaud Detection

  * @{

  */

#define LL_USART_AUTOBAUD_DETECT_ON_STARTBIT    0x00000000U                                 /*!< Measurement of the start bit is used to detect the baud rate */

#define LL_USART_AUTOBAUD_DETECT_ON_FALLINGEDGE USART_CR2_ABRMODE_0                         /*!< Falling edge to falling edge measurement. Received frame must start with a single bit = 1 -> Frame = Start10xxxxxx */

#if defined(USART_FABR_SUPPORT)

#define LL_USART_AUTOBAUD_DETECT_ON_7F_FRAME    USART_CR2_ABRMODE_1                         /*!< 0x7F frame detection */

#define LL_USART_AUTOBAUD_DETECT_ON_55_FRAME    (USART_CR2_ABRMODE_1 | USART_CR2_ABRMODE_0) /*!< 0x55 frame detection */

#endif /* USART_FABR_SUPPORT */

/**

  * @}

  */

/** @defgroup USART_LL_EC_ADDRESS_DETECT Address Length Detection

  * @{

  */

#define LL_USART_ADDRESS_DETECT_4B              0x00000000U           /*!< 4-bit address detection method selected */

#define LL_USART_ADDRESS_DETECT_7B              USART_CR2_ADDM7       /*!< 7-bit address detection (in 8-bit data mode) method selected */

/**

  * @}

  */

/** @defgroup USART_LL_EC_HWCONTROL Hardware Control

  * @{

  */

#define LL_USART_HWCONTROL_NONE                 0x00000000U                          /*!< CTS and RTS hardware flow control disabled */

#define LL_USART_HWCONTROL_RTS                  USART_CR3_RTSE                       /*!< RTS output enabled, data is only requested when there is space in the receive buffer */

#define LL_USART_HWCONTROL_CTS                  USART_CR3_CTSE                       /*!< CTS mode enabled, data is only transmitted when the nCTS input is asserted (tied to 0) */

#define LL_USART_HWCONTROL_RTS_CTS              (USART_CR3_RTSE | USART_CR3_CTSE)    /*!< CTS and RTS hardware flow control enabled */

/**

  * @}

  */

#if defined(USART_CR1_UESM)

/** @defgroup USART_LL_EC_WAKEUP_ON Wakeup Activation

  * @{

  */

#define LL_USART_WAKEUP_ON_ADDRESS              0x00000000U                             /*!< Wake up active on address match */

#define LL_USART_WAKEUP_ON_STARTBIT             USART_CR3_WUS_1                         /*!< Wake up active on Start bit detection */

#define LL_USART_WAKEUP_ON_RXNE                 (USART_CR3_WUS_0 | USART_CR3_WUS_1)     /*!< Wake up active on RXNE */

/**

  * @}

  */

#endif /* USART_CR1_UESM */

#if defined(USART_IRDA_SUPPORT)

/** @defgroup USART_LL_EC_IRDA_POWER IrDA Power

  * @{

  */

#define LL_USART_IRDA_POWER_NORMAL              0x00000000U           /*!< IrDA normal power mode */

#define LL_USART_IRDA_POWER_LOW                 USART_CR3_IRLP        /*!< IrDA low power mode */

/**

  * @}

  */

#endif /* USART_IRDA_SUPPORT */

#if defined(USART_LIN_SUPPORT)

/** @defgroup USART_LL_EC_LINBREAK_DETECT LIN Break Detection Length

  * @{

  */

#define LL_USART_LINBREAK_DETECT_10B            0x00000000U           /*!< 10-bit break detection method selected */

#define LL_USART_LINBREAK_DETECT_11B            USART_CR2_LBDL        /*!< 11-bit break detection method selected */

/**

  * @}

  */

#endif /* USART_LIN_SUPPORT */

/** @defgroup USART_LL_EC_DE_POLARITY Driver Enable Polarity

  * @{

  */

#define LL_USART_DE_POLARITY_HIGH               0x00000000U           /*!< DE signal is active high */

#define LL_USART_DE_POLARITY_LOW                USART_CR3_DEP         /*!< DE signal is active low */

/**

  * @}

  */

/** @defgroup USART_LL_EC_DMA_REG_DATA DMA Register Data

  * @{

  */

#define LL_USART_DMA_REG_DATA_TRANSMIT          0x00000000U          /*!< Get address of data register used for transmission */

#define LL_USART_DMA_REG_DATA_RECEIVE           0x00000001U          /*!< Get address of data register used for reception */

/**

  * @}

  */

/**

  * @}

  */

/* Exported macro ------------------------------------------------------------*/

/** @defgroup USART_LL_Exported_Macros USART Exported Macros

  * @{

  */

/** @defgroup USART_LL_EM_WRITE_READ Common Write and read registers Macros

  * @{

  */

/**

  * @brief  Write a value in USART register

  * @param  __INSTANCE__ USART Instance

  * @param  __REG__ Register to be written

  * @param  __VALUE__ Value to be written in the register

  * @retval None

  */

#define LL_USART_WriteReg(__INSTANCE__, __REG__, __VALUE__) WRITE_REG(__INSTANCE__->__REG__, (__VALUE__))

/**

  * @brief  Read a value in USART register

  * @param  __INSTANCE__ USART Instance

  * @param  __REG__ Register to be read

  * @retval Register value

  */

#define LL_USART_ReadReg(__INSTANCE__, __REG__) READ_REG(__INSTANCE__->__REG__)

/**

  * @}

  */

/** @defgroup USART_LL_EM_Exported_Macros_Helper Exported_Macros_Helper

  * @{

  */

/**

  * @brief  Compute USARTDIV value according to Peripheral Clock and

  *         expected Baud Rate in 8 bits sampling mode (32 bits value of USARTDIV is returned)

  * @param  __PERIPHCLK__ Peripheral Clock frequency used for USART instance

  * @param  __BAUDRATE__ Baud rate value to achieve

  * @retval USARTDIV value to be used for BRR register filling in OverSampling_8 case

  */

#define __LL_USART_DIV_SAMPLING8(__PERIPHCLK__, __BAUDRATE__) ((((__PERIPHCLK__)*2U)\

                                                                + ((__BAUDRATE__)/2U))/(__BAUDRATE__))

/**

  * @brief  Compute USARTDIV value according to Peripheral Clock and

  *         expected Baud Rate in 16 bits sampling mode (32 bits value of USARTDIV is returned)

  * @param  __PERIPHCLK__ Peripheral Clock frequency used for USART instance

  * @param  __BAUDRATE__ Baud rate value to achieve

  * @retval USARTDIV value to be used for BRR register filling in OverSampling_16 case

  */

#define __LL_USART_DIV_SAMPLING16(__PERIPHCLK__, __BAUDRATE__) (((__PERIPHCLK__) + ((__BAUDRATE__)/2U))/(__BAUDRATE__))

/**

  * @}

  */

/**

  * @}

  */

/* Exported functions --------------------------------------------------------*/

/** @defgroup USART_LL_Exported_Functions USART Exported Functions

  * @{

  */

/** @defgroup USART_LL_EF_Configuration Configuration functions

  * @{

  */

/**

  * @brief  USART Enable

  * @rmtoll CR1          UE            LL_USART_Enable

  * @param  USARTx USART Instance

  * @retval None

  */

__STATIC_INLINE void LL_USART_Enable(USART_TypeDef *USARTx)

{

  SET_BIT(USARTx->CR1, USART_CR1_UE);

}

/**

  * @brief  USART Disable (all USART prescalers and outputs are disabled)

  * @note   When USART is disabled, USART prescalers and outputs are stopped immediately,

  *         and current operations are discarded. The configuration of the USART is kept, but all the status

  *         flags, in the USARTx_ISR are set to their default values.

  * @rmtoll CR1          UE            LL_USART_Disable

  * @param  USARTx USART Instance

  * @retval None

  */

__STATIC_INLINE void LL_USART_Disable(USART_TypeDef *USARTx)

{

  CLEAR_BIT(USARTx->CR1, USART_CR1_UE);

}

/**

  * @brief  Indicate if USART is enabled

  * @rmtoll CR1          UE            LL_USART_IsEnabled

  * @param  USARTx USART Instance

  * @retval State of bit (1 or 0).

  */

__STATIC_INLINE uint32_t LL_USART_IsEnabled(USART_TypeDef *USARTx)

{

  return ((READ_BIT(USARTx->CR1, USART_CR1_UE) == (USART_CR1_UE)) ? 1UL : 0UL);

}

#if defined(USART_CR1_UESM)

/**

  * @brief  USART enabled in STOP Mode.

  * @note   When this function is enabled, USART is able to wake up the MCU from Stop mode, provided that

  *         USART clock selection is HSI or LSE in RCC.

  * @note   Macro @ref IS_UART_WAKEUP_FROMSTOP_INSTANCE(USARTx) can be used to check whether or not

  *         Wake-up from Stop mode feature is supported by the USARTx instance.

  * @rmtoll CR1          UESM          LL_USART_EnableInStopMode

  * @param  USARTx USART Instance

  * @retval None

  */

__STATIC_INLINE void LL_USART_EnableInStopMode(USART_TypeDef *USARTx)

{

  SET_BIT(USARTx->CR1, USART_CR1_UESM);

}

/**

  * @brief  USART disabled in STOP Mode.

  * @note   When this function is disabled, USART is not able to wake up the MCU from Stop mode

  * @note   Macro @ref IS_UART_WAKEUP_FROMSTOP_INSTANCE(USARTx) can be used to check whether or not

  *         Wake-up from Stop mode feature is supported by the USARTx instance.

  * @rmtoll CR1          UESM          LL_USART_DisableInStopMode

  * @param  USARTx USART Instance

  * @retval None

  */

__STATIC_INLINE void LL_USART_DisableInStopMode(USART_TypeDef *USARTx)

{

  CLEAR_BIT(USARTx->CR1, USART_CR1_UESM);

}

/**

  * @brief  Indicate if USART is enabled in STOP Mode (able to wake up MCU from Stop mode or not)

  * @note   Macro @ref IS_UART_WAKEUP_FROMSTOP_INSTANCE(USARTx) can be used to check whether or not

  *         Wake-up from Stop mode feature is supported by the USARTx instance.

  * @rmtoll CR1          UESM          LL_USART_IsEnabledInStopMode

  * @param  USARTx USART Instance

  * @retval State of bit (1 or 0).

  */

__STATIC_INLINE uint32_t LL_USART_IsEnabledInStopMode(USART_TypeDef *USARTx)

{

  return ((READ_BIT(USARTx->CR1, USART_CR1_UESM) == (USART_CR1_UESM)) ? 1UL : 0UL);

}

#endif /* USART_CR1_UESM*/

/**

  * @brief  Receiver Enable (Receiver is enabled and begins searching for a start bit)

  * @rmtoll CR1          RE            LL_USART_EnableDirectionRx

  * @param  USARTx USART Instance

  * @retval None

  */

__STATIC_INLINE void LL_USART_EnableDirectionRx(USART_TypeDef *USARTx)

{

  SET_BIT(USARTx->CR1, USART_CR1_RE);

}

/**

  * @brief  Receiver Disable

  * @rmtoll CR1          RE            LL_USART_DisableDirectionRx

  * @param  USARTx USART Instance

  * @retval None

  */

__STATIC_INLINE void LL_USART_DisableDirectionRx(USART_TypeDef *USARTx)

{

  CLEAR_BIT(USARTx->CR1, USART_CR1_RE);

}

/**

  * @brief  Transmitter Enable

  * @rmtoll CR1          TE            LL_USART_EnableDirectionTx

  * @param  USARTx USART Instance

  * @retval None

  */

__STATIC_INLINE void LL_USART_EnableDirectionTx(USART_TypeDef *USARTx)

{

  SET_BIT(USARTx->CR1, USART_CR1_TE);

}

/**

  * @brief  Transmitter Disable

  * @rmtoll CR1          TE            LL_USART_DisableDirectionTx

  * @param  USARTx USART Instance

  * @retval None

  */

__STATIC_INLINE void LL_USART_DisableDirectionTx(USART_TypeDef *USARTx)

{

  CLEAR_BIT(USARTx->CR1, USART_CR1_TE);

}

/**

  * @brief  Configure simultaneously enabled/disabled states

  *         of Transmitter and Receiver

  * @rmtoll CR1          RE            LL_USART_SetTransferDirection\n

  *         CR1          TE            LL_USART_SetTransferDirection

  * @param  USARTx USART Instance

  * @param  TransferDirection This parameter can be one of the following values:

  *         @arg @ref LL_USART_DIRECTION_NONE

  *         @arg @ref LL_USART_DIRECTION_RX

  *         @arg @ref LL_USART_DIRECTION_TX

  *         @arg @ref LL_USART_DIRECTION_TX_RX

  * @retval None

  */

__STATIC_INLINE void LL_USART_SetTransferDirection(USART_TypeDef *USARTx, uint32_t TransferDirection)

{

  MODIFY_REG(USARTx->CR1, USART_CR1_RE | USART_CR1_TE, TransferDirection);

}

/**

  * @brief  Return enabled/disabled states of Transmitter and Receiver

  * @rmtoll CR1          RE            LL_USART_GetTransferDirection\n

  *         CR1          TE            LL_USART_GetTransferDirection

  * @param  USARTx USART Instance

  * @retval Returned value can be one of the following values:

  *         @arg @ref LL_USART_DIRECTION_NONE

  *         @arg @ref LL_USART_DIRECTION_RX

  *         @arg @ref LL_USART_DIRECTION_TX

  *         @arg @ref LL_USART_DIRECTION_TX_RX

  */

__STATIC_INLINE uint32_t LL_USART_GetTransferDirection(USART_TypeDef *USARTx)

{

  return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_RE | USART_CR1_TE));

}

/**

  * @brief  Configure Parity (enabled/disabled and parity mode if enabled).

  * @note   This function selects if hardware parity control (generation and detection) is enabled or disabled.

  *         When the parity control is enabled (Odd or Even), computed parity bit is inserted at the MSB position

  *         (9th or 8th bit depending on data width) and parity is checked on the received data.

  * @rmtoll CR1          PS            LL_USART_SetParity\n

  *         CR1          PCE           LL_USART_SetParity

  * @param  USARTx USART Instance

  * @param  Parity This parameter can be one of the following values:

  *         @arg @ref LL_USART_PARITY_NONE

  *         @arg @ref LL_USART_PARITY_EVEN

  *         @arg @ref LL_USART_PARITY_ODD

  * @retval None

  */

__STATIC_INLINE void LL_USART_SetParity(USART_TypeDef *USARTx, uint32_t Parity)

{

  MODIFY_REG(USARTx->CR1, USART_CR1_PS | USART_CR1_PCE, Parity);

}

/**

  * @brief  Return Parity configuration (enabled/disabled and parity mode if enabled)

  * @rmtoll CR1          PS            LL_USART_GetParity\n

  *         CR1          PCE           LL_USART_GetParity

  * @param  USARTx USART Instance

  * @retval Returned value can be one of the following values:

  *         @arg @ref LL_USART_PARITY_NONE

  *         @arg @ref LL_USART_PARITY_EVEN

  *         @arg @ref LL_USART_PARITY_ODD

  */

__STATIC_INLINE uint32_t LL_USART_GetParity(USART_TypeDef *USARTx)

{

  return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_PS | USART_CR1_PCE));

}

/**

  * @brief  Set Receiver Wake Up method from Mute mode.

  * @rmtoll CR1          WAKE          LL_USART_SetWakeUpMethod

  * @param  USARTx USART Instance

  * @param  Method This parameter can be one of the following values:

  *         @arg @ref LL_USART_WAKEUP_IDLELINE

  *         @arg @ref LL_USART_WAKEUP_ADDRESSMARK

  * @retval None

  */

__STATIC_INLINE void LL_USART_SetWakeUpMethod(USART_TypeDef *USARTx, uint32_t Method)

{

  MODIFY_REG(USARTx->CR1, USART_CR1_WAKE, Method);

}

/**

  * @brief  Return Receiver Wake Up method from Mute mode

  * @rmtoll CR1          WAKE          LL_USART_GetWakeUpMethod

  * @param  USARTx USART Instance

  * @retval Returned value can be one of the following values:

  *         @arg @ref LL_USART_WAKEUP_IDLELINE

  *         @arg @ref LL_USART_WAKEUP_ADDRESSMARK

  */

__STATIC_INLINE uint32_t LL_USART_GetWakeUpMethod(USART_TypeDef *USARTx)

{

  return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_WAKE));

}

/**

  * @brief  Set Word length (i.e. nb of data bits, excluding start and stop bits)

  * @rmtoll CR1          M0            LL_USART_SetDataWidth\n

  *         CR1          M1            LL_USART_SetDataWidth

  * @param  USARTx USART Instance

  * @param  DataWidth This parameter can be one of the following values:

  *         @arg @ref LL_USART_DATAWIDTH_7B (*)

  *         @arg @ref LL_USART_DATAWIDTH_8B

  *         @arg @ref LL_USART_DATAWIDTH_9B

  *

  *         (*) Values not available on all devices

  * @retval None

  */

__STATIC_INLINE void LL_USART_SetDataWidth(USART_TypeDef *USARTx, uint32_t DataWidth)

{

  MODIFY_REG(USARTx->CR1, USART_CR1_M, DataWidth);

}

/**

  * @brief  Return Word length (i.e. nb of data bits, excluding start and stop bits)

  * @rmtoll CR1          M0            LL_USART_GetDataWidth\n

  *         CR1          M1            LL_USART_GetDataWidth

  * @param  USARTx USART Instance

  * @retval Returned value can be one of the following values:

  *         @arg @ref LL_USART_DATAWIDTH_7B (*)

  *         @arg @ref LL_USART_DATAWIDTH_8B

  *         @arg @ref LL_USART_DATAWIDTH_9B

  *

  *         (*) Values not available on all devices

  */

__STATIC_INLINE uint32_t LL_USART_GetDataWidth(USART_TypeDef *USARTx)

{

  return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_M));

}

/**

  * @brief  Allow switch between Mute Mode and Active mode

  * @rmtoll CR1          MME           LL_USART_EnableMuteMode

  * @param  USARTx USART Instance

  * @retval None

  */

__STATIC_INLINE void LL_USART_EnableMuteMode(USART_TypeDef *USARTx)

{

  SET_BIT(USARTx->CR1, USART_CR1_MME);

}

/**

  * @brief  Prevent Mute Mode use. Set Receiver in active mode permanently.

  * @rmtoll CR1          MME           LL_USART_DisableMuteMode

  * @param  USARTx USART Instance

  * @retval None

  */

__STATIC_INLINE void LL_USART_DisableMuteMode(USART_TypeDef *USARTx)

{

  CLEAR_BIT(USARTx->CR1, USART_CR1_MME);

}

/**

  * @brief  Indicate if switch between Mute Mode and Active mode is allowed

  * @rmtoll CR1          MME           LL_USART_IsEnabledMuteMode

  * @param  USARTx USART Instance

  * @retval State of bit (1 or 0).

  */

__STATIC_INLINE uint32_t LL_USART_IsEnabledMuteMode(USART_TypeDef *USARTx)

{

  return ((READ_BIT(USARTx->CR1, USART_CR1_MME) == (USART_CR1_MME)) ? 1UL : 0UL);

}

/**

  * @brief  Set Oversampling to 8-bit or 16-bit mode

  * @rmtoll CR1          OVER8         LL_USART_SetOverSampling

  * @param  USARTx USART Instance

  * @param  OverSampling This parameter can be one of the following values:

  *         @arg @ref LL_USART_OVERSAMPLING_16

  *         @arg @ref LL_USART_OVERSAMPLING_8

  * @retval None

  */

__STATIC_INLINE void LL_USART_SetOverSampling(USART_TypeDef *USARTx, uint32_t OverSampling)

{

  MODIFY_REG(USARTx->CR1, USART_CR1_OVER8, OverSampling);

}

/**

  * @brief  Return Oversampling mode

  * @rmtoll CR1          OVER8         LL_USART_GetOverSampling

  * @param  USARTx USART Instance

  * @retval Returned value can be one of the following values:

  *         @arg @ref LL_USART_OVERSAMPLING_16

  *         @arg @ref LL_USART_OVERSAMPLING_8

  */

__STATIC_INLINE uint32_t LL_USART_GetOverSampling(USART_TypeDef *USARTx)

{

  return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_OVER8));

}

/**

  * @brief  Configure if Clock pulse of the last data bit is output to the SCLK pin or not

  * @note   Macro @ref IS_USART_INSTANCE(USARTx) can be used to check whether or not

  *         Synchronous mode is supported by the USARTx instance.

  * @rmtoll CR2          LBCL          LL_USART_SetLastClkPulseOutput

  * @param  USARTx USART Instance

  * @param  LastBitClockPulse This parameter can be one of the following values:

  *         @arg @ref LL_USART_LASTCLKPULSE_NO_OUTPUT

  *         @arg @ref LL_USART_LASTCLKPULSE_OUTPUT

  * @retval None

  */

__STATIC_INLINE void LL_USART_SetLastClkPulseOutput(USART_TypeDef *USARTx, uint32_t LastBitClockPulse)

{

  MODIFY_REG(USARTx->CR2, USART_CR2_LBCL, LastBitClockPulse);

}

/**

  * @brief  Retrieve Clock pulse of the last data bit output configuration

  *         (Last bit Clock pulse output to the SCLK pin or not)

  * @note   Macro @ref IS_USART_INSTANCE(USARTx) can be used to check whether or not

  *         Synchronous mode is supported by the USARTx instance.

  * @rmtoll CR2          LBCL          LL_USART_GetLastClkPulseOutput

  * @param  USARTx USART Instance

  * @retval Returned value can be one of the following values:

  *         @arg @ref LL_USART_LASTCLKPULSE_NO_OUTPUT

  *         @arg @ref LL_USART_LASTCLKPULSE_OUTPUT

  */

__STATIC_INLINE uint32_t LL_USART_GetLastClkPulseOutput(USART_TypeDef *USARTx)

{

  return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_LBCL));

}

/**

  * @brief  Select the phase of the clock output on the SCLK pin in synchronous mode

  * @note   Macro @ref IS_USART_INSTANCE(USARTx) can be used to check whether or not

  *         Synchronous mode is supported by the USARTx instance.

  * @rmtoll CR2          CPHA          LL_USART_SetClockPhase

  * @param  USARTx USART Instance

  * @param  ClockPhase This parameter can be one of the following values:

  *         @arg @ref LL_USART_PHASE_1EDGE

  *         @arg @ref LL_USART_PHASE_2EDGE

  * @retval None

  */

__STATIC_INLINE void LL_USART_SetClockPhase(USART_TypeDef *USARTx, uint32_t ClockPhase)

{

  MODIFY_REG(USARTx->CR2, USART_CR2_CPHA, ClockPhase);

}

/**

  * @brief  Return phase of the clock output on the SCLK pin in synchronous mode

  * @note   Macro @ref IS_USART_INSTANCE(USARTx) can be used to check whether or not

  *         Synchronous mode is supported by the USARTx instance.

  * @rmtoll CR2          CPHA          LL_USART_GetClockPhase

  * @param  USARTx USART Instance

  * @retval Returned value can be one of the following values:

  *         @arg @ref LL_USART_PHASE_1EDGE

  *         @arg @ref LL_USART_PHASE_2EDGE

  */

__STATIC_INLINE uint32_t LL_USART_GetClockPhase(USART_TypeDef *USARTx)

{

  return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_CPHA));

}

/**

  * @brief  Select the polarity of the clock output on the SCLK pin in synchronous mode

  * @note   Macro @ref IS_USART_INSTANCE(USARTx) can be used to check whether or not

  *         Synchronous mode is supported by the USARTx instance.

  * @rmtoll CR2          CPOL          LL_USART_SetClockPolarity

  * @param  USARTx USART Instance

  * @param  ClockPolarity This parameter can be one of the following values:

  *         @arg @ref LL_USART_POLARITY_LOW

  *         @arg @ref LL_USART_POLARITY_HIGH

  * @retval None

  */

__STATIC_INLINE void LL_USART_SetClockPolarity(USART_TypeDef *USARTx, uint32_t ClockPolarity)

{

  MODIFY_REG(USARTx->CR2, USART_CR2_CPOL, ClockPolarity);

}

/**

  * @brief  Return polarity of the clock output on the SCLK pin in synchronous mode

  * @note   Macro @ref IS_USART_INSTANCE(USARTx) can be used to check whether or not

  *         Synchronous mode is supported by the USARTx instance.

  * @rmtoll CR2          CPOL          LL_USART_GetClockPolarity

  * @param  USARTx USART Instance

  * @retval Returned value can be one of the following values:

  *         @arg @ref LL_USART_POLARITY_LOW

  *         @arg @ref LL_USART_POLARITY_HIGH

  */

__STATIC_INLINE uint32_t LL_USART_GetClockPolarity(USART_TypeDef *USARTx)

{

  return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_CPOL));

}

/**

  * @brief  Configure Clock signal format (Phase Polarity and choice about output of last bit clock pulse)

  * @note   Macro @ref IS_USART_INSTANCE(USARTx) can be used to check whether or not

  *         Synchronous mode is supported by the USARTx instance.

  * @note   Call of this function is equivalent to following function call sequence :