nRF52840 UARTE0 EasyDMA receives more bytes than expected

RE: nRF52840 UARTE0 EasyDMA receives more bytes than expected

LaszloUA — Wed, 11 Sep 2024 12:39:48 GMT

Hi Susheel,

is there any new updates regarding this topic?

RE: nRF52840 UARTE0 EasyDMA receives more bytes than expected

Susheel Nuguru — Mon, 02 Sep 2024 11:51:56 GMT

Hi Vlad,

Naeem is away and wont be back soon. I was assigned to this thread. I will try soon to replicate the issue using the instruction you gave below. Will come back to you when I have some new observations.

RE: nRF52840 UARTE0 EasyDMA receives more bytes than expected

LaszloUA — Tue, 27 Aug 2024 12:00:19 GMT

Hi Naeem,

sorry, took a long vacation without visiting web. It is really strange that my code is not working on your side since I tested this simple example several times, but OK, I can make more confident example. uart_rx_enable() in loop was just needed to "restart" UART automatically. Bad example, agree.

Echo bot works very fine since it explicitly drops all data (custom logic implemented in interrupt). I use ASYNC driver so "under the hood" reception is not available for me.

I have rewritten the code for it to work more correctly, could you please try it to see if you can reproduce my behavior? Now I have added BUTTON 1 to work. I use nRF52840-DK to run this application.

What you can do to reproduce this issue:

Variant 1:

Connect to serial port and see *** Booting nRF Connect SDK v3.5.99-ncs1-1 *** message (or your version).

Write some > 10 bytes message from your keyboard. You can just mash buttons.

Press Button 1 on the board.

Expected to see: UART IS RESTARTED.

I see:

UART IS RESTARTED RX READY Received: 10 bytes RX Stopped RX Disabled

So as you can see, uart_rx wasn't even turned on while some data came in. Then you have turned it on by the push of the button and it INSTANTLY got some data you have entered while uart_rx was disabled. And I'm interested in how could it possibly function so nRF52 somehow still stores data inside even with uart_rx is off, how can I determine this buffer and prevent this behavior?

Variant 2:

Connect to serial port and see *** Booting nRF Connect SDK v3.5.99-ncs1-1 *** message (or your version).

Press Button 1 on the board. Observe UART IS RESTARTED line.

Write some data. See how after 10 bytes you get

RX READY Received: 10 bytes RX Stopped RX Disabled

Now uart_rx is off. Now continue writing something while uart is off. Write at least 10 bytes.

Press Button 1 on the board once again.

Observe:

RX READY
Received: 10 bytes
RX Stopped
RX Disabled

Hopefully this code will work better since I've upgraded it to rely only on button, not on some delays.

#include <zephyr/kernel.h>
#include <zephyr/drivers/uart.h>
#include <zephyr/drivers/gpio.h>
#include <stdbool.h>

static bool is_uart_enabled = false;
static uint8_t rx_buf[10] = {0};
const struct device* uart = DEVICE_DT_GET(DT_NODELABEL(uart0));
const static struct gpio_dt_spec button = GPIO_DT_SPEC_GET(DT_NODELABEL(button0), gpios);


static void uart_cb(const struct device *dev, struct uart_event *evt, void *user_data)
{

    switch (evt->type) {

    case UART_TX_DONE:
        break;

    case UART_TX_ABORTED:
        break;

    case UART_RX_RDY:
        printk("RX READY\n");
        printk("Received: %d bytes\n", evt->data.rx.len);
        break;

    case UART_RX_BUF_REQUEST:
        break;

    case UART_RX_BUF_RELEASED:
        break;

    case UART_RX_DISABLED:
        printk("RX Disabled\n");
        is_uart_enabled = false;
        break;

    case UART_RX_STOPPED:
        printk("RX Stopped\n");
        break;

    default:
        break;
    }
}


int main(void)
{
    int err = 0;

    if (!device_is_ready(uart)) {
        return err;
    }

    if (!gpio_is_ready_dt(&button)) {
        return err;
    }

    gpio_pin_configure_dt(&button, (GPIO_INPUT | GPIO_PULL_UP | GPIO_ACTIVE_LOW));

    err = uart_callback_set(uart, uart_cb, NULL);
    if (err) {
        return err;
    }

    while (1)
    {
        if (gpio_pin_get_dt(&button) == 1)
        {
            if (is_uart_enabled == 0)
            {
                printk("UART IS RESTARTED\n");
                uart_rx_enable(uart, rx_buf, 10, SYS_FOREVER_US);
                is_uart_enabled = true;
            }
        }
        k_msleep(500);
    }

    return 0;
}

prj.conf:

CONFIG_GPIO=y
CONFIG_SERIAL=y
CONFIG_UART_ASYNC_API=y

Best regards,

Vlad

RE: nRF52840 UARTE0 EasyDMA receives more bytes than expected

Naeem Maroof — Thu, 25 Jul 2024 15:20:23 GMT

Hi Vlad,

I am sorry for the delayed response due to high workload during this period.

I have tried your code, but was not able to make it work. It would not go as you have described, and things were breaking (I have tried to debug as well but it would go into idle after entering callback set function).

However, I have tried with the echo-bot sample. I was able to receive the exact amount as set in BUF_SIZE even if I press a lot of characters, only the specified amount is received.

I have also seen that you are calling uart_rx_enable() in the while(1) loop, why?

this function is supposed to be called only once and then the call back will be called as per events generated.

Regards,
Naeem

RE: nRF52840 UARTE0 EasyDMA receives more bytes than expected

LaszloUA — Wed, 17 Jul 2024 13:22:55 GMT

Hi Naeem,

are there any additional updates regarding this situation?

RE: nRF52840 UARTE0 EasyDMA receives more bytes than expected

LaszloUA — Mon, 15 Jul 2024 10:30:31 GMT

Hi Naeem,

Let's split my task on simple parts.

I'm indeed using two separate UARTs to transfer data in a special way, but it's not the point here, I will simplify the setup as much as possible to still be able to reproduce this behavior.

So, for this simple setup I have: PC connected to the nRF52840 UARTE0 via USB cable (On board Interface Chip).

I send the data FROM PC (using Minicom but everything will work, puTTY, nRF Serial Term etc.) to my board. Board only receives data.

My board in EasyDMA mode accepts some bytes of data till 50 bytes will arrive OR till it will be stopped by Bluetooth interrupt to read it earlier.

The thing is: if you send less or equal to 50 bytes from PC to board, everything is fine. If you send more, the next time you will start and stop RX routine, buffer will already have some data inside (that data which was sent after initial 50 bytes).

I use 2.6.1 toolchain, nothing more special to tell, just a basic project. I will send you the code below. For simplicity, I put len of buffer equal 10 bytes. As soon as the board will boot, try to send at least 20 bytes or more data to it, you can for example mash your keyboard buttons and wait. After 5 seconds you will see the next thing in the console:

*** Booting nRF Connect SDK v3.5.99-ncs1-1 ***
RX READY
Received: 10 bytes // THIS WILL SHOW ASAP AFTER YOU ENTER 10 BYTES
RX Disabled
RX READY
Received: 10 bytes // THIS WILL SHOW AFTER UART_RX WILL BE RESTARTED IN WHILE LOOP
RX Stopped
RX Disabled

Code:

#include <zephyr/kernel.h>
#include <zephyr/drivers/uart.h>

static uint8_t rx_buf[10] = {0};
const struct device *uart = DEVICE_DT_GET(DT_NODELABEL(uart0));
static void uart_cb(const struct device *dev, struct uart_event *evt, void *user_data)
{

    switch (evt->type) {

    case UART_TX_DONE:
        break;

    case UART_TX_ABORTED:
        break;

    case UART_RX_RDY:
        printk("RX READY\n");
        printk("Received: %d bytes\n", evt->data.rx.len);
        break;

    case UART_RX_BUF_REQUEST:
        break;

    case UART_RX_BUF_RELEASED:
        break;

    case UART_RX_DISABLED:
        printk("RX Disabled\n");
        break;

    case UART_RX_STOPPED:
        printk("RX Stopped\n");
        break;

    default:
        break;
    }
}


int main(void)
{
    int err = 0;

    if (!device_is_ready(uart)) {
        return err;
    }

    err = uart_callback_set(uart, uart_cb, NULL);
    if (err) {
        return err;
    }

    uart_rx_enable(uart, rx_buf, 10, SYS_FOREVER_US);

    while (1)
    {
        k_msleep(5000);
        uart_rx_enable(uart, rx_buf, 10, SYS_FOREVER_US);
    }

    return 0;
}

Config:

CONFIG_GPIO=y
CONFIG_SERIAL=y
CONFIG_UART_ASYNC_API=y

RE: nRF52840 UARTE0 EasyDMA receives more bytes than expected

Naeem Maroof — Fri, 12 Jul 2024 15:40:54 GMT

Hi Vlad

[quote user=""]After that I'm sending >10, let's say 20 bytes. After 10 bytes received I get an UART_RX_RDY callback, everything is very fine, but if I will restart the reception[/quote]

I do not fully understand your setup. You are sending and receiving, or receiving at the other end?

But if it is that it works for uarte1 and you see a problem with uart0, maybe you can send me a minimal project that compiles and I can test here.

Please do mention the SDK version you are using, and any other details regarding the setup if any.

Regards,
Naeem