Serial library, understanding asynchronous workflow

[lybrus]

Hi there,

I'm trying to use serial library from SDK to interact with cellular modem (AT commands, not nRF9160). I've read documentation (library description, api). May be it is obvious, but I didn't have any experience with UART before at all, I don't understand scenario of using this library in asynchronous way. Examples show synchronous interaction.

I'd done some experiments, and implemented so (read from serial byte by byte and process it, it doesn't seem correct. I don't understand how should it work. How to use queues and buffers):

NRF_SERIAL_DRV_UART_CONFIG_DEF(uarte0_drv_config,
                               RX_PIN_NUMBER,
                               TX_PIN_NUMBER,
                               RTS_PIN_NUMBER,
                               CTS_PIN_NUMBER,
                               NRF_UART_HWFC_ENABLED,
                               NRF_UART_PARITY_EXCLUDED,
                               NRF_UART_BAUDRATE_115200,
                               UART_DEFAULT_CONFIG_IRQ_PRIORITY);

#define SERIAL_FIFO_TX_SIZE 256
#define SERIAL_FIFO_RX_SIZE 256

NRF_SERIAL_QUEUES_DEF(serial0_queues, SERIAL_FIFO_TX_SIZE, SERIAL_FIFO_RX_SIZE);

#define SERIAL_BUFF_TX_SIZE 1
#define SERIAL_BUFF_RX_SIZE 1

NRF_SERIAL_BUFFERS_DEF(serial0_buffs, SERIAL_BUFF_TX_SIZE, SERIAL_BUFF_RX_SIZE);

static void serial_sleep_handler(void);
static void serial_event_handler(nrf_serial_t const *p_serial, nrf_serial_event_t event);

NRF_SERIAL_CONFIG_DEF(serial0_config, NRF_SERIAL_MODE_DMA,
                      &serial0_queues, &serial0_buffs, serial_event_handler, serial_sleep_handler);

NRF_SERIAL_UART_DEF(serial0_uarte, 0);

static void serial_sleep_handler(void)
{
    __WFE();
    __SEV();
    __WFE();
}

sstatic void serial_event_handler(nrf_serial_t const *p_serial, nrf_serial_event_t event)
{
    static ret_code_t ret;
    static uint8_t data, prev_data = NULL;

    switch (event)
    {
        case NRF_SERIAL_EVENT_TX_DONE:
        {
            // count bytes of request and switch at parser module to recieving state at the end

            break;
        }

        case NRF_SERIAL_EVENT_RX_DATA:
        {
            ret = nrf_queue_generic_pop(p_serial->p_ctx->p_config->p_queues->p_rxq,
                                        &data,
                                        false);
            APP_ERROR_CHECK(ret);

            // process data byte by byte

            break;
        }

        case NRF_SERIAL_EVENT_DRV_ERR:
        case NRF_SERIAL_EVENT_FIFO_ERR:
        {
            // reset at parser module
            break;
        }

        default:
        {
            break;
        }
    }
}

If I change ```SERIAL_BUFF_RX_SIZE``` to 2 or more, I will not receive rx_data event until buffer is not full.

Could somebody explain, how to implement it in right way? May be some tutorials or videos about it.

Thanks in advance.

[Simon]

I prefer to use the UART driver directly (use the API in nrf_drv_uart.h), as I find it more intuitive to use.  If you have any specific questions on how to implement it, please ask and I will look into it.

Best regards,

Simon

[lybrus]

Ok, I will try it.

But what about serial library? Do you not recommend it to use? Or just hard for understanding. In this case, how to understand? Review code of this library?

Thanks.

[Simon]

You are talking about synchronous UART (USART), we don't support this on any of the chips. I guess you're interested in interrupt-driven UART with buffers? The nrf_serial examples do not support this, and I couldn't find much about it on Devzone either.

I talked to some other engineer that said it would be easier to achieve what you are trying to do with the UART driver directly, and you'll find many Devzone cases with this. 

Best regards,

Simon

[lybrus]

Simon said:

I guess you're interested in interrupt-driven UART with buffers?

It seems yes. Ok, I understand. Thanks!