static int mcux_lpuart_irq_rx_full(struct device *dev) { const struct mcux_lpuart_config *config = dev->config->config_info; u32_t flags = LPUART_GetStatusFlags(config->base); return (flags & kLPUART_RxDataRegFullFlag) != 0; }
/** * Uart common interrupt process. This need add to uart ISR. * * @param serial serial device */ static void uart_isr(struct rt_serial_device *serial) { struct imxrt_uart *uart; LPUART_Type *base; RT_ASSERT(serial != RT_NULL); uart = (struct imxrt_uart *) serial->parent.user_data; RT_ASSERT(uart != RT_NULL); base = uart->uart_base; RT_ASSERT(base != RT_NULL); /* enter interrupt */ rt_interrupt_enter(); /* UART in mode Receiver -------------------------------------------------*/ if (LPUART_GetStatusFlags(base) & kLPUART_RxDataRegFullFlag) { rt_hw_serial_isr(serial, RT_SERIAL_EVENT_RX_IND); } /* If RX overrun. */ if (LPUART_STAT_OR_MASK & base->STAT) { /* Clear overrun flag, otherwise the RX does not work. */ base->STAT = ((base->STAT & 0x3FE00000U) | LPUART_STAT_OR_MASK); } /* leave interrupt */ rt_interrupt_leave(); }
static int mcux_lpuart_irq_tx_complete(struct device *dev) { const struct mcux_lpuart_config *config = dev->config->config_info; u32_t flags = LPUART_GetStatusFlags(config->base); return (flags & kLPUART_TxDataRegEmptyFlag) != 0; }
int serial_writable(serial_t *obj) { uint32_t status_flags = LPUART_GetStatusFlags(uart_addrs[obj->index]); if (status_flags & kLPUART_RxOverrunFlag) LPUART_ClearStatusFlags(uart_addrs[obj->index], kLPUART_RxOverrunFlag); return (status_flags & kLPUART_TxDataRegEmptyFlag); }
int serial_readable(serial_t *obj) { uint32_t status_flags = LPUART_GetStatusFlags(uart_addrs[obj->index]); if (status_flags & kLPUART_RxOverrunFlag) { LPUART_ClearStatusFlags(uart_addrs[obj->index], kLPUART_RxOverrunFlag); } return (status_flags & kLPUART_RxDataRegFullFlag); }
static int imxrt_putc(struct rt_serial_device *serial, char ch) { struct imxrt_uart *uart; RT_ASSERT(serial != RT_NULL); uart = (struct imxrt_uart *)serial->parent.user_data; LPUART_WriteByte(uart->uart_base, ch); while (!(LPUART_GetStatusFlags(uart->uart_base) & kLPUART_TxDataRegEmptyFlag)); return 1; }
static unsigned char mcux_lpuart_poll_out(struct device *dev, unsigned char c) { const struct mcux_lpuart_config *config = dev->config->config_info; while (!(LPUART_GetStatusFlags(config->base) & kLPUART_TxDataRegEmptyFlag)) ; LPUART_WriteByte(config->base, c); return c; }
static int imxrt_getc(struct rt_serial_device *serial) { int ch; struct imxrt_uart *uart; RT_ASSERT(serial != RT_NULL); uart = (struct imxrt_uart *)serial->parent.user_data; ch = -1; if (LPUART_GetStatusFlags(uart->uart_base) & kLPUART_RxDataRegFullFlag) ch = LPUART_ReadByte(uart->uart_base); return ch; }
static int mcux_lpuart_poll_in(struct device *dev, unsigned char *c) { const struct mcux_lpuart_config *config = dev->config->config_info; u32_t flags = LPUART_GetStatusFlags(config->base); int ret = -1; if (flags & kLPUART_RxDataRegFullFlag) { *c = LPUART_ReadByte(config->base); ret = 0; } return ret; }
static int mcux_lpuart_fifo_read(struct device *dev, u8_t *rx_data, const int len) { const struct mcux_lpuart_config *config = dev->config->config_info; u8_t num_rx = 0; while ((len - num_rx > 0) && (LPUART_GetStatusFlags(config->base) & kLPUART_RxDataRegFullFlag)) { rx_data[num_rx++] = LPUART_ReadByte(config->base); } return num_rx; }
static int mcux_lpuart_fifo_fill(struct device *dev, const u8_t *tx_data, int len) { const struct mcux_lpuart_config *config = dev->config->config_info; u8_t num_tx = 0; while ((len - num_tx > 0) && (LPUART_GetStatusFlags(config->base) & kLPUART_TxDataRegEmptyFlag)) { LPUART_WriteByte(config->base, tx_data[num_tx++]); } return num_tx; }
void BOARD_CELL_UART_IRQ_HANDLER(void) { if ((kLPUART_RxDataRegFullFlag) & LPUART_GetStatusFlags(BOARD_CELL_UART)) { uint8_t data = LPUART_ReadByte(BOARD_CELL_UART); // it may be necessary to create a critical section here, but // right now it didn't hurt us to not disable interrupts // __disable_irq(); /* If ring buffer is not full, add data to ring buffer. */ if (((gsmRxIndex + 1) % GSM_RINGBUFFER_SIZE) != gsmRxHead) { gsmUartRingBuffer[gsmRxIndex++] = data; gsmRxIndex %= GSM_RINGBUFFER_SIZE; } // __enable_irq(); } }
void DEMO_LPUART_IRQHandler(void) { uint8_t data; /* If new data arrived. */ if ((kLPUART_RxDataRegFullFlag)&LPUART_GetStatusFlags(DEMO_LPUART)) { data = LPUART_ReadByte(DEMO_LPUART); /* If ring buffer is not full, add data to ring buffer. */ if (((rxIndex + 1) % DEMO_RING_BUFFER_SIZE) != txIndex) { demoRingBuffer[rxIndex] = data; rxIndex++; rxIndex %= DEMO_RING_BUFFER_SIZE; } } }
/*! * @brief Main function */ int main(void) { lpuart_config_t config; BOARD_InitPins(); BOARD_BootClockRUN(); CLOCK_SetLpuart1Clock(1U); /* * config.baudRate_Bps = 115200U; * config.parityMode = kLPUART_ParityDisabled; * config.stopBitCount = kLPUART_OneStopBit; * config.txFifoWatermark = 0; * config.rxFifoWatermark = 0; * config.enableTx = false; * config.enableRx = false; */ LPUART_GetDefaultConfig(&config); config.baudRate_Bps = BOARD_DEBUG_UART_BAUDRATE; config.enableTx = true; config.enableRx = true; LPUART_Init(DEMO_LPUART, &config, CLOCK_GetFreq(DEMO_LPUART_CLKSRC)); /* Send g_tipString out. */ LPUART_WriteBlocking(DEMO_LPUART, g_tipString, sizeof(g_tipString) / sizeof(g_tipString[0])); /* Enable RX interrupt. */ LPUART_EnableInterrupts(DEMO_LPUART, kLPUART_RxDataRegFullInterruptEnable); EnableIRQ(DEMO_LPUART_IRQn); while (1) { /* Send data only when LPUART TX register is empty and ring buffer has data to send out. */ while ((kLPUART_TxDataRegEmptyFlag & LPUART_GetStatusFlags(DEMO_LPUART)) && (rxIndex != txIndex)) { LPUART_WriteByte(DEMO_LPUART, demoRingBuffer[txIndex]); txIndex++; txIndex %= DEMO_RING_BUFFER_SIZE; } } }
static int mcux_lpuart_err_check(struct device *dev) { const struct mcux_lpuart_config *config = dev->config->config_info; u32_t flags = LPUART_GetStatusFlags(config->base); int err = 0; if (flags & kLPUART_RxOverrunFlag) { err |= UART_ERROR_OVERRUN; } if (flags & kLPUART_ParityErrorFlag) { err |= UART_ERROR_PARITY; } if (flags & kLPUART_FramingErrorFlag) { err |= UART_ERROR_FRAMING; } LPUART_ClearStatusFlags(config->base, kLPUART_RxOverrunFlag | kLPUART_ParityErrorFlag | kLPUART_FramingErrorFlag); return err; }