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;
}
