Lpuart_driver

Data Structures
struct	_lpuart_config
	LPUART configuration structure. More...
struct	_lpuart_transfer
	LPUART transfer structure. More...
struct	_lpuart_handle
	LPUART handle structure. More...

Variables
uint32_t	_lpuart_config::baudRate_Bps
lpuart_parity_mode_t	_lpuart_config::parityMode
lpuart_data_bits_t	_lpuart_config::dataBitsCount
bool	_lpuart_config::isMsb
lpuart_stop_bit_count_t	_lpuart_config::stopBitCount
uint8_t	_lpuart_config::txFifoWatermark
uint8_t	_lpuart_config::rxFifoWatermark
bool	_lpuart_config::enableRxRTS
bool	_lpuart_config::enableTxCTS
lpuart_transmit_cts_source_t	_lpuart_config::txCtsSource
lpuart_transmit_cts_config_t	_lpuart_config::txCtsConfig
lpuart_idle_type_select_t	_lpuart_config::rxIdleType
lpuart_idle_config_t	_lpuart_config::rxIdleConfig
bool	_lpuart_config::enableTx
bool	_lpuart_config::enableRx
uint8_t *	_lpuart_transfer::data
size_t	_lpuart_transfer::dataSize
uint8_t *volatile	_lpuart_handle::txData
volatile size_t	_lpuart_handle::txDataSize
size_t	_lpuart_handle::txDataSizeAll
uint8_t *volatile	_lpuart_handle::rxData
volatile size_t	_lpuart_handle::rxDataSize
size_t	_lpuart_handle::rxDataSizeAll
uint8_t *	_lpuart_handle::rxRingBuffer
size_t	_lpuart_handle::rxRingBufferSize
volatile uint16_t	_lpuart_handle::rxRingBufferHead
volatile uint16_t	_lpuart_handle::rxRingBufferTail
lpuart_transfer_callback_t	_lpuart_handle::callback
void *	_lpuart_handle::userData
volatile uint8_t	_lpuart_handle::txState
volatile uint8_t	_lpuart_handle::rxState
bool	_lpuart_handle::isSevenDataBits

Driver version
enum	_lpuart_status {   kStatus_LPUART_TxBusy = MAKE_STATUS(kStatusGroup_LPUART, 0) , kStatus_LPUART_RxBusy = MAKE_STATUS(kStatusGroup_LPUART, 1) , kStatus_LPUART_TxIdle = MAKE_STATUS(kStatusGroup_LPUART, 2) , kStatus_LPUART_RxIdle = MAKE_STATUS(kStatusGroup_LPUART, 3) ,   kStatus_LPUART_TxWatermarkTooLarge = MAKE_STATUS(kStatusGroup_LPUART, 4) , kStatus_LPUART_RxWatermarkTooLarge = MAKE_STATUS(kStatusGroup_LPUART, 5) , kStatus_LPUART_FlagCannotClearManually = MAKE_STATUS(kStatusGroup_LPUART, 6) , kStatus_LPUART_Error = MAKE_STATUS(kStatusGroup_LPUART, 7) ,   kStatus_LPUART_RxRingBufferOverrun , kStatus_LPUART_RxHardwareOverrun = MAKE_STATUS(kStatusGroup_LPUART, 9) , kStatus_LPUART_NoiseError = MAKE_STATUS(kStatusGroup_LPUART, 10) , kStatus_LPUART_FramingError = MAKE_STATUS(kStatusGroup_LPUART, 11) ,   kStatus_LPUART_ParityError = MAKE_STATUS(kStatusGroup_LPUART, 12) , kStatus_LPUART_BaudrateNotSupport , kStatus_LPUART_IdleLineDetected = MAKE_STATUS(kStatusGroup_LPUART, 14) }
	Error codes for the LPUART driver. More...
enum	_lpuart_parity_mode { kLPUART_ParityDisabled = 0x0U , kLPUART_ParityEven = 0x2U , kLPUART_ParityOdd = 0x3U }
	LPUART parity mode. More...
enum	_lpuart_data_bits { kLPUART_EightDataBits = 0x0U , kLPUART_SevenDataBits = 0x1U }
	LPUART data bits count. More...
enum	_lpuart_stop_bit_count { kLPUART_OneStopBit = 0U , kLPUART_TwoStopBit = 1U }
	LPUART stop bit count. More...
enum	_lpuart_transmit_cts_source { kLPUART_CtsSourcePin = 0U , kLPUART_CtsSourceMatchResult = 1U }
	LPUART transmit CTS source. More...
enum	_lpuart_transmit_cts_config { kLPUART_CtsSampleAtStart = 0U , kLPUART_CtsSampleAtIdle = 1U }
	LPUART transmit CTS configure. More...
enum	_lpuart_idle_type_select { kLPUART_IdleTypeStartBit = 0U , kLPUART_IdleTypeStopBit = 1U }
	LPUART idle flag type defines when the receiver starts counting. More...
enum	_lpuart_idle_config {   kLPUART_IdleCharacter1 = 0U , kLPUART_IdleCharacter2 = 1U , kLPUART_IdleCharacter4 = 2U , kLPUART_IdleCharacter8 = 3U ,   kLPUART_IdleCharacter16 = 4U , kLPUART_IdleCharacter32 = 5U , kLPUART_IdleCharacter64 = 6U , kLPUART_IdleCharacter128 = 7U }
	LPUART idle detected configuration. This structure defines the number of idle characters that must be received before the IDLE flag is set. More...
enum	_lpuart_interrupt_enable {   kLPUART_LinBreakInterruptEnable = (LPUART_BAUD_LBKDIE_MASK >> 8) , kLPUART_RxActiveEdgeInterruptEnable = (LPUART_BAUD_RXEDGIE_MASK >> 8) , kLPUART_TxDataRegEmptyInterruptEnable = (LPUART_CTRL_TIE_MASK) , kLPUART_TransmissionCompleteInterruptEnable = (LPUART_CTRL_TCIE_MASK) ,   kLPUART_RxDataRegFullInterruptEnable = (LPUART_CTRL_RIE_MASK) , kLPUART_IdleLineInterruptEnable = (LPUART_CTRL_ILIE_MASK) , kLPUART_RxOverrunInterruptEnable = (LPUART_CTRL_ORIE_MASK) , kLPUART_NoiseErrorInterruptEnable = (LPUART_CTRL_NEIE_MASK) ,   kLPUART_FramingErrorInterruptEnable = (LPUART_CTRL_FEIE_MASK) , kLPUART_ParityErrorInterruptEnable = (LPUART_CTRL_PEIE_MASK) , kLPUART_TxFifoOverflowInterruptEnable = (LPUART_FIFO_TXOFE_MASK >> 8) , kLPUART_RxFifoUnderflowInterruptEnable = (LPUART_FIFO_RXUFE_MASK >> 8) }
	LPUART interrupt configuration structure, default settings all disabled. More...
enum	_lpuart_flags {   kLPUART_TxDataRegEmptyFlag , kLPUART_TransmissionCompleteFlag , kLPUART_RxDataRegFullFlag , kLPUART_IdleLineFlag = (LPUART_STAT_IDLE_MASK) ,   kLPUART_RxOverrunFlag = (LPUART_STAT_OR_MASK) , kLPUART_NoiseErrorFlag = (LPUART_STAT_NF_MASK) , kLPUART_FramingErrorFlag , kLPUART_ParityErrorFlag = (LPUART_STAT_PF_MASK) ,   kLPUART_LinBreakFlag , kLPUART_RxActiveEdgeFlag , kLPUART_RxActiveFlag , kLPUART_DataMatch1Flag = LPUART_STAT_MA1F_MASK ,   kLPUART_DataMatch2Flag = LPUART_STAT_MA2F_MASK , kLPUART_NoiseErrorInRxDataRegFlag , kLPUART_ParityErrorInRxDataRegFlag , kLPUART_TxFifoEmptyFlag = (LPUART_FIFO_TXEMPT_MASK >> 16) ,   kLPUART_RxFifoEmptyFlag = (LPUART_FIFO_RXEMPT_MASK >> 16) , kLPUART_TxFifoOverflowFlag , kLPUART_RxFifoUnderflowFlag }
	LPUART status flags. More...
typedef enum _lpuart_parity_mode	lpuart_parity_mode_t
	LPUART parity mode.
typedef enum _lpuart_data_bits	lpuart_data_bits_t
	LPUART data bits count.
typedef enum _lpuart_stop_bit_count	lpuart_stop_bit_count_t
	LPUART stop bit count.
typedef enum _lpuart_transmit_cts_source	lpuart_transmit_cts_source_t
	LPUART transmit CTS source.
typedef enum _lpuart_transmit_cts_config	lpuart_transmit_cts_config_t
	LPUART transmit CTS configure.
typedef enum _lpuart_idle_type_select	lpuart_idle_type_select_t
	LPUART idle flag type defines when the receiver starts counting.
typedef enum _lpuart_idle_config	lpuart_idle_config_t
	LPUART idle detected configuration. This structure defines the number of idle characters that must be received before the IDLE flag is set.
typedef struct _lpuart_config	lpuart_config_t
	LPUART configuration structure.
typedef struct _lpuart_transfer	lpuart_transfer_t
	LPUART transfer structure.
typedef struct _lpuart_handle	lpuart_handle_t
typedef void(*	lpuart_transfer_callback_t) (LPUART_Type *base, lpuart_handle_t *handle, status_t status, void *userData)
	LPUART transfer callback function.

Software Reset
static void	LPUART_SoftwareReset (LPUART_Type *base)
	Resets the LPUART using software.

Initialization and deinitialization
status_t	LPUART_Init (LPUART_Type *base, const lpuart_config_t *config, uint32_t srcClock_Hz)
	Initializes an LPUART instance with the user configuration structure and the peripheral clock.
void	LPUART_Deinit (LPUART_Type *base)
	Deinitializes a LPUART instance.
void	LPUART_GetDefaultConfig (lpuart_config_t *config)
	Gets the default configuration structure.
status_t	LPUART_SetBaudRate (LPUART_Type *base, uint32_t baudRate_Bps, uint32_t srcClock_Hz)
	Sets the LPUART instance baudrate.

Status
uint32_t	LPUART_GetStatusFlags (LPUART_Type *base)
	Gets LPUART status flags.
status_t	LPUART_ClearStatusFlags (LPUART_Type *base, uint32_t mask)
	Clears status flags with a provided mask.

Interrupts
void	LPUART_EnableInterrupts (LPUART_Type *base, uint32_t mask)
	Enables LPUART interrupts according to a provided mask.
void	LPUART_DisableInterrupts (LPUART_Type *base, uint32_t mask)
	Disables LPUART interrupts according to a provided mask.
uint32_t	LPUART_GetEnabledInterrupts (LPUART_Type *base)
	Gets enabled LPUART interrupts.
static uint32_t	LPUART_GetDataRegisterAddress (LPUART_Type *base)
	Gets the LPUART data register address.
static void	LPUART_EnableTxDMA (LPUART_Type *base, bool enable)
	Enables or disables the LPUART transmitter DMA request.
static void	LPUART_EnableRxDMA (LPUART_Type *base, bool enable)
	Enables or disables the LPUART receiver DMA.

Bus Operations
uint32_t	LPUART_GetInstance (LPUART_Type *base)
	Get the LPUART instance from peripheral base address.
static void	LPUART_EnableTx (LPUART_Type *base, bool enable)
	Enables or disables the LPUART transmitter.
static void	LPUART_EnableRx (LPUART_Type *base, bool enable)
	Enables or disables the LPUART receiver.
static void	LPUART_WriteByte (LPUART_Type *base, uint8_t data)
	Writes to the transmitter register.
static uint8_t	LPUART_ReadByte (LPUART_Type *base)
	Reads the receiver register.
void	LPUART_WriteBlocking (LPUART_Type *base, const uint8_t *data, size_t length)
	Writes to the transmitter register using a blocking method.
status_t	LPUART_ReadBlocking (LPUART_Type *base, uint8_t *data, size_t length)
	Reads the receiver data register using a blocking method.

Transactional
void	LPUART_TransferCreateHandle (LPUART_Type *base, lpuart_handle_t *handle, lpuart_transfer_callback_t callback, void *userData)
	Initializes the LPUART handle.
status_t	LPUART_TransferSendNonBlocking (LPUART_Type *base, lpuart_handle_t *handle, lpuart_transfer_t *xfer)
	Transmits a buffer of data using the interrupt method.
void	LPUART_TransferStartRingBuffer (LPUART_Type *base, lpuart_handle_t *handle, uint8_t *ringBuffer, size_t ringBufferSize)
	Sets up the RX ring buffer.
void	LPUART_TransferStopRingBuffer (LPUART_Type *base, lpuart_handle_t *handle)
	Aborts the background transfer and uninstalls the ring buffer.
size_t	LPUART_TransferGetRxRingBufferLength (LPUART_Type *base, lpuart_handle_t *handle)
	Get the length of received data in RX ring buffer.
void	LPUART_TransferAbortSend (LPUART_Type *base, lpuart_handle_t *handle)
	Aborts the interrupt-driven data transmit.
status_t	LPUART_TransferGetSendCount (LPUART_Type *base, lpuart_handle_t *handle, uint32_t *count)
	Gets the number of bytes that have been written to the LPUART transmitter register.
status_t	LPUART_TransferReceiveNonBlocking (LPUART_Type *base, lpuart_handle_t *handle, lpuart_transfer_t *xfer, size_t *receivedBytes)
	Receives a buffer of data using the interrupt method.
void	LPUART_TransferAbortReceive (LPUART_Type *base, lpuart_handle_t *handle)
	Aborts the interrupt-driven data receiving.
status_t	LPUART_TransferGetReceiveCount (LPUART_Type *base, lpuart_handle_t *handle, uint32_t *count)
	Gets the number of bytes that have been received.
void	LPUART_TransferHandleIRQ (LPUART_Type *base, lpuart_handle_t *handle)
	LPUART IRQ handle function.
void	LPUART_TransferHandleErrorIRQ (LPUART_Type *base, lpuart_handle_t *handle)
	LPUART Error IRQ handle function.

Detailed Description

Typedef Documentation

lpuart_config_t

typedef struct _lpuart_config lpuart_config_t

LPUART configuration structure.

lpuart_data_bits_t

typedef enum _lpuart_data_bits lpuart_data_bits_t

LPUART data bits count.

lpuart_handle_t

typedef struct _lpuart_handle lpuart_handle_t

Definition at line 222 of file fsl_lpuart.h.

lpuart_idle_config_t

typedef enum _lpuart_idle_config lpuart_idle_config_t

LPUART idle detected configuration. This structure defines the number of idle characters that must be received before the IDLE flag is set.

lpuart_idle_type_select_t

typedef enum _lpuart_idle_type_select lpuart_idle_type_select_t

LPUART idle flag type defines when the receiver starts counting.

lpuart_parity_mode_t

typedef enum _lpuart_parity_mode lpuart_parity_mode_t

LPUART parity mode.

lpuart_stop_bit_count_t

typedef enum _lpuart_stop_bit_count lpuart_stop_bit_count_t

LPUART stop bit count.

lpuart_transfer_callback_t

typedef void(* lpuart_transfer_callback_t) (LPUART_Type *base, lpuart_handle_t *handle, status_t status, void *userData)

LPUART transfer callback function.

Definition at line 225 of file fsl_lpuart.h.

lpuart_transfer_t

typedef struct _lpuart_transfer lpuart_transfer_t

LPUART transfer structure.

lpuart_transmit_cts_config_t

typedef enum _lpuart_transmit_cts_config lpuart_transmit_cts_config_t

LPUART transmit CTS configure.

lpuart_transmit_cts_source_t

typedef enum _lpuart_transmit_cts_source lpuart_transmit_cts_source_t

LPUART transmit CTS source.

Enumeration Type Documentation

_lpuart_data_bits

enum _lpuart_data_bits

LPUART data bits count.

Enumerator
kLPUART_EightDataBits	Eight data bit
kLPUART_SevenDataBits	Seven data bit

Definition at line 59 of file fsl_lpuart.h.

{
    kLPUART_EightDataBits = 0x0U, /*!< Eight data bit */
#if defined(FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT) && FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT
    kLPUART_SevenDataBits = 0x1U, /*!< Seven data bit */
#endif
} lpuart_data_bits_t;

_lpuart_flags

enum _lpuart_flags

LPUART status flags.

This provides constants for the LPUART status flags for use in the LPUART functions.

Enumerator
kLPUART_TxDataRegEmptyFlag	Transmit data register empty flag, sets when transmit buffer is empty
kLPUART_TransmissionCompleteFlag	Transmission complete flag, sets when transmission activity complete
kLPUART_RxDataRegFullFlag	Receive data register full flag, sets when the receive data buffer is full
kLPUART_IdleLineFlag	Idle line detect flag, sets when idle line detected
kLPUART_RxOverrunFlag	Receive Overrun, sets when new data is received before data is read from receive register
kLPUART_NoiseErrorFlag	Receive takes 3 samples of each received bit. If any of these samples differ, noise flag sets
kLPUART_FramingErrorFlag	Frame error flag, sets if logic 0 was detected where stop bit expected
kLPUART_ParityErrorFlag	If parity enabled, sets upon parity error detection
kLPUART_LinBreakFlag	LIN break detect interrupt flag, sets when LIN break char detected and LIN circuit enabled
kLPUART_RxActiveEdgeFlag	Receive pin active edge interrupt flag, sets when active edge detected
kLPUART_RxActiveFlag	Receiver Active Flag (RAF), sets at beginning of valid start bit
kLPUART_DataMatch1Flag	The next character to be read from LPUART_DATA matches MA1
kLPUART_DataMatch2Flag	The next character to be read from LPUART_DATA matches MA2
kLPUART_NoiseErrorInRxDataRegFlag	NOISY bit, sets if noise detected in current data word
kLPUART_ParityErrorInRxDataRegFlag	PARITYE bit, sets if noise detected in current data word
kLPUART_TxFifoEmptyFlag	TXEMPT bit, sets if transmit buffer is empty
kLPUART_RxFifoEmptyFlag	RXEMPT bit, sets if receive buffer is empty
kLPUART_TxFifoOverflowFlag	TXOF bit, sets if transmit buffer overflow occurred
kLPUART_RxFifoUnderflowFlag	RXUF bit, sets if receive buffer underflow occurred

Definition at line 143 of file fsl_lpuart.h.

{
    kLPUART_TxDataRegEmptyFlag =
        (LPUART_STAT_TDRE_MASK), /*!< Transmit data register empty flag, sets when transmit buffer is empty */
    kLPUART_TransmissionCompleteFlag =
        (LPUART_STAT_TC_MASK), /*!< Transmission complete flag, sets when transmission activity complete */
    kLPUART_RxDataRegFullFlag =
        (LPUART_STAT_RDRF_MASK), /*!< Receive data register full flag, sets when the receive data buffer is full */
    kLPUART_IdleLineFlag = (LPUART_STAT_IDLE_MASK), /*!< Idle line detect flag, sets when idle line detected */
    kLPUART_RxOverrunFlag = (LPUART_STAT_OR_MASK),  /*!< Receive Overrun, sets when new data is received before data is
                                                       read from receive register */
    kLPUART_NoiseErrorFlag = (LPUART_STAT_NF_MASK), /*!< Receive takes 3 samples of each received bit.  If any of these
                                                       samples differ, noise flag sets */
    kLPUART_FramingErrorFlag =
        (LPUART_STAT_FE_MASK), /*!< Frame error flag, sets if logic 0 was detected where stop bit expected */
    kLPUART_ParityErrorFlag = (LPUART_STAT_PF_MASK), /*!< If parity enabled, sets upon parity error detection */
#if defined(FSL_FEATURE_LPUART_HAS_LIN_BREAK_DETECT) && FSL_FEATURE_LPUART_HAS_LIN_BREAK_DETECT
    kLPUART_LinBreakFlag =
        (int)(LPUART_STAT_LBKDIF_MASK), /*!< LIN break detect interrupt flag, sets when LIN break char
                                      detected and LIN circuit enabled */
#endif
    kLPUART_RxActiveEdgeFlag =
        (LPUART_STAT_RXEDGIF_MASK), /*!< Receive pin active edge interrupt flag, sets when active edge detected */
    kLPUART_RxActiveFlag =
        (LPUART_STAT_RAF_MASK), /*!< Receiver Active Flag (RAF), sets at beginning of valid start bit */
#if defined(FSL_FEATURE_LPUART_HAS_ADDRESS_MATCHING) && FSL_FEATURE_LPUART_HAS_ADDRESS_MATCHING
    kLPUART_DataMatch1Flag = LPUART_STAT_MA1F_MASK, /*!< The next character to be read from LPUART_DATA matches MA1*/
    kLPUART_DataMatch2Flag = LPUART_STAT_MA2F_MASK, /*!< The next character to be read from LPUART_DATA matches MA2*/
#endif
#if defined(FSL_FEATURE_LPUART_HAS_EXTENDED_DATA_REGISTER_FLAGS) && FSL_FEATURE_LPUART_HAS_EXTENDED_DATA_REGISTER_FLAGS
    kLPUART_NoiseErrorInRxDataRegFlag =
        (LPUART_DATA_NOISY_MASK >> 10), /*!< NOISY bit, sets if noise detected in current data word */
    kLPUART_ParityErrorInRxDataRegFlag =
        (LPUART_DATA_PARITYE_MASK >> 10), /*!< PARITYE bit, sets if noise detected in current data word */
#endif
#if defined(FSL_FEATURE_LPUART_HAS_FIFO) && FSL_FEATURE_LPUART_HAS_FIFO
    kLPUART_TxFifoEmptyFlag = (LPUART_FIFO_TXEMPT_MASK >> 16), /*!< TXEMPT bit, sets if transmit buffer is empty */
    kLPUART_RxFifoEmptyFlag = (LPUART_FIFO_RXEMPT_MASK >> 16), /*!< RXEMPT bit, sets if receive buffer is empty */
    kLPUART_TxFifoOverflowFlag =
        (LPUART_FIFO_TXOF_MASK >> 16), /*!< TXOF bit, sets if transmit buffer overflow occurred */
    kLPUART_RxFifoUnderflowFlag =
        (LPUART_FIFO_RXUF_MASK >> 16), /*!< RXUF bit, sets if receive buffer underflow occurred */
#endif
};

_lpuart_idle_config

enum _lpuart_idle_config

LPUART idle detected configuration. This structure defines the number of idle characters that must be received before the IDLE flag is set.

Enumerator
kLPUART_IdleCharacter1	the number of idle characters.
kLPUART_IdleCharacter2	the number of idle characters.
kLPUART_IdleCharacter4	the number of idle characters.
kLPUART_IdleCharacter8	the number of idle characters.
kLPUART_IdleCharacter16	the number of idle characters.
kLPUART_IdleCharacter32	the number of idle characters.
kLPUART_IdleCharacter64	the number of idle characters.
kLPUART_IdleCharacter128	the number of idle characters.

Definition at line 101 of file fsl_lpuart.h.

{
    kLPUART_IdleCharacter1 = 0U,   /*!< the number of idle characters. */
    kLPUART_IdleCharacter2 = 1U,   /*!< the number of idle characters. */
    kLPUART_IdleCharacter4 = 2U,   /*!< the number of idle characters. */
    kLPUART_IdleCharacter8 = 3U,   /*!< the number of idle characters. */
    kLPUART_IdleCharacter16 = 4U,  /*!< the number of idle characters. */
    kLPUART_IdleCharacter32 = 5U,  /*!< the number of idle characters. */
    kLPUART_IdleCharacter64 = 6U,  /*!< the number of idle characters. */
    kLPUART_IdleCharacter128 = 7U, /*!< the number of idle characters. */
} lpuart_idle_config_t;

_lpuart_idle_type_select

enum _lpuart_idle_type_select

LPUART idle flag type defines when the receiver starts counting.

Enumerator
kLPUART_IdleTypeStartBit	Start counting after a valid start bit.
kLPUART_IdleTypeStopBit	Start counting after a stop bit.

Definition at line 91 of file fsl_lpuart.h.

{
    kLPUART_IdleTypeStartBit = 0U, /*!< Start counting after a valid start bit. */
    kLPUART_IdleTypeStopBit = 1U,  /*!< Start counting after a stop bit. */
} lpuart_idle_type_select_t;

_lpuart_interrupt_enable

enum _lpuart_interrupt_enable

LPUART interrupt configuration structure, default settings all disabled.

This structure contains the settings for all LPUART interrupt configurations.

Enumerator
kLPUART_LinBreakInterruptEnable	LIN break detect.
kLPUART_RxActiveEdgeInterruptEnable	Receive Active Edge.
kLPUART_TxDataRegEmptyInterruptEnable	Transmit data register empty.
kLPUART_TransmissionCompleteInterruptEnable	Transmission complete.
kLPUART_RxDataRegFullInterruptEnable	Receiver data register full.
kLPUART_IdleLineInterruptEnable	Idle line.
kLPUART_RxOverrunInterruptEnable	Receiver Overrun.
kLPUART_NoiseErrorInterruptEnable	Noise error flag.
kLPUART_FramingErrorInterruptEnable	Framing error flag.
kLPUART_ParityErrorInterruptEnable	Parity error flag.
kLPUART_TxFifoOverflowInterruptEnable	Transmit FIFO Overflow.
kLPUART_RxFifoUnderflowInterruptEnable	Receive FIFO Underflow.

Definition at line 118 of file fsl_lpuart.h.

{
#if defined(FSL_FEATURE_LPUART_HAS_LIN_BREAK_DETECT) && FSL_FEATURE_LPUART_HAS_LIN_BREAK_DETECT
    kLPUART_LinBreakInterruptEnable = (LPUART_BAUD_LBKDIE_MASK >> 8), /*!< LIN break detect. */
#endif
    kLPUART_RxActiveEdgeInterruptEnable = (LPUART_BAUD_RXEDGIE_MASK >> 8), /*!< Receive Active Edge. */
    kLPUART_TxDataRegEmptyInterruptEnable = (LPUART_CTRL_TIE_MASK),        /*!< Transmit data register empty. */
    kLPUART_TransmissionCompleteInterruptEnable = (LPUART_CTRL_TCIE_MASK), /*!< Transmission complete. */
    kLPUART_RxDataRegFullInterruptEnable = (LPUART_CTRL_RIE_MASK),         /*!< Receiver data register full. */
    kLPUART_IdleLineInterruptEnable = (LPUART_CTRL_ILIE_MASK),             /*!< Idle line. */
    kLPUART_RxOverrunInterruptEnable = (LPUART_CTRL_ORIE_MASK),            /*!< Receiver Overrun. */
    kLPUART_NoiseErrorInterruptEnable = (LPUART_CTRL_NEIE_MASK),           /*!< Noise error flag. */
    kLPUART_FramingErrorInterruptEnable = (LPUART_CTRL_FEIE_MASK),         /*!< Framing error flag. */
    kLPUART_ParityErrorInterruptEnable = (LPUART_CTRL_PEIE_MASK),          /*!< Parity error flag. */
#if defined(FSL_FEATURE_LPUART_HAS_FIFO) && FSL_FEATURE_LPUART_HAS_FIFO
    kLPUART_TxFifoOverflowInterruptEnable = (LPUART_FIFO_TXOFE_MASK >> 8),  /*!< Transmit FIFO Overflow. */
    kLPUART_RxFifoUnderflowInterruptEnable = (LPUART_FIFO_RXUFE_MASK >> 8), /*!< Receive FIFO Underflow. */
#endif
};

_lpuart_parity_mode

enum _lpuart_parity_mode

LPUART parity mode.

Enumerator
kLPUART_ParityDisabled	Parity disabled
kLPUART_ParityEven	Parity enabled, type even, bit setting: PE|PT = 10
kLPUART_ParityOdd	Parity enabled, type odd, bit setting: PE|PT = 11

Definition at line 51 of file fsl_lpuart.h.

{
    kLPUART_ParityDisabled = 0x0U, /*!< Parity disabled */
    kLPUART_ParityEven = 0x2U,     /*!< Parity enabled, type even, bit setting: PE|PT = 10 */
    kLPUART_ParityOdd = 0x3U,      /*!< Parity enabled, type odd,  bit setting: PE|PT = 11 */
} lpuart_parity_mode_t;

_lpuart_status

enum _lpuart_status

Error codes for the LPUART driver.

Enumerator
kStatus_LPUART_TxBusy	TX busy
kStatus_LPUART_RxBusy	RX busy
kStatus_LPUART_TxIdle	LPUART transmitter is idle.
kStatus_LPUART_RxIdle	LPUART receiver is idle.
kStatus_LPUART_TxWatermarkTooLarge	TX FIFO watermark too large
kStatus_LPUART_RxWatermarkTooLarge	RX FIFO watermark too large
kStatus_LPUART_FlagCannotClearManually	Some flag can't manually clear
kStatus_LPUART_Error	Error happens on LPUART.
kStatus_LPUART_RxRingBufferOverrun	LPUART RX software ring buffer overrun.
kStatus_LPUART_RxHardwareOverrun	LPUART RX receiver overrun.
kStatus_LPUART_NoiseError	LPUART noise error.
kStatus_LPUART_FramingError	LPUART framing error.
kStatus_LPUART_ParityError	LPUART parity error.
kStatus_LPUART_BaudrateNotSupport	Baudrate is not support in current clock source
kStatus_LPUART_IdleLineDetected	IDLE flag.

Definition at line 29 of file fsl_lpuart.h.

{
    kStatus_LPUART_TxBusy = MAKE_STATUS(kStatusGroup_LPUART, 0),                  /*!< TX busy */
    kStatus_LPUART_RxBusy = MAKE_STATUS(kStatusGroup_LPUART, 1),                  /*!< RX busy */
    kStatus_LPUART_TxIdle = MAKE_STATUS(kStatusGroup_LPUART, 2),                  /*!< LPUART transmitter is idle. */
    kStatus_LPUART_RxIdle = MAKE_STATUS(kStatusGroup_LPUART, 3),                  /*!< LPUART receiver is idle. */
    kStatus_LPUART_TxWatermarkTooLarge = MAKE_STATUS(kStatusGroup_LPUART, 4),     /*!< TX FIFO watermark too large  */
    kStatus_LPUART_RxWatermarkTooLarge = MAKE_STATUS(kStatusGroup_LPUART, 5),     /*!< RX FIFO watermark too large  */
    kStatus_LPUART_FlagCannotClearManually = MAKE_STATUS(kStatusGroup_LPUART, 6), /*!< Some flag can't manually clear */
    kStatus_LPUART_Error = MAKE_STATUS(kStatusGroup_LPUART, 7),                   /*!< Error happens on LPUART. */
    kStatus_LPUART_RxRingBufferOverrun =
        MAKE_STATUS(kStatusGroup_LPUART, 8), /*!< LPUART RX software ring buffer overrun. */
    kStatus_LPUART_RxHardwareOverrun = MAKE_STATUS(kStatusGroup_LPUART, 9), /*!< LPUART RX receiver overrun. */
    kStatus_LPUART_NoiseError = MAKE_STATUS(kStatusGroup_LPUART, 10),       /*!< LPUART noise error. */
    kStatus_LPUART_FramingError = MAKE_STATUS(kStatusGroup_LPUART, 11),     /*!< LPUART framing error. */
    kStatus_LPUART_ParityError = MAKE_STATUS(kStatusGroup_LPUART, 12),      /*!< LPUART parity error. */
    kStatus_LPUART_BaudrateNotSupport =
        MAKE_STATUS(kStatusGroup_LPUART, 13), /*!< Baudrate is not support in current clock source */
    kStatus_LPUART_IdleLineDetected = MAKE_STATUS(kStatusGroup_LPUART, 14), /*!< IDLE flag. */
};

_lpuart_stop_bit_count

enum _lpuart_stop_bit_count

LPUART stop bit count.

Enumerator
kLPUART_OneStopBit	One stop bit
kLPUART_TwoStopBit	Two stop bits

Definition at line 68 of file fsl_lpuart.h.

{
    kLPUART_OneStopBit = 0U, /*!< One stop bit */
    kLPUART_TwoStopBit = 1U, /*!< Two stop bits */
} lpuart_stop_bit_count_t;

_lpuart_transmit_cts_config

enum _lpuart_transmit_cts_config

LPUART transmit CTS configure.

Enumerator
kLPUART_CtsSampleAtStart	CTS input is sampled at the start of each character.
kLPUART_CtsSampleAtIdle	CTS input is sampled when the transmitter is idle

Definition at line 83 of file fsl_lpuart.h.

{
    kLPUART_CtsSampleAtStart = 0U, /*!< CTS input is sampled at the start of each character. */
    kLPUART_CtsSampleAtIdle = 1U,  /*!< CTS input is sampled when the transmitter is idle */
} lpuart_transmit_cts_config_t;

_lpuart_transmit_cts_source

enum _lpuart_transmit_cts_source

LPUART transmit CTS source.

Enumerator
kLPUART_CtsSourcePin	CTS resource is the LPUART_CTS pin.
kLPUART_CtsSourceMatchResult	CTS resource is the match result.

Definition at line 76 of file fsl_lpuart.h.

{
    kLPUART_CtsSourcePin = 0U,         /*!< CTS resource is the LPUART_CTS pin. */
    kLPUART_CtsSourceMatchResult = 1U, /*!< CTS resource is the match result. */
} lpuart_transmit_cts_source_t;

Function Documentation

LPUART_ClearStatusFlags()

status_t LPUART_ClearStatusFlags	(	LPUART_Type *	base,
		uint32_t	mask
	)

Clears status flags with a provided mask.

This function clears LPUART status flags with a provided mask. Automatically cleared flags can't be cleared by this function. Flags that can only cleared or set by hardware are: kLPUART_TxDataRegEmptyFlag, kLPUART_TransmissionCompleteFlag, kLPUART_RxDataRegFullFlag, kLPUART_RxActiveFlag, kLPUART_NoiseErrorInRxDataRegFlag, kLPUART_ParityErrorInRxDataRegFlag, kLPUART_TxFifoEmptyFlag,kLPUART_RxFifoEmptyFlag Note: This API should be called when the Tx/Rx is idle, otherwise it takes no effects.

Parameters

base	LPUART peripheral base address.
mask	the status flags to be cleared. The user can use the enumerators in the _lpuart_status_flag_t to do the OR operation and get the mask.

Returns

0 succeed, others failed.

Return values

kStatus_LPUART_FlagCannotClearManually	The flag can't be cleared by this function but it is cleared automatically by hardware.
kStatus_Success	Status in the mask are cleared.

brief Clears status flags with a provided mask.

This function clears LPUART status flags with a provided mask. Automatically cleared flags can't be cleared by this function. Flags that can only cleared or set by hardware are: kLPUART_TxDataRegEmptyFlag, kLPUART_TransmissionCompleteFlag, kLPUART_RxDataRegFullFlag, kLPUART_RxActiveFlag, kLPUART_NoiseErrorInRxDataRegFlag, kLPUART_ParityErrorInRxDataRegFlag, kLPUART_TxFifoEmptyFlag,kLPUART_RxFifoEmptyFlag Note: This API should be called when the Tx/Rx is idle, otherwise it takes no effects.

param base LPUART peripheral base address. param mask the status flags to be cleared. The user can use the enumerators in the _lpuart_status_flag_t to do the OR operation and get the mask. return 0 succeed, others failed. retval kStatus_LPUART_FlagCannotClearManually The flag can't be cleared by this function but it is cleared automatically by hardware. retval kStatus_Success Status in the mask are cleared.

Definition at line 777 of file fsl_lpuart.c.

{
    uint32_t temp;
    status_t status;
#if defined(FSL_FEATURE_LPUART_HAS_FIFO) && FSL_FEATURE_LPUART_HAS_FIFO
    temp = (uint32_t)base->FIFO;
    temp &= (uint32_t)(~(LPUART_FIFO_TXOF_MASK | LPUART_FIFO_RXUF_MASK));
    temp |= (mask << 16) & (LPUART_FIFO_TXOF_MASK | LPUART_FIFO_RXUF_MASK);
    base->FIFO = temp;
#endif
    temp = (uint32_t)base->STAT;
#if defined(FSL_FEATURE_LPUART_HAS_LIN_BREAK_DETECT) && FSL_FEATURE_LPUART_HAS_LIN_BREAK_DETECT
    temp &= (uint32_t)(~(LPUART_STAT_LBKDIF_MASK));
    temp |= mask & LPUART_STAT_LBKDIF_MASK;
#endif
    temp &= (uint32_t)(~(LPUART_STAT_RXEDGIF_MASK | LPUART_STAT_IDLE_MASK | LPUART_STAT_OR_MASK | LPUART_STAT_NF_MASK |
                         LPUART_STAT_FE_MASK | LPUART_STAT_PF_MASK));
    temp |= mask & (LPUART_STAT_RXEDGIF_MASK | LPUART_STAT_IDLE_MASK | LPUART_STAT_OR_MASK | LPUART_STAT_NF_MASK |
                    LPUART_STAT_FE_MASK | LPUART_STAT_PF_MASK);
#if defined(FSL_FEATURE_LPUART_HAS_ADDRESS_MATCHING) && FSL_FEATURE_LPUART_HAS_ADDRESS_MATCHING
    temp &= (uint32_t)(~(LPUART_STAT_MA2F_MASK | LPUART_STAT_MA1F_MASK));
    temp |= mask & (LPUART_STAT_MA2F_MASK | LPUART_STAT_MA1F_MASK);
#endif
    base->STAT = temp;
    /* If some flags still pending. */
    if (mask & LPUART_GetStatusFlags(base))
    {
        /* Some flags can only clear or set by the hardware itself, these flags are: kLPUART_TxDataRegEmptyFlag,
        kLPUART_TransmissionCompleteFlag, kLPUART_RxDataRegFullFlag, kLPUART_RxActiveFlag,
        kLPUART_NoiseErrorInRxDataRegFlag, kLPUART_ParityErrorInRxDataRegFlag,
        kLPUART_TxFifoEmptyFlag, kLPUART_RxFifoEmptyFlag. */
        status = kStatus_LPUART_FlagCannotClearManually; /* flags can not clear manually */
    }
    else
    {
        status = kStatus_Success;
    }
 
    return status;
}

Referenced by LPUART_ReadBlocking().

Here is the call graph for this function:

Here is the caller graph for this function:

LPUART_Deinit()

void LPUART_Deinit

(

LPUART_Type *

base

)

Deinitializes a LPUART instance.

This function waits for transmit to complete, disables TX and RX, and disables the LPUART clock.

Parameters

base	LPUART peripheral base address.

brief Deinitializes a LPUART instance.

This function waits for transmit to complete, disables TX and RX, and disables the LPUART clock.

param base LPUART peripheral base address.

Definition at line 455 of file fsl_lpuart.c.

{
    uint32_t temp;
 
#if defined(FSL_FEATURE_LPUART_HAS_FIFO) && FSL_FEATURE_LPUART_HAS_FIFO
    /* Wait tx FIFO send out*/
    while (0 != ((base->WATER & LPUART_WATER_TXCOUNT_MASK) >> LPUART_WATER_TXWATER_SHIFT))
    {
    }
#endif
    /* Wait last char shift out */
    while (0 == (base->STAT & LPUART_STAT_TC_MASK))
    {
    }
 
    /* Clear all status flags */
    temp = (LPUART_STAT_RXEDGIF_MASK | LPUART_STAT_IDLE_MASK | LPUART_STAT_OR_MASK | LPUART_STAT_NF_MASK |
            LPUART_STAT_FE_MASK | LPUART_STAT_PF_MASK);
 
#if defined(FSL_FEATURE_LPUART_HAS_LIN_BREAK_DETECT) && FSL_FEATURE_LPUART_HAS_LIN_BREAK_DETECT
    temp |= LPUART_STAT_LBKDIF_MASK;
#endif
 
#if defined(FSL_FEATURE_LPUART_HAS_ADDRESS_MATCHING) && FSL_FEATURE_LPUART_HAS_ADDRESS_MATCHING
    temp |= (LPUART_STAT_MA1F_MASK | LPUART_STAT_MA2F_MASK);
#endif
 
    base->STAT |= temp;
 
    /* Disable the module. */
    base->CTRL = 0;
 
#if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL)
    uint32_t instance = LPUART_GetInstance(base);
 
    /* Disable lpuart clock */
    CLOCK_DisableClock(s_lpuartClock[instance]);
 
#if defined(LPUART_PERIPH_CLOCKS)
    CLOCK_DisableClock(s_lpuartPeriphClocks[instance]);
#endif
 
#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */
}

Referenced by uart_lld_stop().

Here is the call graph for this function:

Here is the caller graph for this function:

LPUART_DisableInterrupts()

void LPUART_DisableInterrupts	(	LPUART_Type *	base,
		uint32_t	mask
	)

Disables LPUART interrupts according to a provided mask.

This function disables the LPUART interrupts according to a provided mask. The mask is a logical OR of enumeration members. See _lpuart_interrupt_enable. This example shows how to disable the TX empty interrupt and RX full interrupt:

LPUART_DisableInterrupts(LPUART1,kLPUART_TxDataRegEmptyInterruptEnable | kLPUART_RxDataRegFullInterruptEnable);

Parameters

base	LPUART peripheral base address.
mask	The interrupts to disable. Logical OR of _lpuart_interrupt_enable.

brief Disables LPUART interrupts according to a provided mask.

This function disables the LPUART interrupts according to a provided mask. The mask is a logical OR of enumeration members. See ref _lpuart_interrupt_enable. This example shows how to disable the TX empty interrupt and RX full interrupt: code LPUART_DisableInterrupts(LPUART1,kLPUART_TxDataRegEmptyInterruptEnable | kLPUART_RxDataRegFullInterruptEnable); endcode

param base LPUART peripheral base address. param mask The interrupts to disable. Logical OR of ref _lpuart_interrupt_enable.

Definition at line 686 of file fsl_lpuart.c.

{
    base->BAUD &= ~((mask << 8) & (LPUART_BAUD_LBKDIE_MASK | LPUART_BAUD_RXEDGIE_MASK));
#if defined(FSL_FEATURE_LPUART_HAS_FIFO) && FSL_FEATURE_LPUART_HAS_FIFO
    base->FIFO = (base->FIFO & ~(LPUART_FIFO_TXOF_MASK | LPUART_FIFO_RXUF_MASK)) &
                 ~((mask << 8) & (LPUART_FIFO_TXOFE_MASK | LPUART_FIFO_RXUFE_MASK));
#endif
    mask &= 0xFFFFFF00U;
    base->CTRL &= ~mask;
}

Referenced by LPUART_TransferAbortReceive(), LPUART_TransferAbortSend(), LPUART_TransferHandleIRQ(), LPUART_TransferReceiveNonBlocking(), and LPUART_TransferStopRingBuffer().

Here is the caller graph for this function:

LPUART_EnableInterrupts()

void LPUART_EnableInterrupts	(	LPUART_Type *	base,
		uint32_t	mask
	)

Enables LPUART interrupts according to a provided mask.

This function enables the LPUART interrupts according to a provided mask. The mask is a logical OR of enumeration members. See the _lpuart_interrupt_enable. This examples shows how to enable TX empty interrupt and RX full interrupt:

LPUART_EnableInterrupts(LPUART1,kLPUART_TxDataRegEmptyInterruptEnable | kLPUART_RxDataRegFullInterruptEnable);

Parameters

base	LPUART peripheral base address.
mask	The interrupts to enable. Logical OR of _uart_interrupt_enable.

brief Enables LPUART interrupts according to a provided mask.

This function enables the LPUART interrupts according to a provided mask. The mask is a logical OR of enumeration members. See the ref _lpuart_interrupt_enable. This examples shows how to enable TX empty interrupt and RX full interrupt: code LPUART_EnableInterrupts(LPUART1,kLPUART_TxDataRegEmptyInterruptEnable | kLPUART_RxDataRegFullInterruptEnable); endcode

param base LPUART peripheral base address. param mask The interrupts to enable. Logical OR of ref _uart_interrupt_enable.

Definition at line 662 of file fsl_lpuart.c.

{
    base->BAUD |= ((mask << 8) & (LPUART_BAUD_LBKDIE_MASK | LPUART_BAUD_RXEDGIE_MASK));
#if defined(FSL_FEATURE_LPUART_HAS_FIFO) && FSL_FEATURE_LPUART_HAS_FIFO
    base->FIFO = (base->FIFO & ~(LPUART_FIFO_TXOF_MASK | LPUART_FIFO_RXUF_MASK)) |
                 ((mask << 8) & (LPUART_FIFO_TXOFE_MASK | LPUART_FIFO_RXUFE_MASK));
#endif
    mask &= 0xFFFFFF00U;
    base->CTRL |= mask;
}

Referenced by LPUART_TransferReceiveNonBlocking(), LPUART_TransferSendNonBlocking(), LPUART_TransferStartRingBuffer(), and uart_lld_start_receive().

Here is the caller graph for this function:

LPUART_EnableRx()

static void LPUART_EnableRx ( LPUART_Type *  base, bool  enable  )

inlinestatic

Enables or disables the LPUART receiver.

This function enables or disables the LPUART receiver.

Parameters

base	LPUART peripheral base address.
enable	True to enable, false to disable.

Definition at line 566 of file fsl_lpuart.h.

{
    if (enable)
    {
        base->CTRL |= LPUART_CTRL_RE_MASK;
    }
    else
    {
        base->CTRL &= ~LPUART_CTRL_RE_MASK;
    }
}

Here is the call graph for this function:

LPUART_EnableRxDMA()

static void LPUART_EnableRxDMA ( LPUART_Type *  base, bool  enable  )

inlinestatic

Enables or disables the LPUART receiver DMA.

This function enables or disables the receiver data register full flag, STAT[RDRF], to generate DMA requests.

Parameters

base	LPUART peripheral base address.
enable	True to enable, false to disable.

Definition at line 510 of file fsl_lpuart.h.

{
    if (enable)
    {
        base->BAUD |= LPUART_BAUD_RDMAE_MASK;
    }
    else
    {
        base->BAUD &= ~LPUART_BAUD_RDMAE_MASK;
    }
}

Referenced by LPUART_ReceiveEDMA(), LPUART_TransferAbortReceiveEDMA(), and uart_lld_stop_receive().

Here is the call graph for this function:

Here is the caller graph for this function:

LPUART_EnableTx()

static void LPUART_EnableTx ( LPUART_Type *  base, bool  enable  )

inlinestatic

Enables or disables the LPUART transmitter.

This function enables or disables the LPUART transmitter.

Parameters

base	LPUART peripheral base address.
enable	True to enable, false to disable.

Definition at line 546 of file fsl_lpuart.h.

{
    if (enable)
    {
        base->CTRL |= LPUART_CTRL_TE_MASK;
    }
    else
    {
        base->CTRL &= ~LPUART_CTRL_TE_MASK;
    }
}

Here is the call graph for this function:

LPUART_EnableTxDMA()

static void LPUART_EnableTxDMA ( LPUART_Type *  base, bool  enable  )

inlinestatic

Enables or disables the LPUART transmitter DMA request.

This function enables or disables the transmit data register empty flag, STAT[TDRE], to generate DMA requests.

Parameters

base	LPUART peripheral base address.
enable	True to enable, false to disable.

Definition at line 490 of file fsl_lpuart.h.

{
    if (enable)
    {
        base->BAUD |= LPUART_BAUD_TDMAE_MASK;
    }
    else
    {
        base->BAUD &= ~LPUART_BAUD_TDMAE_MASK;
    }
}

Referenced by LPUART_SendEDMA(), and LPUART_TransferAbortSendEDMA().

Here is the call graph for this function:

Here is the caller graph for this function:

LPUART_GetDataRegisterAddress()

static uint32_t LPUART_GetDataRegisterAddress ( LPUART_Type *  base )

inlinestatic

Gets the LPUART data register address.

This function returns the LPUART data register address, which is mainly used by the DMA/eDMA.

Parameters

base	LPUART peripheral base address.

Returns

LPUART data register addresses which are used both by the transmitter and receiver.

Definition at line 477 of file fsl_lpuart.h.

{
    return (uint32_t) & (base->DATA);
}

Referenced by LPUART_ReceiveEDMA(), and LPUART_SendEDMA().

Here is the caller graph for this function:

LPUART_GetDefaultConfig()

void LPUART_GetDefaultConfig

(

lpuart_config_t *

config

)

Gets the default configuration structure.

This function initializes the LPUART configuration structure to a default value. The default values are: lpuartConfig->baudRate_Bps = 115200U; lpuartConfig->parityMode = kLPUART_ParityDisabled; lpuartConfig->dataBitsCount = kLPUART_EightDataBits; lpuartConfig->isMsb = false; lpuartConfig->stopBitCount = kLPUART_OneStopBit; lpuartConfig->txFifoWatermark = 0; lpuartConfig->rxFifoWatermark = 1; lpuartConfig->rxIdleType = kLPUART_IdleTypeStartBit; lpuartConfig->rxIdleConfig = kLPUART_IdleCharacter1; lpuartConfig->enableTx = false; lpuartConfig->enableRx = false;

Parameters

config

Pointer to a configuration structure.

brief Gets the default configuration structure.

This function initializes the LPUART configuration structure to a default value. The default values are: lpuartConfig->baudRate_Bps = 115200U; lpuartConfig->parityMode = kLPUART_ParityDisabled; lpuartConfig->dataBitsCount = kLPUART_EightDataBits; lpuartConfig->isMsb = false; lpuartConfig->stopBitCount = kLPUART_OneStopBit; lpuartConfig->txFifoWatermark = 0; lpuartConfig->rxFifoWatermark = 1; lpuartConfig->rxIdleType = kLPUART_IdleTypeStartBit; lpuartConfig->rxIdleConfig = kLPUART_IdleCharacter1; lpuartConfig->enableTx = false; lpuartConfig->enableRx = false;

param config Pointer to a configuration structure.

Definition at line 519 of file fsl_lpuart.c.

{
    assert(config);
 
    /* Initializes the configure structure to zero. */
    memset(config, 0, sizeof(*config));
 
    config->baudRate_Bps = 115200U;
    config->parityMode = kLPUART_ParityDisabled;
    config->dataBitsCount = kLPUART_EightDataBits;
    config->isMsb = false;
#if defined(FSL_FEATURE_LPUART_HAS_STOP_BIT_CONFIG_SUPPORT) && FSL_FEATURE_LPUART_HAS_STOP_BIT_CONFIG_SUPPORT
    config->stopBitCount = kLPUART_OneStopBit;
#endif
#if defined(FSL_FEATURE_LPUART_HAS_FIFO) && FSL_FEATURE_LPUART_HAS_FIFO
    config->txFifoWatermark = 0;
    config->rxFifoWatermark = 0;
#endif
#if defined(FSL_FEATURE_LPUART_HAS_MODEM_SUPPORT) && FSL_FEATURE_LPUART_HAS_MODEM_SUPPORT
    config->enableRxRTS = false;
    config->enableTxCTS = false;
    config->txCtsConfig = kLPUART_CtsSampleAtStart;
    config->txCtsSource = kLPUART_CtsSourcePin;
#endif
    config->rxIdleType = kLPUART_IdleTypeStartBit;
    config->rxIdleConfig = kLPUART_IdleCharacter1;
    config->enableTx = false;
    config->enableRx = false;
}

Referenced by uart_lld_start().

Here is the caller graph for this function:

LPUART_GetEnabledInterrupts()

uint32_t LPUART_GetEnabledInterrupts

(

LPUART_Type *

base

)

Gets enabled LPUART interrupts.

This function gets the enabled LPUART interrupts. The enabled interrupts are returned as the logical OR value of the enumerators _lpuart_interrupt_enable. To check a specific interrupt enable status, compare the return value with enumerators in _lpuart_interrupt_enable. For example, to check whether the TX empty interrupt is enabled:

uint32_t enabledInterrupts = LPUART_GetEnabledInterrupts(LPUART1);
 
if (kLPUART_TxDataRegEmptyInterruptEnable & enabledInterrupts)
{
    ...
}

Parameters

base	LPUART peripheral base address.

Returns

LPUART interrupt flags which are logical OR of the enumerators in _lpuart_interrupt_enable.

brief Gets enabled LPUART interrupts.

This function gets the enabled LPUART interrupts. The enabled interrupts are returned as the logical OR value of the enumerators ref _lpuart_interrupt_enable. To check a specific interrupt enable status, compare the return value with enumerators in ref _lpuart_interrupt_enable. For example, to check whether the TX empty interrupt is enabled: code uint32_t enabledInterrupts = LPUART_GetEnabledInterrupts(LPUART1);

if (kLPUART_TxDataRegEmptyInterruptEnable & enabledInterrupts) { ... } endcode

param base LPUART peripheral base address. return LPUART interrupt flags which are logical OR of the enumerators in ref _lpuart_interrupt_enable.

Definition at line 717 of file fsl_lpuart.c.

{
    uint32_t temp;
    temp = (base->BAUD & (LPUART_BAUD_LBKDIE_MASK | LPUART_BAUD_RXEDGIE_MASK)) >> 8;
#if defined(FSL_FEATURE_LPUART_HAS_FIFO) && FSL_FEATURE_LPUART_HAS_FIFO
    temp |= (base->FIFO & (LPUART_FIFO_TXOFE_MASK | LPUART_FIFO_RXUFE_MASK)) >> 8;
#endif
    temp |= (base->CTRL & 0xFF0C000);
 
    return temp;
}

Referenced by LPUART_TransferHandleIRQ().

Here is the caller graph for this function:

LPUART_GetInstance()

uint32_t LPUART_GetInstance

(

LPUART_Type *

base

)

Get the LPUART instance from peripheral base address.

Parameters

base	LPUART peripheral base address.

Returns

LPUART instance.

brief Get the LPUART instance from peripheral base address.

param base LPUART peripheral base address. return LPUART instance.

Definition at line 111 of file fsl_lpuart.c.

{
    uint32_t instance;
 
    /* Find the instance index from base address mappings. */
    for (instance = 0; instance < ARRAY_SIZE(s_lpuartBases); instance++)
    {
        if (s_lpuartBases[instance] == base)
        {
            break;
        }
    }
 
    assert(instance < ARRAY_SIZE(s_lpuartBases));
 
    return instance;
}

Referenced by ADMA_UART0_INT_DriverIRQHandler(), ADMA_UART1_INT_DriverIRQHandler(), ADMA_UART2_INT_DriverIRQHandler(), ADMA_UART3_INT_DriverIRQHandler(), DMA_UART0_INT_DriverIRQHandler(), DMA_UART1_INT_DriverIRQHandler(), DMA_UART2_INT_DriverIRQHandler(), DMA_UART3_INT_DriverIRQHandler(), DMA_UART4_INT_DriverIRQHandler(), LPUART_Deinit(), LPUART_Init(), LPUART_TransferCreateHandle(), LPUART_TransferCreateHandleEDMA(), M4_0_LPUART_DriverIRQHandler(), M4_1_LPUART_DriverIRQHandler(), and M4_LPUART_DriverIRQHandler().

Here is the caller graph for this function:

LPUART_GetStatusFlags()

uint32_t LPUART_GetStatusFlags

(

LPUART_Type *

base

)

Gets LPUART status flags.

This function gets all LPUART status flags. The flags are returned as the logical OR value of the enumerators _lpuart_flags. To check for a specific status, compare the return value with enumerators in the _lpuart_flags. For example, to check whether the TX is empty:

if (kLPUART_TxDataRegEmptyFlag & LPUART_GetStatusFlags(LPUART1))
{
    ...
}

Parameters

base	LPUART peripheral base address.

Returns

LPUART status flags which are ORed by the enumerators in the _lpuart_flags.

brief Gets LPUART status flags.

This function gets all LPUART status flags. The flags are returned as the logical OR value of the enumerators ref _lpuart_flags. To check for a specific status, compare the return value with enumerators in the ref _lpuart_flags. For example, to check whether the TX is empty: code if (kLPUART_TxDataRegEmptyFlag & LPUART_GetStatusFlags(LPUART1)) { ... } endcode

param base LPUART peripheral base address. return LPUART status flags which are ORed by the enumerators in the _lpuart_flags.

Definition at line 746 of file fsl_lpuart.c.

{
    uint32_t temp;
    temp = base->STAT;
#if defined(FSL_FEATURE_LPUART_HAS_FIFO) && FSL_FEATURE_LPUART_HAS_FIFO
    temp |= (base->FIFO &
             (LPUART_FIFO_TXEMPT_MASK | LPUART_FIFO_RXEMPT_MASK | LPUART_FIFO_TXOF_MASK | LPUART_FIFO_RXUF_MASK)) >>
            16;
#endif
    return temp;
}

Referenced by LPUART_ClearStatusFlags(), LPUART_ReadBlocking(), and LPUART_TransferHandleIRQ().

Here is the caller graph for this function:

LPUART_Init()

status_t LPUART_Init	(	LPUART_Type *	base,
		const lpuart_config_t *	config,
		uint32_t	srcClock_Hz
	)

Initializes an LPUART instance with the user configuration structure and the peripheral clock.

This function configures the LPUART module with user-defined settings. Call the LPUART_GetDefaultConfig() function to configure the configuration structure and get the default configuration. The example below shows how to use this API to configure the LPUART.

lpuart_config_t lpuartConfig;
lpuartConfig.baudRate_Bps = 115200U;
lpuartConfig.parityMode = kLPUART_ParityDisabled;
lpuartConfig.dataBitsCount = kLPUART_EightDataBits;
lpuartConfig.isMsb = false;
lpuartConfig.stopBitCount = kLPUART_OneStopBit;
lpuartConfig.txFifoWatermark = 0;
lpuartConfig.rxFifoWatermark = 1;
LPUART_Init(LPUART1, &lpuartConfig, 20000000U);

Parameters

base	LPUART peripheral base address.
config	Pointer to a user-defined configuration structure.
srcClock_Hz	LPUART clock source frequency in HZ.

Return values

kStatus_LPUART_BaudrateNotSupport	Baudrate is not support in current clock source.
kStatus_Success	LPUART initialize succeed

brief Initializes an LPUART instance with the user configuration structure and the peripheral clock.

This function configures the LPUART module with user-defined settings. Call the LPUART_GetDefaultConfig() function to configure the configuration structure and get the default configuration. The example below shows how to use this API to configure the LPUART. code lpuart_config_t lpuartConfig; lpuartConfig.baudRate_Bps = 115200U; lpuartConfig.parityMode = kLPUART_ParityDisabled; lpuartConfig.dataBitsCount = kLPUART_EightDataBits; lpuartConfig.isMsb = false; lpuartConfig.stopBitCount = kLPUART_OneStopBit; lpuartConfig.txFifoWatermark = 0; lpuartConfig.rxFifoWatermark = 1; LPUART_Init(LPUART1, &lpuartConfig, 20000000U); endcode

param base LPUART peripheral base address. param config Pointer to a user-defined configuration structure. param srcClock_Hz LPUART clock source frequency in HZ. retval kStatus_LPUART_BaudrateNotSupport Baudrate is not support in current clock source. retval kStatus_Success LPUART initialize succeed

Definition at line 239 of file fsl_lpuart.c.

{
    assert(config);
    assert(config->baudRate_Bps);
#if defined(FSL_FEATURE_LPUART_HAS_FIFO) && FSL_FEATURE_LPUART_HAS_FIFO
    assert(FSL_FEATURE_LPUART_FIFO_SIZEn(base) >= config->txFifoWatermark);
    assert(FSL_FEATURE_LPUART_FIFO_SIZEn(base) >= config->rxFifoWatermark);
#endif
 
    uint32_t temp;
    uint16_t sbr, sbrTemp;
    uint32_t osr, osrTemp, tempDiff, calculatedBaud, baudDiff;
 
    /* This LPUART instantiation uses a slightly different baud rate calculation
     * The idea is to use the best OSR (over-sampling rate) possible
     * Note, OSR is typically hard-set to 16 in other LPUART instantiations
     * loop to find the best OSR value possible, one that generates minimum baudDiff
     * iterate through the rest of the supported values of OSR */
 
    baudDiff = config->baudRate_Bps;
    osr = 0;
    sbr = 0;
    for (osrTemp = 4; osrTemp <= 32; osrTemp++)
    {
        /* calculate the temporary sbr value   */
        sbrTemp = (srcClock_Hz / (config->baudRate_Bps * osrTemp));
        /*set sbrTemp to 1 if the sourceClockInHz can not satisfy the desired baud rate*/
        if (sbrTemp == 0)
        {
            sbrTemp = 1;
        }
        /* Calculate the baud rate based on the temporary OSR and SBR values */
        calculatedBaud = (srcClock_Hz / (osrTemp * sbrTemp));
 
        tempDiff = calculatedBaud - config->baudRate_Bps;
 
        /* Select the better value between srb and (sbr + 1) */
        if (tempDiff > (config->baudRate_Bps - (srcClock_Hz / (osrTemp * (sbrTemp + 1)))))
        {
            tempDiff = config->baudRate_Bps - (srcClock_Hz / (osrTemp * (sbrTemp + 1)));
            sbrTemp++;
        }
 
        if (tempDiff <= baudDiff)
        {
            baudDiff = tempDiff;
            osr = osrTemp; /* update and store the best OSR value calculated */
            sbr = sbrTemp; /* update store the best SBR value calculated */
        }
    }
 
    /* Check to see if actual baud rate is within 3% of desired baud rate
     * based on the best calculate OSR value */
    if (baudDiff > ((config->baudRate_Bps / 100) * 3))
    {
        /* Unacceptable baud rate difference of more than 3%*/
        return kStatus_LPUART_BaudrateNotSupport;
    }
 
#if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL)
 
    uint32_t instance = LPUART_GetInstance(base);
 
    /* Enable lpuart clock */
    CLOCK_EnableClock(s_lpuartClock[instance]);
#if defined(LPUART_PERIPH_CLOCKS)
    CLOCK_EnableClock(s_lpuartPeriphClocks[instance]);
#endif
 
#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */
 
#if defined(FSL_FEATURE_LPUART_HAS_GLOBAL) && FSL_FEATURE_LPUART_HAS_GLOBAL
    /*Reset all internal logic and registers, except the Global Register */
    LPUART_SoftwareReset(base);
#else
    /* Disable LPUART TX RX before setting. */
    base->CTRL &= ~(LPUART_CTRL_TE_MASK | LPUART_CTRL_RE_MASK);
#endif
 
    temp = base->BAUD;
 
    /* Acceptable baud rate, check if OSR is between 4x and 7x oversampling.
     * If so, then "BOTHEDGE" sampling must be turned on */
    if ((osr > 3) && (osr < 8))
    {
        temp |= LPUART_BAUD_BOTHEDGE_MASK;
    }
 
    /* program the osr value (bit value is one less than actual value) */
    temp &= ~LPUART_BAUD_OSR_MASK;
    temp |= LPUART_BAUD_OSR(osr - 1);
 
    /* write the sbr value to the BAUD registers */
    temp &= ~LPUART_BAUD_SBR_MASK;
    base->BAUD = temp | LPUART_BAUD_SBR(sbr);
 
    /* Set bit count and parity mode. */
    base->BAUD &= ~LPUART_BAUD_M10_MASK;
 
    temp = base->CTRL &
           ~(LPUART_CTRL_PE_MASK | LPUART_CTRL_PT_MASK | LPUART_CTRL_M_MASK | LPUART_CTRL_ILT_MASK |
             LPUART_CTRL_IDLECFG_MASK);
 
    temp |=
        (uint8_t)config->parityMode | LPUART_CTRL_IDLECFG(config->rxIdleConfig) | LPUART_CTRL_ILT(config->rxIdleType);
 
#if defined(FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT) && FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT
    if (kLPUART_SevenDataBits == config->dataBitsCount)
    {
        if (kLPUART_ParityDisabled != config->parityMode)
        {
            temp &= ~LPUART_CTRL_M7_MASK; /* Seven data bits and one parity bit */
        }
        else
        {
            temp |= LPUART_CTRL_M7_MASK;
        }
    }
    else
#endif
    {
        if (kLPUART_ParityDisabled != config->parityMode)
        {
            temp |= LPUART_CTRL_M_MASK; /* Eight data bits and one parity bit */
        }
    }
 
    base->CTRL = temp;
 
#if defined(FSL_FEATURE_LPUART_HAS_STOP_BIT_CONFIG_SUPPORT) && FSL_FEATURE_LPUART_HAS_STOP_BIT_CONFIG_SUPPORT
    /* set stop bit per char */
    temp = base->BAUD & ~LPUART_BAUD_SBNS_MASK;
    base->BAUD = temp | LPUART_BAUD_SBNS((uint8_t)config->stopBitCount);
#endif
 
#if defined(FSL_FEATURE_LPUART_HAS_FIFO) && FSL_FEATURE_LPUART_HAS_FIFO
    /* Set tx/rx WATER watermark
       Note:
       Take care of the RX FIFO, RX interrupt request only assert when received bytes
       equal or more than RX water mark, there is potential issue if RX water
       mark larger than 1.
       For example, if RX FIFO water mark is 2, upper layer needs 5 bytes and
       5 bytes are received. the last byte will be saved in FIFO but not trigger
       RX interrupt because the water mark is 2.
     */
    base->WATER = (((uint32_t)(config->rxFifoWatermark) << 16) | config->txFifoWatermark);
 
    /* Enable tx/rx FIFO */
    base->FIFO |= (LPUART_FIFO_TXFE_MASK | LPUART_FIFO_RXFE_MASK);
 
    /* Flush FIFO */
    base->FIFO |= (LPUART_FIFO_TXFLUSH_MASK | LPUART_FIFO_RXFLUSH_MASK);
#endif
 
    /* Clear all status flags */
    temp = (LPUART_STAT_RXEDGIF_MASK | LPUART_STAT_IDLE_MASK | LPUART_STAT_OR_MASK | LPUART_STAT_NF_MASK |
            LPUART_STAT_FE_MASK | LPUART_STAT_PF_MASK);
 
#if defined(FSL_FEATURE_LPUART_HAS_LIN_BREAK_DETECT) && FSL_FEATURE_LPUART_HAS_LIN_BREAK_DETECT
    temp |= LPUART_STAT_LBKDIF_MASK;
#endif
 
#if defined(FSL_FEATURE_LPUART_HAS_ADDRESS_MATCHING) && FSL_FEATURE_LPUART_HAS_ADDRESS_MATCHING
    temp |= (LPUART_STAT_MA1F_MASK | LPUART_STAT_MA2F_MASK);
#endif
 
#if defined(FSL_FEATURE_LPUART_HAS_MODEM_SUPPORT) && FSL_FEATURE_LPUART_HAS_MODEM_SUPPORT
    /* Set the CTS configuration/TX CTS source. */
    base->MODIR |= LPUART_MODIR_TXCTSC(config->txCtsConfig) | LPUART_MODIR_TXCTSSRC(config->txCtsSource);
    if (config->enableRxRTS)
    {
        /* Enable the receiver RTS(request-to-send) function. */
        base->MODIR |= LPUART_MODIR_RXRTSE_MASK;
    }
    if (config->enableTxCTS)
    {
        /* Enable the CTS(clear-to-send) function. */
        base->MODIR |= LPUART_MODIR_TXCTSE_MASK;
    }
#endif
 
    /* Set data bits order. */
    if (config->isMsb)
    {
        temp |= LPUART_STAT_MSBF_MASK;
    }
    else
    {
        temp &= ~LPUART_STAT_MSBF_MASK;
    }
 
    base->STAT |= temp;
 
    /* Enable TX/RX base on configure structure. */
    temp = base->CTRL;
    if (config->enableTx)
    {
        temp |= LPUART_CTRL_TE_MASK;
    }
 
    if (config->enableRx)
    {
        temp |= LPUART_CTRL_RE_MASK;
    }
 
    base->CTRL = temp;
 
    return kStatus_Success;
}

Referenced by uart_lld_start().

Here is the call graph for this function:

Here is the caller graph for this function:

LPUART_ReadBlocking()

status_t LPUART_ReadBlocking	(	LPUART_Type *	base,
		uint8_t *	data,
		size_t	length
	)

Reads the receiver data register using a blocking method.

This function polls the receiver register, waits for the receiver register full or receiver FIFO has data, and reads data from the TX register.

Parameters

base	LPUART peripheral base address.
data	Start address of the buffer to store the received data.
length	Size of the buffer.

Return values

kStatus_LPUART_RxHardwareOverrun	Receiver overrun happened while receiving data.
kStatus_LPUART_NoiseError	Noise error happened while receiving data.
kStatus_LPUART_FramingError	Framing error happened while receiving data.
kStatus_LPUART_ParityError	Parity error happened while receiving data.
kStatus_Success	Successfully received all data.

brief Reads the receiver data register using a blocking method.

This function polls the receiver register, waits for the receiver register full or receiver FIFO has data, and reads data from the TX register.

param base LPUART peripheral base address. param data Start address of the buffer to store the received data. param length Size of the buffer. retval kStatus_LPUART_RxHardwareOverrun Receiver overrun happened while receiving data. retval kStatus_LPUART_NoiseError Noise error happened while receiving data. retval kStatus_LPUART_FramingError Framing error happened while receiving data. retval kStatus_LPUART_ParityError Parity error happened while receiving data. retval kStatus_Success Successfully received all data.

Definition at line 862 of file fsl_lpuart.c.

{
    assert(data);
 
    uint32_t statusFlag;
#if defined(FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT) && FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT
    uint32_t ctrl = base->CTRL;
    bool isSevenDataBits =
        ((ctrl & LPUART_CTRL_M7_MASK) || ((!(ctrl & LPUART_CTRL_M_MASK)) && (ctrl & LPUART_CTRL_PE_MASK)));
#endif
 
    while (length--)
    {
#if defined(FSL_FEATURE_LPUART_HAS_FIFO) && FSL_FEATURE_LPUART_HAS_FIFO
        while (0 == ((base->WATER & LPUART_WATER_RXCOUNT_MASK) >> LPUART_WATER_RXCOUNT_SHIFT))
#else
        while (!(base->STAT & LPUART_STAT_RDRF_MASK))
#endif
        {
            statusFlag = LPUART_GetStatusFlags(base);
 
            if (statusFlag & kLPUART_RxOverrunFlag)
            {
                LPUART_ClearStatusFlags(base, kLPUART_RxOverrunFlag);
                return kStatus_LPUART_RxHardwareOverrun;
            }
 
            if (statusFlag & kLPUART_NoiseErrorFlag)
            {
                LPUART_ClearStatusFlags(base, kLPUART_NoiseErrorFlag);
                return kStatus_LPUART_NoiseError;
            }
 
            if (statusFlag & kLPUART_FramingErrorFlag)
            {
                LPUART_ClearStatusFlags(base, kLPUART_FramingErrorFlag);
                return kStatus_LPUART_FramingError;
            }
 
            if (statusFlag & kLPUART_ParityErrorFlag)
            {
                LPUART_ClearStatusFlags(base, kLPUART_ParityErrorFlag);
                return kStatus_LPUART_ParityError;
            }
        }
#if defined(FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT) && FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT
        if (isSevenDataBits)
        {
            *(data++) = (base->DATA & 0x7F);
        }
        else
        {
            *(data++) = base->DATA;
        }
#else
        *(data++) = base->DATA;
#endif
    }
 
    return kStatus_Success;
}

Here is the call graph for this function:

LPUART_ReadByte()

static uint8_t LPUART_ReadByte ( LPUART_Type *  base )

inlinestatic

Reads the receiver register.

This function reads data from the receiver register directly. The upper layer must ensure that the receiver register is full or that the RX FIFO has data before calling this function.

Parameters

base	LPUART peripheral base address.

Returns

Data read from data register.

Definition at line 601 of file fsl_lpuart.h.

{
#if defined(FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT) && FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT
    uint32_t ctrl = base->CTRL;
    bool isSevenDataBits =
        ((ctrl & LPUART_CTRL_M7_MASK) ||
         ((!(ctrl & LPUART_CTRL_M7_MASK)) && (!(ctrl & LPUART_CTRL_M_MASK)) && (ctrl & LPUART_CTRL_PE_MASK)));
 
    if (isSevenDataBits)
    {
        return (base->DATA & 0x7F);
    }
    else
    {
        return base->DATA;
    }
#else
    return base->DATA;
#endif
}

LPUART_SetBaudRate()

status_t LPUART_SetBaudRate	(	LPUART_Type *	base,
		uint32_t	baudRate_Bps,
		uint32_t	srcClock_Hz
	)

Sets the LPUART instance baudrate.

This function configures the LPUART module baudrate. This function is used to update the LPUART module baudrate after the LPUART module is initialized by the LPUART_Init.

LPUART_SetBaudRate(LPUART1, 115200U, 20000000U);

Parameters

base	LPUART peripheral base address.
baudRate_Bps	LPUART baudrate to be set.
srcClock_Hz	LPUART clock source frequency in HZ.

Return values

kStatus_LPUART_BaudrateNotSupport	Baudrate is not supported in the current clock source.
kStatus_Success	Set baudrate succeeded.

brief Sets the LPUART instance baudrate.

This function configures the LPUART module baudrate. This function is used to update the LPUART module baudrate after the LPUART module is initialized by the LPUART_Init. code LPUART_SetBaudRate(LPUART1, 115200U, 20000000U); endcode

param base LPUART peripheral base address. param baudRate_Bps LPUART baudrate to be set. param srcClock_Hz LPUART clock source frequency in HZ. retval kStatus_LPUART_BaudrateNotSupport Baudrate is not supported in the current clock source. retval kStatus_Success Set baudrate succeeded.

Definition at line 564 of file fsl_lpuart.c.

{
    assert(baudRate_Bps);
 
    uint32_t temp, oldCtrl;
    uint16_t sbr, sbrTemp;
    uint32_t osr, osrTemp, tempDiff, calculatedBaud, baudDiff;
 
    /* This LPUART instantiation uses a slightly different baud rate calculation
     * The idea is to use the best OSR (over-sampling rate) possible
     * Note, OSR is typically hard-set to 16 in other LPUART instantiations
     * loop to find the best OSR value possible, one that generates minimum baudDiff
     * iterate through the rest of the supported values of OSR */
 
    baudDiff = baudRate_Bps;
    osr = 0;
    sbr = 0;
    for (osrTemp = 4; osrTemp <= 32; osrTemp++)
    {
        /* calculate the temporary sbr value   */
        sbrTemp = (srcClock_Hz / (baudRate_Bps * osrTemp));
        /*set sbrTemp to 1 if the sourceClockInHz can not satisfy the desired baud rate*/
        if (sbrTemp == 0)
        {
            sbrTemp = 1;
        }
        /* Calculate the baud rate based on the temporary OSR and SBR values */
        calculatedBaud = (srcClock_Hz / (osrTemp * sbrTemp));
 
        tempDiff = calculatedBaud - baudRate_Bps;
 
        /* Select the better value between srb and (sbr + 1) */
        if (tempDiff > (baudRate_Bps - (srcClock_Hz / (osrTemp * (sbrTemp + 1)))))
        {
            tempDiff = baudRate_Bps - (srcClock_Hz / (osrTemp * (sbrTemp + 1)));
            sbrTemp++;
        }
 
        if (tempDiff <= baudDiff)
        {
            baudDiff = tempDiff;
            osr = osrTemp; /* update and store the best OSR value calculated */
            sbr = sbrTemp; /* update store the best SBR value calculated */
        }
    }
 
    /* Check to see if actual baud rate is within 3% of desired baud rate
     * based on the best calculate OSR value */
    if (baudDiff < ((baudRate_Bps / 100) * 3))
    {
        /* Store CTRL before disable Tx and Rx */
        oldCtrl = base->CTRL;
 
        /* Disable LPUART TX RX before setting. */
        base->CTRL &= ~(LPUART_CTRL_TE_MASK | LPUART_CTRL_RE_MASK);
 
        temp = base->BAUD;
 
        /* Acceptable baud rate, check if OSR is between 4x and 7x oversampling.
         * If so, then "BOTHEDGE" sampling must be turned on */
        if ((osr > 3) && (osr < 8))
        {
            temp |= LPUART_BAUD_BOTHEDGE_MASK;
        }
 
        /* program the osr value (bit value is one less than actual value) */
        temp &= ~LPUART_BAUD_OSR_MASK;
        temp |= LPUART_BAUD_OSR(osr - 1);
 
        /* write the sbr value to the BAUD registers */
        temp &= ~LPUART_BAUD_SBR_MASK;
        base->BAUD = temp | LPUART_BAUD_SBR(sbr);
 
        /* Restore CTRL. */
        base->CTRL = oldCtrl;
 
        return kStatus_Success;
    }
    else
    {
        /* Unacceptable baud rate difference of more than 3%*/
        return kStatus_LPUART_BaudrateNotSupport;
    }
}

Referenced by ke1xf_clock_init().

Here is the caller graph for this function:

LPUART_SoftwareReset()

static void LPUART_SoftwareReset ( LPUART_Type *  base )

inlinestatic

Resets the LPUART using software.

This function resets all internal logic and registers except the Global Register. Remains set until cleared by software.

Parameters

base	LPUART peripheral base address.

Definition at line 276 of file fsl_lpuart.h.

{
    base->GLOBAL |= LPUART_GLOBAL_RST_MASK;
    base->GLOBAL &= ~LPUART_GLOBAL_RST_MASK;
}

Referenced by LPUART_Init().

Here is the caller graph for this function:

LPUART_TransferAbortReceive()

void LPUART_TransferAbortReceive	(	LPUART_Type *	base,
		lpuart_handle_t *	handle
	)

Aborts the interrupt-driven data receiving.

This function aborts the interrupt-driven data receiving. The user can get the remainBytes to find out how many bytes not received yet.

Parameters

base	LPUART peripheral base address.
handle	LPUART handle pointer.

brief Aborts the interrupt-driven data receiving.

This function aborts the interrupt-driven data receiving. The user can get the remainBytes to find out how many bytes not received yet.

param base LPUART peripheral base address. param handle LPUART handle pointer.

Definition at line 1294 of file fsl_lpuart.c.

{
    assert(handle);
 
    /* Only abort the receive to handle->rxData, the RX ring buffer is still working. */
    if (!handle->rxRingBuffer)
    {
        /* Disable RX interrupt. */
        LPUART_DisableInterrupts(base, kLPUART_RxDataRegFullInterruptEnable | kLPUART_RxOverrunInterruptEnable |
                                           kLPUART_IdleLineInterruptEnable);
    }
 
    handle->rxDataSize = 0U;
    handle->rxState = kLPUART_RxIdle;
}

Referenced by uart_lld_stop_receive().

Here is the call graph for this function:

Here is the caller graph for this function:

LPUART_TransferAbortSend()

void LPUART_TransferAbortSend	(	LPUART_Type *	base,
		lpuart_handle_t *	handle
	)

Aborts the interrupt-driven data transmit.

This function aborts the interrupt driven data sending. The user can get the remainBtyes to find out how many bytes are not sent out.

Parameters

base	LPUART peripheral base address.
handle	LPUART handle pointer.

brief Aborts the interrupt-driven data transmit.

This function aborts the interrupt driven data sending. The user can get the remainBtyes to find out how many bytes are not sent out.

param base LPUART peripheral base address. param handle LPUART handle pointer.

Definition at line 1105 of file fsl_lpuart.c.

{
    assert(handle);
 
    LPUART_DisableInterrupts(base, kLPUART_TxDataRegEmptyInterruptEnable | kLPUART_TransmissionCompleteInterruptEnable);
 
    handle->txDataSize = 0;
    handle->txState = kLPUART_TxIdle;
}

Here is the call graph for this function:

LPUART_TransferCreateHandle()

void LPUART_TransferCreateHandle	(	LPUART_Type *	base,
		lpuart_handle_t *	handle,
		lpuart_transfer_callback_t	callback,
		void *	userData
	)

Initializes the LPUART handle.

This function initializes the LPUART handle, which can be used for other LPUART transactional APIs. Usually, for a specified LPUART instance, call this API once to get the initialized handle.

The LPUART driver supports the "background" receiving, which means that user can set up an RX ring buffer optionally. Data received is stored into the ring buffer even when the user doesn't call the LPUART_TransferReceiveNonBlocking() API. If there is already data received in the ring buffer, the user can get the received data from the ring buffer directly. The ring buffer is disabled if passing NULL as ringBuffer.

Parameters

base	LPUART peripheral base address.
handle	LPUART handle pointer.
callback	Callback function.
userData	User data.

brief Initializes the LPUART handle.

This function initializes the LPUART handle, which can be used for other LPUART transactional APIs. Usually, for a specified LPUART instance, call this API once to get the initialized handle.

The LPUART driver supports the "background" receiving, which means that user can set up an RX ring buffer optionally. Data received is stored into the ring buffer even when the user doesn't call the LPUART_TransferReceiveNonBlocking() API. If there is already data received in the ring buffer, the user can get the received data from the ring buffer directly. The ring buffer is disabled if passing NULL as p ringBuffer.

param base LPUART peripheral base address. param handle LPUART handle pointer. param callback Callback function. param userData User data.

Definition at line 942 of file fsl_lpuart.c.

{
    assert(handle);
 
    uint32_t instance;
#if defined(FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT) && FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT
    uint32_t ctrl = base->CTRL;
    bool isSevenDataBits =
        ((ctrl & LPUART_CTRL_M7_MASK) || ((!(ctrl & LPUART_CTRL_M_MASK)) && (ctrl & LPUART_CTRL_PE_MASK)));
#endif
 
    /* Zero the handle. */
    memset(handle, 0, sizeof(lpuart_handle_t));
 
    /* Set the TX/RX state. */
    handle->rxState = kLPUART_RxIdle;
    handle->txState = kLPUART_TxIdle;
 
    /* Set the callback and user data. */
    handle->callback = callback;
    handle->userData = userData;
 
#if defined(FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT) && FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT
    /* Initial seven data bits flag */
    handle->isSevenDataBits = isSevenDataBits;
#endif
 
    /* Get instance from peripheral base address. */
    instance = LPUART_GetInstance(base);
 
    /* Save the handle in global variables to support the double weak mechanism. */
    s_lpuartHandle[instance] = handle;
 
    s_lpuartIsr = LPUART_TransferHandleIRQ;
 
/* Enable interrupt in NVIC. */
#if defined(FSL_FEATURE_LPUART_HAS_SEPARATE_RX_TX_IRQ) && FSL_FEATURE_LPUART_HAS_SEPARATE_RX_TX_IRQ
    EnableIRQ(s_lpuartRxIRQ[instance]);
    EnableIRQ(s_lpuartTxIRQ[instance]);
#else
    EnableIRQ(s_lpuartIRQ[instance]);
#endif
}

Referenced by uart_lld_start().

Here is the call graph for this function:

Here is the caller graph for this function:

LPUART_TransferGetReceiveCount()

status_t LPUART_TransferGetReceiveCount	(	LPUART_Type *	base,
		lpuart_handle_t *	handle,
		uint32_t *	count
	)

Gets the number of bytes that have been received.

This function gets the number of bytes that have been received.

Parameters

base	LPUART peripheral base address.
handle	LPUART handle pointer.
count	Receive bytes count.

Return values

kStatus_NoTransferInProgress	No receive in progress.
kStatus_InvalidArgument	Parameter is invalid.
kStatus_Success	Get successfully through the parameter count;

brief Gets the number of bytes that have been received.

This function gets the number of bytes that have been received.

param base LPUART peripheral base address. param handle LPUART handle pointer. param count Receive bytes count. retval kStatus_NoTransferInProgress No receive in progress. retval kStatus_InvalidArgument Parameter is invalid. retval kStatus_Success Get successfully through the parameter count;

Definition at line 1322 of file fsl_lpuart.c.

{
    assert(handle);
    assert(count);
 
    if (kLPUART_RxIdle == handle->rxState)
    {
        return kStatus_NoTransferInProgress;
    }
 
    *count = handle->rxDataSizeAll - handle->rxDataSize;
 
    return kStatus_Success;
}

Referenced by uart_lld_stop_receive().

Here is the caller graph for this function:

LPUART_TransferGetRxRingBufferLength()

size_t LPUART_TransferGetRxRingBufferLength	(	LPUART_Type *	base,
		lpuart_handle_t *	handle
	)

Get the length of received data in RX ring buffer.

Parameters

handle

LPUART handle pointer.

Returns

Length of received data in RX ring buffer.

brief Get the length of received data in RX ring buffer.

userData handle LPUART handle pointer. return Length of received data in RX ring buffer.

Definition at line 135 of file fsl_lpuart.c.

{
    assert(handle);
 
    size_t size;
 
    if (handle->rxRingBufferTail > handle->rxRingBufferHead)
    {
        size = (size_t)(handle->rxRingBufferHead + handle->rxRingBufferSize - handle->rxRingBufferTail);
    }
    else
    {
        size = (size_t)(handle->rxRingBufferHead - handle->rxRingBufferTail);
    }
 
    return size;
}

Referenced by LPUART_TransferIsRxRingBufferFull(), and LPUART_TransferReceiveNonBlocking().

Here is the caller graph for this function:

LPUART_TransferGetSendCount()

status_t LPUART_TransferGetSendCount	(	LPUART_Type *	base,
		lpuart_handle_t *	handle,
		uint32_t *	count
	)

Gets the number of bytes that have been written to the LPUART transmitter register.

This function gets the number of bytes that have been written to LPUART TX register by an interrupt method.

Parameters

base	LPUART peripheral base address.
handle	LPUART handle pointer.
count	Send bytes count.

Return values

kStatus_NoTransferInProgress	No send in progress.
kStatus_InvalidArgument	Parameter is invalid.
kStatus_Success	Get successfully through the parameter count;

brief Gets the number of bytes that have been written to the LPUART transmitter register.

This function gets the number of bytes that have been written to LPUART TX register by an interrupt method.

param base LPUART peripheral base address. param handle LPUART handle pointer. param count Send bytes count. retval kStatus_NoTransferInProgress No send in progress. retval kStatus_InvalidArgument Parameter is invalid. retval kStatus_Success Get successfully through the parameter count;

Definition at line 1128 of file fsl_lpuart.c.

{
    assert(handle);
    assert(count);
 
    if (kLPUART_TxIdle == handle->txState)
    {
        return kStatus_NoTransferInProgress;
    }
 
    *count = handle->txDataSizeAll - handle->txDataSize;
 
    return kStatus_Success;
}

LPUART_TransferHandleErrorIRQ()

void LPUART_TransferHandleErrorIRQ	(	LPUART_Type *	base,
		lpuart_handle_t *	handle
	)

LPUART Error IRQ handle function.

This function handles the LPUART error IRQ request.

Parameters

base	LPUART peripheral base address.
handle	LPUART handle pointer.

brief LPUART Error IRQ handle function.

This function handles the LPUART error IRQ request.

param base LPUART peripheral base address. param handle LPUART handle pointer.

Definition at line 1573 of file fsl_lpuart.c.

{
    /* To be implemented by User. */
}

LPUART_TransferHandleIRQ()

void LPUART_TransferHandleIRQ	(	LPUART_Type *	base,
		lpuart_handle_t *	handle
	)

LPUART IRQ handle function.

This function handles the LPUART transmit and receive IRQ request.

Parameters

base	LPUART peripheral base address.
handle	LPUART handle pointer.

brief LPUART IRQ handle function.

This function handles the LPUART transmit and receive IRQ request.

param base LPUART peripheral base address. param handle LPUART handle pointer.

Definition at line 1345 of file fsl_lpuart.c.

{
    assert(handle);
 
    uint8_t count;
    uint8_t tempCount;
    uint32_t status = LPUART_GetStatusFlags(base);
    uint32_t enabledInterrupts = LPUART_GetEnabledInterrupts(base);
 
    /////////////////////////////////////////////////////////////////////////////////////////
    // [andreika][rusefi]: we use this 'fake' unused status to trigger the callback via IRQ in software
    if (LPUART_STAT_RXINV_MASK & status)
    {
        base->STAT &= ~LPUART_STAT_RXINV_MASK;
        if (handle->callback)
        {
            handle->callback(base, handle, kStatus_LPUART_RxIdle, handle->userData);
        }
    }
    /////////////////////////////////////////////////////////////////////////////////////////
 
    /* If RX overrun. */
    if (kLPUART_RxOverrunFlag & status)
    {
        /* Clear overrun flag, otherwise the RX does not work. */
        base->STAT = ((base->STAT & 0x3FE00000U) | LPUART_STAT_OR_MASK);
 
        /* Trigger callback. */
        if (handle->callback)
        {
            handle->callback(base, handle, kStatus_LPUART_RxHardwareOverrun, handle->userData);
        }
    }
 
    /* If IDLE flag is set and the IDLE interrupt is enabled. */
    if ((kLPUART_IdleLineFlag & status) && (kLPUART_IdleLineInterruptEnable & enabledInterrupts))
    {
#if defined(FSL_FEATURE_LPUART_HAS_FIFO) && FSL_FEATURE_LPUART_HAS_FIFO
        count = ((uint8_t)((base->WATER & LPUART_WATER_RXCOUNT_MASK) >> LPUART_WATER_RXCOUNT_SHIFT));
 
        while ((count) && (handle->rxDataSize))
        {
            tempCount = MIN(handle->rxDataSize, count);
 
            /* Using non block API to read the data from the registers. */
            LPUART_ReadNonBlocking(base, handle->rxData, tempCount);
            handle->rxData += tempCount;
            handle->rxDataSize -= tempCount;
            count -= tempCount;
 
            /* If rxDataSize is 0, disable idle line interrupt.*/
            if (!(handle->rxDataSize))
            {
                handle->rxState = kLPUART_RxIdle;
 
                LPUART_DisableInterrupts(base, kLPUART_RxDataRegFullInterruptEnable | kLPUART_RxOverrunInterruptEnable);
                if (handle->callback)
                {
                    handle->callback(base, handle, kStatus_LPUART_RxIdle, handle->userData);
                }
            }
        }
#endif
        /* Clear IDLE flag.*/
        base->STAT |= LPUART_STAT_IDLE_MASK;
 
        /* If rxDataSize is 0, disable idle line interrupt.*/
        if (!(handle->rxDataSize))
        {
            LPUART_DisableInterrupts(base, kLPUART_IdleLineInterruptEnable);
        }
        /* If callback is not NULL and rxDataSize is not 0. */
        if ((handle->callback) && (handle->rxDataSize))
        {
            handle->callback(base, handle, kStatus_LPUART_IdleLineDetected, handle->userData);
        }
    }
    /* Receive data register full */
    if ((kLPUART_RxDataRegFullFlag & status) && (kLPUART_RxDataRegFullInterruptEnable & enabledInterrupts))
    {
/* Get the size that can be stored into buffer for this interrupt. */
#if defined(FSL_FEATURE_LPUART_HAS_FIFO) && FSL_FEATURE_LPUART_HAS_FIFO
        count = ((uint8_t)((base->WATER & LPUART_WATER_RXCOUNT_MASK) >> LPUART_WATER_RXCOUNT_SHIFT));
#else
        count = 1;
#endif
 
        /* If handle->rxDataSize is not 0, first save data to handle->rxData. */
        while ((count) && (handle->rxDataSize))
        {
#if defined(FSL_FEATURE_LPUART_HAS_FIFO) && FSL_FEATURE_LPUART_HAS_FIFO
            tempCount = MIN(handle->rxDataSize, count);
#else
            tempCount = 1;
#endif
 
            /* Using non block API to read the data from the registers. */
            LPUART_ReadNonBlocking(base, handle->rxData, tempCount);
            handle->rxData += tempCount;
            handle->rxDataSize -= tempCount;
            count -= tempCount;
 
            /* If all the data required for upper layer is ready, trigger callback. */
            if (!handle->rxDataSize)
            {
                handle->rxState = kLPUART_RxIdle;
 
                if (handle->callback)
                {
                    handle->callback(base, handle, kStatus_LPUART_RxIdle, handle->userData);
                }
            }
        }
 
        /* If use RX ring buffer, receive data to ring buffer. */
        if (handle->rxRingBuffer)
        {
            while (count--)
            {
                /* If RX ring buffer is full, trigger callback to notify over run. */
                if (LPUART_TransferIsRxRingBufferFull(base, handle))
                {
                    if (handle->callback)
                    {
                        handle->callback(base, handle, kStatus_LPUART_RxRingBufferOverrun, handle->userData);
                    }
                }
 
                /* If ring buffer is still full after callback function, the oldest data is overrided. */
                if (LPUART_TransferIsRxRingBufferFull(base, handle))
                {
                    /* Increase handle->rxRingBufferTail to make room for new data. */
                    if (handle->rxRingBufferTail + 1U == handle->rxRingBufferSize)
                    {
                        handle->rxRingBufferTail = 0U;
                    }
                    else
                    {
                        handle->rxRingBufferTail++;
                    }
                }
 
/* Read data. */
#if defined(FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT) && FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT
                if (handle->isSevenDataBits)
                {
                    handle->rxRingBuffer[handle->rxRingBufferHead] = (base->DATA & 0x7F);
                }
                else
                {
                    handle->rxRingBuffer[handle->rxRingBufferHead] = base->DATA;
                }
#else
                handle->rxRingBuffer[handle->rxRingBufferHead] = base->DATA;
#endif
 
                /* Increase handle->rxRingBufferHead. */
                if (handle->rxRingBufferHead + 1U == handle->rxRingBufferSize)
                {
                    handle->rxRingBufferHead = 0U;
                }
                else
                {
                    handle->rxRingBufferHead++;
                }
            }
        }
        /* If no receive requst pending, stop RX interrupt. */
        else if (!handle->rxDataSize)
        {
            LPUART_DisableInterrupts(base, kLPUART_RxDataRegFullInterruptEnable | kLPUART_RxOverrunInterruptEnable);
        }
        else
        {
        }
    }
 
    /* Send data register empty and the interrupt is enabled. */
    if ((kLPUART_TxDataRegEmptyFlag & status) && (kLPUART_TxDataRegEmptyInterruptEnable & enabledInterrupts))
    {
/* Get the bytes that available at this moment. */
#if defined(FSL_FEATURE_LPUART_HAS_FIFO) && FSL_FEATURE_LPUART_HAS_FIFO
        count = FSL_FEATURE_LPUART_FIFO_SIZEn(base) -
                ((base->WATER & LPUART_WATER_TXCOUNT_MASK) >> LPUART_WATER_TXCOUNT_SHIFT);
#else
        count = 1;
#endif
 
        while ((count) && (handle->txDataSize))
        {
#if defined(FSL_FEATURE_LPUART_HAS_FIFO) && FSL_FEATURE_LPUART_HAS_FIFO
            tempCount = MIN(handle->txDataSize, count);
#else
            tempCount = 1;
#endif
 
            /* Using non block API to write the data to the registers. */
            LPUART_WriteNonBlocking(base, handle->txData, tempCount);
            handle->txData += tempCount;
            handle->txDataSize -= tempCount;
            count -= tempCount;
 
            /* If all the data are written to data register, notify user with the callback, then TX finished. */
            if (!handle->txDataSize)
            {
                handle->txState = kLPUART_TxIdle;
 
                /* Disable TX register empty interrupt. */
                base->CTRL = (base->CTRL & ~LPUART_CTRL_TIE_MASK);
 
                /* Trigger callback. */
                if (handle->callback)
                {
                    handle->callback(base, handle, kStatus_LPUART_TxIdle, handle->userData);
                }
            }
        }
    }
}

Referenced by LPUART_TransferCreateHandle().

Here is the call graph for this function:

Here is the caller graph for this function:

LPUART_TransferReceiveNonBlocking()

status_t LPUART_TransferReceiveNonBlocking	(	LPUART_Type *	base,
		lpuart_handle_t *	handle,
		lpuart_transfer_t *	xfer,
		size_t *	receivedBytes
	)

Receives a buffer of data using the interrupt method.

This function receives data using an interrupt method. This is a non-blocking function which returns without waiting to ensure that all data are received. If the RX ring buffer is used and not empty, the data in the ring buffer is copied and the parameter receivedBytes shows how many bytes are copied from the ring buffer. After copying, if the data in the ring buffer is not enough for read, the receive request is saved by the LPUART driver. When the new data arrives, the receive request is serviced first. When all data is received, the LPUART driver notifies the upper layer through a callback function and passes a status parameter kStatus_UART_RxIdle. For example, the upper layer needs 10 bytes but there are only 5 bytes in ring buffer. The 5 bytes are copied to xfer->data, which returns with the parameter receivedBytes set to 5. For the remaining 5 bytes, the newly arrived data is saved from xfer->data[5]. When 5 bytes are received, the LPUART driver notifies the upper layer. If the RX ring buffer is not enabled, this function enables the RX and RX interrupt to receive data to xfer->data. When all data is received, the upper layer is notified.

Parameters

base	LPUART peripheral base address.
handle	LPUART handle pointer.
xfer	LPUART transfer structure, see #uart_transfer_t.
receivedBytes	Bytes received from the ring buffer directly.

Return values

kStatus_Success	Successfully queue the transfer into the transmit queue.
kStatus_LPUART_RxBusy	Previous receive request is not finished.
kStatus_InvalidArgument	Invalid argument.

brief Receives a buffer of data using the interrupt method.

This function receives data using an interrupt method. This is a non-blocking function which returns without waiting to ensure that all data are received. If the RX ring buffer is used and not empty, the data in the ring buffer is copied and the parameter p receivedBytes shows how many bytes are copied from the ring buffer. After copying, if the data in the ring buffer is not enough for read, the receive request is saved by the LPUART driver. When the new data arrives, the receive request is serviced first. When all data is received, the LPUART driver notifies the upper layer through a callback function and passes a status parameter ref kStatus_UART_RxIdle. For example, the upper layer needs 10 bytes but there are only 5 bytes in ring buffer. The 5 bytes are copied to xfer->data, which returns with the parameter p receivedBytes set to 5. For the remaining 5 bytes, the newly arrived data is saved from xfer->data[5]. When 5 bytes are received, the LPUART driver notifies the upper layer. If the RX ring buffer is not enabled, this function enables the RX and RX interrupt to receive data to xfer->data. When all data is received, the upper layer is notified.

param base LPUART peripheral base address. param handle LPUART handle pointer. param xfer LPUART transfer structure, see #uart_transfer_t. param receivedBytes Bytes received from the ring buffer directly. retval kStatus_Success Successfully queue the transfer into the transmit queue. retval kStatus_LPUART_RxBusy Previous receive request is not finished. retval kStatus_InvalidArgument Invalid argument.

Definition at line 1169 of file fsl_lpuart.c.

{
    assert(handle);
    assert(xfer);
    assert(xfer->data);
    assert(xfer->dataSize);
 
    uint32_t i;
    status_t status;
    /* How many bytes to copy from ring buffer to user memory. */
    size_t bytesToCopy = 0U;
    /* How many bytes to receive. */
    size_t bytesToReceive;
    /* How many bytes currently have received. */
    size_t bytesCurrentReceived;
 
    /* How to get data:
       1. If RX ring buffer is not enabled, then save xfer->data and xfer->dataSize
          to lpuart handle, enable interrupt to store received data to xfer->data. When
          all data received, trigger callback.
       2. If RX ring buffer is enabled and not empty, get data from ring buffer first.
          If there are enough data in ring buffer, copy them to xfer->data and return.
          If there are not enough data in ring buffer, copy all of them to xfer->data,
          save the xfer->data remained empty space to lpuart handle, receive data
          to this empty space and trigger callback when finished. */
 
    if (kLPUART_RxBusy == handle->rxState)
    {
        status = kStatus_LPUART_RxBusy;
    }
    else
    {
        bytesToReceive = xfer->dataSize;
        bytesCurrentReceived = 0;
 
        /* If RX ring buffer is used. */
        if (handle->rxRingBuffer)
        {
            /* Disable LPUART RX IRQ, protect ring buffer. */
            LPUART_DisableInterrupts(base, kLPUART_RxDataRegFullInterruptEnable);
 
            /* How many bytes in RX ring buffer currently. */
            bytesToCopy = LPUART_TransferGetRxRingBufferLength(base, handle);
 
            if (bytesToCopy)
            {
                bytesToCopy = MIN(bytesToReceive, bytesToCopy);
 
                bytesToReceive -= bytesToCopy;
 
                /* Copy data from ring buffer to user memory. */
                for (i = 0U; i < bytesToCopy; i++)
                {
                    xfer->data[bytesCurrentReceived++] = handle->rxRingBuffer[handle->rxRingBufferTail];
 
                    /* Wrap to 0. Not use modulo (%) because it might be large and slow. */
                    if (handle->rxRingBufferTail + 1U == handle->rxRingBufferSize)
                    {
                        handle->rxRingBufferTail = 0U;
                    }
                    else
                    {
                        handle->rxRingBufferTail++;
                    }
                }
            }
 
            /* If ring buffer does not have enough data, still need to read more data. */
            if (bytesToReceive)
            {
                /* No data in ring buffer, save the request to LPUART handle. */
                handle->rxData = xfer->data + bytesCurrentReceived;
                handle->rxDataSize = bytesToReceive;
                handle->rxDataSizeAll = bytesToReceive;
                handle->rxState = kLPUART_RxBusy;
            }
            /* Enable LPUART RX IRQ if previously enabled. */
            LPUART_EnableInterrupts(base, kLPUART_RxDataRegFullInterruptEnable);
 
            /* Call user callback since all data are received. */
            if (0 == bytesToReceive)
            {
                if (handle->callback)
                {
                    handle->callback(base, handle, kStatus_LPUART_RxIdle, handle->userData);
                }
            }
        }
        /* Ring buffer not used. */
        else
        {
            handle->rxData = xfer->data + bytesCurrentReceived;
            handle->rxDataSize = bytesToReceive;
            handle->rxDataSizeAll = bytesToReceive;
            handle->rxState = kLPUART_RxBusy;
 
            /* Enable RX interrupt. */
            LPUART_EnableInterrupts(base, kLPUART_RxDataRegFullInterruptEnable | kLPUART_RxOverrunInterruptEnable |
                                              kLPUART_IdleLineInterruptEnable);
        }
 
        /* Return the how many bytes have read. */
        if (receivedBytes)
        {
            *receivedBytes = bytesCurrentReceived;
        }
 
        status = kStatus_Success;
    }
 
    return status;
}

Referenced by uart_lld_start_receive().

Here is the call graph for this function:

Here is the caller graph for this function:

LPUART_TransferSendNonBlocking()

status_t LPUART_TransferSendNonBlocking	(	LPUART_Type *	base,
		lpuart_handle_t *	handle,
		lpuart_transfer_t *	xfer
	)

Transmits a buffer of data using the interrupt method.

This function send data using an interrupt method. This is a non-blocking function, which returns directly without waiting for all data written to the transmitter register. When all data is written to the TX register in the ISR, the LPUART driver calls the callback function and passes the kStatus_LPUART_TxIdle as status parameter.

Note

The kStatus_LPUART_TxIdle is passed to the upper layer when all data are written to the TX register. However, there is no check to ensure that all the data sent out. Before disabling the TX, check the kLPUART_TransmissionCompleteFlag to ensure that the transmit is finished.

Parameters

base	LPUART peripheral base address.
handle	LPUART handle pointer.
xfer	LPUART transfer structure, see lpuart_transfer_t.

Return values

kStatus_Success	Successfully start the data transmission.
kStatus_LPUART_TxBusy	Previous transmission still not finished, data not all written to the TX register.
kStatus_InvalidArgument	Invalid argument.

brief Transmits a buffer of data using the interrupt method.

This function send data using an interrupt method. This is a non-blocking function, which returns directly without waiting for all data written to the transmitter register. When all data is written to the TX register in the ISR, the LPUART driver calls the callback function and passes the ref kStatus_LPUART_TxIdle as status parameter.

note The kStatus_LPUART_TxIdle is passed to the upper layer when all data are written to the TX register. However, there is no check to ensure that all the data sent out. Before disabling the TX, check the kLPUART_TransmissionCompleteFlag to ensure that the transmit is finished.

param base LPUART peripheral base address. param handle LPUART handle pointer. param xfer LPUART transfer structure, see lpuart_transfer_t. retval kStatus_Success Successfully start the data transmission. retval kStatus_LPUART_TxBusy Previous transmission still not finished, data not all written to the TX register. retval kStatus_InvalidArgument Invalid argument.

Definition at line 1066 of file fsl_lpuart.c.

{
    assert(handle);
    assert(xfer);
    assert(xfer->data);
    assert(xfer->dataSize);
 
    status_t status;
 
    /* Return error if current TX busy. */
    if (kLPUART_TxBusy == handle->txState)
    {
        status = kStatus_LPUART_TxBusy;
    }
    else
    {
        handle->txData = xfer->data;
        handle->txDataSize = xfer->dataSize;
        handle->txDataSizeAll = xfer->dataSize;
        handle->txState = kLPUART_TxBusy;
 
        /* Enable transmitter interrupt. */
        LPUART_EnableInterrupts(base, kLPUART_TxDataRegEmptyInterruptEnable);
 
        status = kStatus_Success;
    }
 
    return status;
}

Here is the call graph for this function:

LPUART_TransferStartRingBuffer()

void LPUART_TransferStartRingBuffer	(	LPUART_Type *	base,
		lpuart_handle_t *	handle,
		uint8_t *	ringBuffer,
		size_t	ringBufferSize
	)

Sets up the RX ring buffer.

This function sets up the RX ring buffer to a specific UART handle.

When the RX ring buffer is used, data received is stored into the ring buffer even when the user doesn't call the UART_TransferReceiveNonBlocking() API. If there is already data received in the ring buffer, the user can get the received data from the ring buffer directly.

Note

When using RX ring buffer, one byte is reserved for internal use. In other words, if ringBufferSize is 32, then only 31 bytes are used for saving data.

Parameters

base	LPUART peripheral base address.
handle	LPUART handle pointer.
ringBuffer	Start address of ring buffer for background receiving. Pass NULL to disable the ring buffer.
ringBufferSize	size of the ring buffer.

brief Sets up the RX ring buffer.

This function sets up the RX ring buffer to a specific UART handle.

When the RX ring buffer is used, data received is stored into the ring buffer even when the user doesn't call the UART_TransferReceiveNonBlocking() API. If there is already data received in the ring buffer, the user can get the received data from the ring buffer directly.

note When using RX ring buffer, one byte is reserved for internal use. In other words, if p ringBufferSize is 32, then only 31 bytes are used for saving data.

param base LPUART peripheral base address. param handle LPUART handle pointer. param ringBuffer Start address of ring buffer for background receiving. Pass NULL to disable the ring buffer. param ringBufferSize size of the ring buffer.

Definition at line 1006 of file fsl_lpuart.c.

{
    assert(handle);
    assert(ringBuffer);
 
    /* Setup the ring buffer address */
    handle->rxRingBuffer = ringBuffer;
    handle->rxRingBufferSize = ringBufferSize;
    handle->rxRingBufferHead = 0U;
    handle->rxRingBufferTail = 0U;
 
    /* Enable the interrupt to accept the data when user need the ring buffer. */
    LPUART_EnableInterrupts(base, kLPUART_RxDataRegFullInterruptEnable | kLPUART_RxOverrunInterruptEnable);
}

Referenced by uart_lld_start().

Here is the call graph for this function:

Here is the caller graph for this function:

LPUART_TransferStopRingBuffer()

void LPUART_TransferStopRingBuffer	(	LPUART_Type *	base,
		lpuart_handle_t *	handle
	)

Aborts the background transfer and uninstalls the ring buffer.

This function aborts the background transfer and uninstalls the ring buffer.

Parameters

base	LPUART peripheral base address.
handle	LPUART handle pointer.

brief Aborts the background transfer and uninstalls the ring buffer.

This function aborts the background transfer and uninstalls the ring buffer.

param base LPUART peripheral base address. param handle LPUART handle pointer.

Definition at line 1032 of file fsl_lpuart.c.

{
    assert(handle);
 
    if (handle->rxState == kLPUART_RxIdle)
    {
        LPUART_DisableInterrupts(base, kLPUART_RxDataRegFullInterruptEnable | kLPUART_RxOverrunInterruptEnable);
    }
 
    handle->rxRingBuffer = NULL;
    handle->rxRingBufferSize = 0U;
    handle->rxRingBufferHead = 0U;
    handle->rxRingBufferTail = 0U;
}

Here is the call graph for this function:

LPUART_WriteBlocking()

void LPUART_WriteBlocking	(	LPUART_Type *	base,
		const uint8_t *	data,
		size_t	length
	)

Writes to the transmitter register using a blocking method.

This function polls the transmitter register, waits for the register to be empty or for TX FIFO to have room, and writes data to the transmitter buffer.

Note

This function does not check whether all data has been sent out to the bus. Before disabling the transmitter, check the kLPUART_TransmissionCompleteFlag to ensure that the transmit is finished.

Parameters

base	LPUART peripheral base address.
data	Start address of the data to write.
length	Size of the data to write.

brief Writes to the transmitter register using a blocking method.

This function polls the transmitter register, waits for the register to be empty or for TX FIFO to have room, and writes data to the transmitter buffer.

note This function does not check whether all data has been sent out to the bus. Before disabling the transmitter, check the kLPUART_TransmissionCompleteFlag to ensure that the transmit is finished.

param base LPUART peripheral base address. param data Start address of the data to write. param length Size of the data to write.

Definition at line 832 of file fsl_lpuart.c.

{
    assert(data);
 
    /* This API can only ensure that the data is written into the data buffer but can't
    ensure all data in the data buffer are sent into the transmit shift buffer. */
    while (length--)
    {
        while (!(base->STAT & LPUART_STAT_TDRE_MASK))
        {
        }
        base->DATA = *(data++);
    }
}

Referenced by uart_lld_blocking_send().

Here is the caller graph for this function:

LPUART_WriteByte()

static void LPUART_WriteByte ( LPUART_Type *  base, uint8_t  data  )

inlinestatic

Writes to the transmitter register.

This function writes data to the transmitter register directly. The upper layer must ensure that the TX register is empty or that the TX FIFO has room before calling this function.

Parameters

base	LPUART peripheral base address.
data	Data write to the TX register.

Definition at line 587 of file fsl_lpuart.h.

{
    base->DATA = data;
}

Variable Documentation

baudRate_Bps

uint32_t _lpuart_config::baudRate_Bps

LPUART baud rate

Definition at line 191 of file fsl_lpuart.h.

Referenced by uart_lld_start().

callback

lpuart_transfer_callback_t _lpuart_handle::callback

Callback function.

Definition at line 242 of file fsl_lpuart.h.

Referenced by LPUART_TransferCreateHandle(), LPUART_TransferHandleIRQ(), and LPUART_TransferReceiveNonBlocking().

data

uint8_t* _lpuart_transfer::data

The buffer of data to be transfer.

Definition at line 217 of file fsl_lpuart.h.

Referenced by LPUART_ReceiveEDMA(), LPUART_SendEDMA(), LPUART_TransferReceiveNonBlocking(), LPUART_TransferSendNonBlocking(), uart_lld_start_receive(), and uart_lld_start_send().

dataBitsCount

lpuart_data_bits_t _lpuart_config::dataBitsCount

Data bits count, eight (default), seven

Definition at line 193 of file fsl_lpuart.h.

Referenced by uart_lld_start().

dataSize

size_t _lpuart_transfer::dataSize

The byte count to be transfer.

Definition at line 218 of file fsl_lpuart.h.

Referenced by LPUART_ReceiveEDMA(), LPUART_SendEDMA(), LPUART_TransferReceiveNonBlocking(), LPUART_TransferSendNonBlocking(), uart_lld_start_receive(), and uart_lld_start_send().

enableRx

bool _lpuart_config::enableRx

Enable RX

Definition at line 211 of file fsl_lpuart.h.

Referenced by uart_lld_start().

enableRxRTS

bool _lpuart_config::enableRxRTS

RX RTS enable

Definition at line 203 of file fsl_lpuart.h.

enableTx

bool _lpuart_config::enableTx

Enable TX

Definition at line 210 of file fsl_lpuart.h.

Referenced by uart_lld_start().

enableTxCTS

bool _lpuart_config::enableTxCTS

TX CTS enable

Definition at line 204 of file fsl_lpuart.h.

isMsb

bool _lpuart_config::isMsb

Data bits order, LSB (default), MSB

Definition at line 194 of file fsl_lpuart.h.

isSevenDataBits

bool _lpuart_handle::isSevenDataBits

Seven data bits flag.

Definition at line 249 of file fsl_lpuart.h.

Referenced by LPUART_TransferCreateHandle(), and LPUART_TransferHandleIRQ().

parityMode

lpuart_parity_mode_t _lpuart_config::parityMode

Parity mode, disabled (default), even, odd

Definition at line 192 of file fsl_lpuart.h.

Referenced by uart_lld_start().

rxData

uint8_t* volatile _lpuart_handle::rxData

Address of remaining data to receive.

Definition at line 233 of file fsl_lpuart.h.

Referenced by LPUART_TransferHandleIRQ(), and LPUART_TransferReceiveNonBlocking().

rxDataSize

volatile size_t _lpuart_handle::rxDataSize

Size of the remaining data to receive.

Definition at line 234 of file fsl_lpuart.h.

Referenced by LPUART_TransferAbortReceive(), LPUART_TransferGetReceiveCount(), LPUART_TransferHandleIRQ(), and LPUART_TransferReceiveNonBlocking().

rxDataSizeAll

size_t _lpuart_handle::rxDataSizeAll

Size of the data to receive.

Definition at line 235 of file fsl_lpuart.h.

Referenced by LPUART_TransferGetReceiveCount(), LPUART_TransferReceiveNonBlocking(), and uart_lld_stop_receive().

rxFifoWatermark

uint8_t _lpuart_config::rxFifoWatermark

RX FIFO watermark

Definition at line 200 of file fsl_lpuart.h.

Referenced by uart_lld_start().

rxIdleConfig

lpuart_idle_config_t _lpuart_config::rxIdleConfig

RX IDLE configuration.

Definition at line 209 of file fsl_lpuart.h.

rxIdleType

lpuart_idle_type_select_t _lpuart_config::rxIdleType

RX IDLE type.

Definition at line 208 of file fsl_lpuart.h.

rxRingBuffer

uint8_t* _lpuart_handle::rxRingBuffer

Start address of the receiver ring buffer.

Definition at line 237 of file fsl_lpuart.h.

Referenced by LPUART_TransferAbortReceive(), LPUART_TransferHandleIRQ(), LPUART_TransferReceiveNonBlocking(), LPUART_TransferStartRingBuffer(), and LPUART_TransferStopRingBuffer().

rxRingBufferHead

volatile uint16_t _lpuart_handle::rxRingBufferHead

Index for the driver to store received data into ring buffer.

Definition at line 239 of file fsl_lpuart.h.

Referenced by LPUART_TransferGetRxRingBufferLength(), LPUART_TransferHandleIRQ(), LPUART_TransferStartRingBuffer(), and LPUART_TransferStopRingBuffer().

rxRingBufferSize

size_t _lpuart_handle::rxRingBufferSize

Size of the ring buffer.

Definition at line 238 of file fsl_lpuart.h.

Referenced by LPUART_TransferGetRxRingBufferLength(), LPUART_TransferHandleIRQ(), LPUART_TransferIsRxRingBufferFull(), LPUART_TransferReceiveNonBlocking(), LPUART_TransferStartRingBuffer(), and LPUART_TransferStopRingBuffer().

rxRingBufferTail

volatile uint16_t _lpuart_handle::rxRingBufferTail

Index for the user to get data from the ring buffer.

Definition at line 240 of file fsl_lpuart.h.

Referenced by LPUART_TransferGetRxRingBufferLength(), LPUART_TransferHandleIRQ(), LPUART_TransferReceiveNonBlocking(), LPUART_TransferStartRingBuffer(), and LPUART_TransferStopRingBuffer().

rxState

volatile uint8_t _lpuart_handle::rxState

RX transfer state.

Definition at line 246 of file fsl_lpuart.h.

Referenced by LPUART_TransferAbortReceive(), LPUART_TransferCreateHandle(), LPUART_TransferGetReceiveCount(), LPUART_TransferHandleIRQ(), LPUART_TransferReceiveNonBlocking(), and LPUART_TransferStopRingBuffer().

stopBitCount

lpuart_stop_bit_count_t _lpuart_config::stopBitCount

Number of stop bits, 1 stop bit (default) or 2 stop bits

Definition at line 196 of file fsl_lpuart.h.

Referenced by uart_lld_start().

txCtsConfig

lpuart_transmit_cts_config_t _lpuart_config::txCtsConfig

TX CTS configure

Definition at line 206 of file fsl_lpuart.h.

txCtsSource

lpuart_transmit_cts_source_t _lpuart_config::txCtsSource

TX CTS source

Definition at line 205 of file fsl_lpuart.h.

txData

uint8_t* volatile _lpuart_handle::txData

Address of remaining data to send.

Definition at line 230 of file fsl_lpuart.h.

Referenced by LPUART_TransferHandleIRQ(), and LPUART_TransferSendNonBlocking().

txDataSize

volatile size_t _lpuart_handle::txDataSize

Size of the remaining data to send.

Definition at line 231 of file fsl_lpuart.h.

Referenced by LPUART_TransferAbortSend(), LPUART_TransferGetSendCount(), LPUART_TransferHandleIRQ(), and LPUART_TransferSendNonBlocking().

txDataSizeAll

size_t _lpuart_handle::txDataSizeAll

Size of the data to send out.

Definition at line 232 of file fsl_lpuart.h.

Referenced by LPUART_TransferGetSendCount(), and LPUART_TransferSendNonBlocking().

txFifoWatermark

uint8_t _lpuart_config::txFifoWatermark

TX FIFO watermark

Definition at line 199 of file fsl_lpuart.h.

Referenced by uart_lld_start().

txState

volatile uint8_t _lpuart_handle::txState

TX transfer state.

Definition at line 245 of file fsl_lpuart.h.

Referenced by LPUART_TransferAbortSend(), LPUART_TransferCreateHandle(), LPUART_TransferGetSendCount(), LPUART_TransferHandleIRQ(), and LPUART_TransferSendNonBlocking().

userData

void* _lpuart_handle::userData

LPUART callback function parameter.

Definition at line 243 of file fsl_lpuart.h.

Referenced by LPUART_TransferCreateHandle(), LPUART_TransferHandleIRQ(), and LPUART_TransferReceiveNonBlocking().