UART

Data Structures
struct	UARTConfig
	Driver configuration structure. More...
struct	UARTDriver
	Structure representing an UART driver. More...

Typedefs
typedef uint32_t	uartflags_t
	UART driver condition flags type.
typedef struct UARTDriver	UARTDriver
	Structure representing an UART driver.
typedef void(*	uartcb_t) (UARTDriver *uartp)
	Generic UART notification callback type.
typedef void(*	uartccb_t) (UARTDriver *uartp, uint16_t c)
	Character received UART notification callback type.
typedef void(*	uartecb_t) (UARTDriver *uartp, uartflags_t e)
	Receive error UART notification callback type.
typedef void(*	uarthcb_t) (UARTDriver *uartp, uartflags_t full)
	Receive Half-transfer UART notification callback type.

Functions
static void	uart_enter_rx_idle_loop (UARTDriver *uartp)
	Puts the receiver in the UART_RX_IDLE state.
void	uart_lld_callback (LPUART_Type *base, void *handle, status_t status, void *userData)
void	uart_lld_init (void)
	Low level UART driver initialization.
void	uart_lld_start (UARTDriver *uartp)
	Configures and activates the UART peripheral.
void	uart_lld_stop (UARTDriver *uartp)
	Deactivates the UART peripheral.
void	uart_lld_start_send (UARTDriver *uartp, size_t n, const void *txbuf)
	Starts a transmission on the UART peripheral.
size_t	uart_lld_stop_send (UARTDriver *uartp)
	Stops any ongoing transmission.
void	uart_lld_start_receive (UARTDriver *uartp, size_t n, void *rxbuf)
	Starts a receive operation on the UART peripheral.
size_t	uart_lld_stop_receive (UARTDriver *uartp)
	Stops any ongoing receive operation.
void	uart_lld_blocking_send (UARTDriver *uartp, size_t n, const void *txbuf)

Variables
UARTDriver	UARTD1
	UART1 driver identifier.
UARTDriver	UARTD2
UARTDriver	UARTD3
UARTDriver	UARTD1
	UART1 driver identifier.
UARTDriver	UARTD2
UARTDriver	UARTD3

Detailed Description

Typedef Documentation

uartcb_t

typedef void(* uartcb_t) (UARTDriver *uartp)

Generic UART notification callback type.

Parameters

[in]

uartp

pointer to the UARTDriver object

Definition at line 98 of file hal_uart_lld.h.

uartccb_t

typedef void(* uartccb_t) (UARTDriver *uartp, uint16_t c)

Character received UART notification callback type.

Parameters

[in]	uartp	pointer to the UARTDriver object
[in]	c	received character

Definition at line 106 of file hal_uart_lld.h.

UARTDriver

typedef struct UARTDriver UARTDriver

Structure representing an UART driver.

Definition at line 91 of file hal_uart_lld.h.

uartecb_t

typedef void(* uartecb_t) (UARTDriver *uartp, uartflags_t e)

Receive error UART notification callback type.

Parameters

[in]	uartp	pointer to the UARTDriver object
[in]	e	receive error mask

Definition at line 114 of file hal_uart_lld.h.

uartflags_t

typedef uint32_t uartflags_t

UART driver condition flags type.

Definition at line 86 of file hal_uart_lld.h.

uarthcb_t

typedef void(* uarthcb_t) (UARTDriver *uartp, uartflags_t full)

Receive Half-transfer UART notification callback type.

Parameters

[in]	uartp	pointer to the UARTDriver object
[in]	full	flag set to 1 for the second half, and 0 for the first half

Definition at line 122 of file hal_uart_lld.h.

Function Documentation

uart_enter_rx_idle_loop()

static void uart_enter_rx_idle_loop ( UARTDriver *  uartp )

static

Puts the receiver in the UART_RX_IDLE state.

Parameters

[in]

uartp

pointer to the UARTDriver object

Definition at line 65 of file hal_uart_lld.c.

                                                       {
}

uart_lld_blocking_send()

void uart_lld_blocking_send	(	UARTDriver *	uartp,
		size_t	n,
		const void *	txbuf
	)

Definition at line 395 of file hal_uart_lld.c.

                                                                            {
    LPUART_WriteBlocking(uartp->lpuart, txbuf, n);
}

Here is the call graph for this function:

uart_lld_callback()

void uart_lld_callback	(	LPUART_Type *	base,
		void *	handle,
		status_t	status,
		void *	userData
	)

Definition at line 72 of file hal_uart_lld.c.

                                                                                         {
    UARTDriver *uartp = (UARTDriver *)userData;
#ifdef UART_USE_RING_BUFFER
    // FSL LPUART lib can call this callback from anywhere, that's not good! :(
    if (!port_is_isr_context()) {
        // we cannot just call _uart_rx_complete_isr_code() without failing on osalSysLockFromISR(),
        // so we have to trigger an IRQ interrupt to wake-up the thread after osalThreadSuspendTimeoutS()
        // (See uartReceiveTimeout())
        // We use 'LPUART_STAT_RXINV_MASK' just because it's unused flag 
        // and we can pass the status into the IRQ handler.
        // todo: this is a hack! :( is there a better way?
        base->STAT |= LPUART_STAT_RXINV_MASK;
        NVIC_SetPendingIRQ(uartp->pendingRxIrq);
        return;
    }
 
#endif /* UART_USE_RING_BUFFER */
 
    // this is a common part for both interrupt-ring mode and DMA mode
    switch (status) {
    case kStatus_LPUART_TxIdle:
        _uart_tx1_isr_code(uartp);
        break;
    case kStatus_LPUART_RxIdle:
        _uart_rx_complete_isr_code(uartp);
        break;
    case kStatus_LPUART_RxHardwareOverrun:
    case kStatus_LPUART_RxRingBufferOverrun:
        _uart_rx_error_isr_code(uartp, UART_OVERRUN_ERROR);
        break;
    case kStatus_LPUART_FramingError:
        _uart_rx_error_isr_code(uartp, UART_FRAMING_ERROR);
        break;
    case kStatus_LPUART_ParityError:
        _uart_rx_error_isr_code(uartp, UART_PARITY_ERROR);
        break;
    case kStatus_LPUART_NoiseError:
        _uart_rx_error_isr_code(uartp, UART_NOISE_ERROR);
        break;
    }
}

Referenced by uart_lld_start().

Here is the caller graph for this function:

uart_lld_init()

void uart_lld_init

(

void

)

Low level UART driver initialization.

@notapi

Definition at line 123 of file hal_uart_lld.c.

                         {
 
#if KINETIS_UART_USE_UART1 == TRUE
  /* Driver initialization.*/
  uartObjectInit(&UARTD1);
#endif
 
#if KINETIS_UART_USE_UART2 == TRUE
  /* Driver initialization.*/
  uartObjectInit(&UARTD2);
#endif
 
#if KINETIS_UART_USE_UART3 == TRUE
  /* Driver initialization.*/
  uartObjectInit(&UARTD3);
#endif
}

uart_lld_start()

void uart_lld_start

(

UARTDriver *

uartp

)

Configures and activates the UART peripheral.

Parameters

[in]

uartp

pointer to the UARTDriver object

@notapi

Definition at line 148 of file hal_uart_lld.c.

                                       {
 
  if (uartp->state == UART_STOP) {
    lpuart_config_t lpuartConfig;
    LPUART_GetDefaultConfig(&lpuartConfig);
    lpuartConfig.enableTx = true;
    lpuartConfig.enableRx = true;
    lpuartConfig.baudRate_Bps = uartp->config->speed;
    lpuartConfig.parityMode = (uartp->config->cr1 & USART_CR1_PCE) ? 
                            ((uartp->config->cr1 & USART_CR1_PS) ? kLPUART_ParityOdd : kLPUART_ParityEven) : 
                            kLPUART_ParityDisabled;
    lpuartConfig.dataBitsCount = kLPUART_EightDataBits; // todo: check for USART_CR1_M?
    lpuartConfig.stopBitCount = (uartp->config->cr2 & USART_CR2_STOP2_BITS) ? kLPUART_TwoStopBit : kLPUART_OneStopBit;
#ifdef UART_USE_RING_BUFFER
    lpuartConfig.txFifoWatermark = 0;
    lpuartConfig.rxFifoWatermark = 1;
#endif /* UART_USE_RING_BUFFER */
 
    dma_request_source_t reqRx, reqTx;
    uint32_t dmaStreamRx, dmaStreamTx;
 
#if KINETIS_UART_USE_UART1 == TRUE
    if (&UARTD1 == uartp) {
        uartp->lpuart = LPUART0;
        reqRx = kDmaRequestMux0LPUART0Rx;
        reqTx = kDmaRequestMux0LPUART0Tx;
        dmaStreamRx = KINETIS_DMA_STREAM_UART0_RX;
        dmaStreamTx = KINETIS_DMA_STREAM_UART0_TX;
        nvicEnableVector(LPUART0_TX_IRQn, KINETIS_UART0_IRQ_PRIORITY);
        nvicEnableVector(LPUART0_RX_IRQn, KINETIS_UART0_IRQ_PRIORITY);
        uartp->pendingRxIrq = LPUART0_RX_IRQn;
    }
#endif
#if KINETIS_UART_USE_UART2 == TRUE
    if (&UARTD2 == uartp) {
        uartp->lpuart = LPUART1;
        reqRx = kDmaRequestMux0LPUART1Rx;
        reqTx = kDmaRequestMux0LPUART1Tx;
        dmaStreamRx = KINETIS_DMA_STREAM_UART1_RX;
        dmaStreamTx = KINETIS_DMA_STREAM_UART1_TX;
        nvicEnableVector(LPUART1_TX_IRQn, KINETIS_UART1_IRQ_PRIORITY);
        nvicEnableVector(LPUART1_RX_IRQn, KINETIS_UART1_IRQ_PRIORITY);
        uartp->pendingRxIrq = LPUART1_RX_IRQn;
    }
#endif
#if KINETIS_UART_USE_UART3 == TRUE
    if (&UARTD3 == uartp) {
        uartp->lpuart = LPUART2;
        reqRx = kDmaRequestMux0LPUART2Rx;
        reqTx = kDmaRequestMux0LPUART2Tx;
        dmaStreamRx = KINETIS_DMA_STREAM_UART2_RX;
        dmaStreamTx = KINETIS_DMA_STREAM_UART2_TX;
        nvicEnableVector(LPUART2_TX_IRQn, KINETIS_UART2_IRQ_PRIORITY);
        nvicEnableVector(LPUART2_RX_IRQn, KINETIS_UART2_IRQ_PRIORITY);
        uartp->pendingRxIrq = LPUART2_RX_IRQn;
    }
#endif
    // Enable UART
    status_t status = LPUART_Init(uartp->lpuart, &lpuartConfig, KINETIS_UART_FREQUENCY);
    if (status == kStatus_LPUART_BaudrateNotSupport) {
        // the only reason we could fail is wrong 'baudRate_Bps'. So let's give it a second chance...
        static const int defaultBaudRate = 115200;
        lpuartConfig.baudRate_Bps = defaultBaudRate;
        status = LPUART_Init(uartp->lpuart, &lpuartConfig, KINETIS_UART_FREQUENCY);
        assert (status == kStatus_Success);
    }
 
    //LPUART_EnableInterrupts(uartp->lpuart, kLPUART_IdleLineInterruptEnable);
 
    // Enable DMA
    nvicEnableVector(DMA0_IRQn + dmaStreamRx, KINETIS_UART_DMA_IRQ_PRIORITY);
    nvicEnableVector(DMA0_IRQn + dmaStreamTx, KINETIS_UART_DMA_IRQ_PRIORITY);
    
    EDMA_CreateHandle(&uartp->lpuartRxEdmaHandle, DMA0, dmaStreamRx); 
    EDMA_CreateHandle(&uartp->lpuartTxEdmaHandle, DMA0, dmaStreamTx); 
 
    DMAMUX_SetSource(DMAMUX, dmaStreamRx, reqRx);
    DMAMUX_EnableChannel(DMAMUX, dmaStreamRx);
    
    DMAMUX_SetSource(DMAMUX, dmaStreamTx, reqTx);
    DMAMUX_EnableChannel(DMAMUX, dmaStreamTx);
 
    LPUART_TransferCreateHandleEDMA(uartp->lpuart, &uartp->dmaHandle, (lpuart_edma_transfer_callback_t)uart_lld_callback, 
                uartp, &uartp->lpuartTxEdmaHandle, &uartp->lpuartRxEdmaHandle);
 
    // This is needed not only for the Ring-buffer mode, but also for the EDMA mode - for UART error handling!
    LPUART_TransferCreateHandle(uartp->lpuart, &uartp->rxHandle, (lpuart_transfer_callback_t)uart_lld_callback, uartp);
 
#ifdef UART_USE_RING_BUFFER
    LPUART_TransferStartRingBuffer(uartp->lpuart, &uartp->rxHandle, uartp->rxRingBuffer, KINETIS_UART_RX_RING_BUFFER_SIZE);
#endif
  }
 
  uartp->rxstate = UART_RX_IDLE;
  uartp->txstate = UART_TX_IDLE;
}

Here is the call graph for this function:

uart_lld_start_receive()

void uart_lld_start_receive	(	UARTDriver *	uartp,
		size_t	n,
		void *	rxbuf
	)

Starts a receive operation on the UART peripheral.

Note

The buffers are organized as uint8_t arrays for data sizes below or equal to 8 bits else it is organized as uint16_t arrays.

Parameters

[in]	uartp	pointer to the UARTDriver object
[in]	n	number of data frames to send
[out]	rxbuf	the pointer to the receive buffer

@notapi

Definition at line 338 of file hal_uart_lld.c.

                                                                      {
    lpuart_transfer_t xfer;
    xfer.data = (uint8_t *)rxbuf;
    xfer.dataSize = n;
   
#ifdef UART_USE_RING_BUFFER
    size_t receivedBytes = 0U;
    /*status_t status = */LPUART_TransferReceiveNonBlocking(uartp->lpuart, &uartp->rxHandle, &xfer, &receivedBytes);
    // todo: check receivedBytes?
#else
    /*status_t status = */LPUART_ReceiveEDMA(uartp->lpuart, &uartp->dmaHandle, &xfer);
    // This is needed for UART error handling
    LPUART_EnableInterrupts(uartp->lpuart, kLPUART_RxDataRegFullInterruptEnable | kLPUART_RxOverrunInterruptEnable);
#endif /* UART_USE_RING_BUFFER */   
    // todo: check status
}

Here is the call graph for this function:

uart_lld_start_send()

void uart_lld_start_send	(	UARTDriver *	uartp,
		size_t	n,
		const void *	txbuf
	)

Starts a transmission on the UART peripheral.

Note

The buffers are organized as uint8_t arrays for data sizes below or equal to 8 bits else it is organized as uint16_t arrays.

Parameters

[in]	uartp	pointer to the UARTDriver object
[in]	n	number of data frames to send
[in]	txbuf	the pointer to the transmit buffer

@notapi

Definition at line 299 of file hal_uart_lld.c.

                                                                         {
 
    lpuart_transfer_t xfer;
    xfer.data = (uint8_t *)txbuf;
    xfer.dataSize = n;
    
    /*status_t status = */LPUART_SendEDMA(uartp->lpuart, &uartp->dmaHandle, &xfer);
    // todo: check status
}

Here is the call graph for this function:

uart_lld_stop()

void uart_lld_stop

(

UARTDriver *

uartp

)

Deactivates the UART peripheral.

Parameters

[in]

uartp

pointer to the UARTDriver object

@notapi

Definition at line 252 of file hal_uart_lld.c.

                                      {
 
  if (uartp->state == UART_READY) {
    /* Resets the peripheral.*/
 
    /* Disables the peripheral.*/
#if KINETIS_UART_USE_UART1 == TRUE
    if (&UARTD1 == uartp) {
        nvicDisableVector(LPUART0_TX_IRQn);
        nvicDisableVector(LPUART0_RX_IRQn);
        DMAMUX_DisableChannel(DMAMUX, KINETIS_DMA_STREAM_UART0_RX);
        DMAMUX_DisableChannel(DMAMUX, KINETIS_DMA_STREAM_UART0_TX);
        LPUART_Deinit(LPUART0);
    }
#endif
#if KINETIS_UART_USE_UART2 == TRUE
    if (&UARTD2 == uartp) {
        nvicDisableVector(LPUART1_TX_IRQn);
        nvicDisableVector(LPUART1_RX_IRQn);
        DMAMUX_DisableChannel(DMAMUX, KINETIS_DMA_STREAM_UART1_RX);
        DMAMUX_DisableChannel(DMAMUX, KINETIS_DMA_STREAM_UART1_TX);
        LPUART_Deinit(LPUART1);
    }
#endif
#if KINETIS_UART_USE_UART3 == TRUE
    if (&UARTD3 == uartp) {
        nvicDisableVector(LPUART2_TX_IRQn);
        nvicDisableVector(LPUART2_RX_IRQn);
        DMAMUX_DisableChannel(DMAMUX, KINETIS_DMA_STREAM_UART2_RX);
        DMAMUX_DisableChannel(DMAMUX, KINETIS_DMA_STREAM_UART2_TX);
        LPUART_Deinit(LPUART2);
    }
#endif
  }
}

Here is the call graph for this function:

uart_lld_stop_receive()

size_t uart_lld_stop_receive

(

UARTDriver *

uartp

)

Stops any ongoing receive operation.

Note

Stopping a receive operation also suppresses the receive callbacks.

Parameters

[in]

uartp

pointer to the UARTDriver object

Returns

The number of data frames not received by the stopped receive operation.

@notapi

Definition at line 366 of file hal_uart_lld.c.

                                                {
 
  uint32_t numReceived = 0;
#ifdef UART_USE_RING_BUFFER
    if (LPUART_TransferGetReceiveCount(uartp->lpuart, &uartp->rxHandle, &numReceived) == kStatus_NoTransferInProgress)
    {
        return 0;
    }
 
    LPUART_TransferAbortReceive(uartp->lpuart, &uartp->rxHandle);
    
    return uartp->rxHandle.rxDataSizeAll - (size_t)numReceived;
#else
    // let's do it before LPUART_TransferGetReceiveCountEDMA()?
    LPUART_EnableRxDMA(uartp->lpuart, false);
 
    if (LPUART_TransferGetReceiveCountEDMA(uartp->lpuart, &uartp->dmaHandle, &numReceived) == kStatus_NoTransferInProgress) {
        //numReceived = uartp->dmaHandle.rxDataSizeAll;
        return 0;
    }
  
    LPUART_TransferAbortReceiveEDMA(uartp->lpuart, &uartp->dmaHandle);
 
    return uartp->dmaHandle.rxDataSizeAll - (size_t)numReceived;
#endif /* UART_USE_RING_BUFFER */
}

Here is the call graph for this function:

uart_lld_stop_send()

size_t uart_lld_stop_send

(

UARTDriver *

uartp

)

Stops any ongoing transmission.

Note

Stopping a transmission also suppresses the transmission callbacks.

Parameters

[in]

uartp

pointer to the UARTDriver object

Returns

The number of data frames not transmitted by the stopped transmit operation.

@notapi

Definition at line 320 of file hal_uart_lld.c.

                                             {
 
  LPUART_TransferAbortSendEDMA(uartp->lpuart, &uartp->dmaHandle);
 
  return 0;
}

Here is the call graph for this function:

Variable Documentation

UARTD1 [1/2]

UARTDriver UARTD1

UART1 driver identifier.

Definition at line 43 of file hal_uart_lld.c.

Referenced by uart_lld_init(), uart_lld_start(), and uart_lld_stop().

UARTD1 [2/2]

UARTDriver UARTD1

extern

UART1 driver identifier.

Definition at line 43 of file hal_uart_lld.c.

Referenced by uart_lld_init(), uart_lld_start(), and uart_lld_stop().

UARTD2 [1/2]

UARTDriver UARTD2

Definition at line 46 of file hal_uart_lld.c.

Referenced by uart_lld_init(), uart_lld_start(), and uart_lld_stop().

UARTD2 [2/2]

UARTDriver UARTD2

extern

Definition at line 46 of file hal_uart_lld.c.

Referenced by uart_lld_init(), uart_lld_start(), and uart_lld_stop().

UARTD3 [1/2]

UARTDriver UARTD3

Definition at line 49 of file hal_uart_lld.c.

Referenced by uart_lld_init(), uart_lld_start(), and uart_lld_stop().

UARTD3 [2/2]

UARTDriver UARTD3

extern

Definition at line 49 of file hal_uart_lld.c.

Referenced by uart_lld_init(), uart_lld_start(), and uart_lld_stop().