How to use the RXTO

[jerome.sc]

Hello,

I have an application that I receive data over the UART. The data being received can be of different lengths e.g. 12 bytes up to a maximum of 256 bytes. I want to know when the data coming in has stopped, so I know when to read the buffer. I've been reading the UARTE — Universal asynchronous receiver/transmitter with EasyDMA page, and it mentions using RXTO to know when the RX has stopped.

https://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.nrf52832.ps.v1.1%2Fuarte.html

I've set the UARTE up, but I don't know how to setup or use the RXTO.

I've used the UART example code, and modified it by changing the main code. I can toggle and LED from the UARTE1_IRQHandler, but the "hello" is not being transmitted.

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "app_uart.h"
#include "app_error.h"
#include "nrf_delay.h"
#include "nrf.h"
#include "bsp.h"
#include "nrf_uarte.h"


uint8_t UARTE_RX_BUF  = 10;
uint8_t UARTE_TX_BUF = 10;

void UARTE1_IRQHandler(void)
{
if(nrf_uarte_event_check(NRF_UARTE1, NRF_UARTE_EVENT_RXDRDY)) {
        nrf_uarte_event_clear(NRF_UARTE1, NRF_UARTE_EVENT_RXDRDY);
        nrf_gpio_pin_toggle(LED_2);
        nrf_uarte_task_trigger(NRF_UARTE1, NRF_UARTE_TASK_STARTRX);
    }

}


void uarte_config(void)
{

  nrf_uarte_txrx_pins_set(NRF_UARTE1, TX_PIN_NUMBER, RX_PIN_NUMBER);
  nrf_uarte_baudrate_set(NRF_UARTE1, NRF_UARTE_BAUDRATE_115200);
  nrf_uarte_configure(NRF_UARTE1, NRF_UARTE_PARITY_EXCLUDED, NRF_UARTE_HWFC_DISABLED);
  nrf_uarte_enable(NRF_UARTE1);

  nrf_uarte_event_clear(NRF_UARTE1, NRF_UARTE_EVENT_RXDRDY);
  nrf_uarte_int_enable(NRF_UARTE1, NRF_UARTE_INT_RXDRDY_MASK);

  nrf_uarte_rx_buffer_set(NRF_UARTE1, &UARTE_RX_BUF, 10);
  nrf_uarte_tx_buffer_set(NRF_UARTE1, &UARTE_TX_BUF, 10);

  NVIC_SetPriority(UARTE1_IRQn, 3);
  NVIC_ClearPendingIRQ(UARTE1_IRQn);
  NVIC_EnableIRQ(UARTE1_IRQn);

}

int main(void)
{
    uint32_t err_code;

    uarte_config();

    bsp_board_init(BSP_INIT_LEDS);
    uint8_t data[] = "Hello";

    nrf_uarte_task_trigger(NRF_UARTE1, NRF_UARTE_TASK_STARTRX);

    nrf_uarte_tx_buffer_set(NRF_UARTE1, data, 5);
    nrf_uarte_task_trigger(NRF_UARTE1, NRF_UARTE_TASK_STARTTX);

    

    while (true)
    {
      
    }
}

[Edvin]

Hello,

The RXTO is not what you are looking for in this case. 

The UART protocol doesn't have any means of telling the connected device how many bytes that are in a message. The same goes for the UART peripheral. It will only be notified every time one byte is received. 

But your question is fairly common, because you would typically want to do something when you have received N bytes, but N is not necessarily constant, like in your case where you say that N can be 12 in one message, and 256 in the next.

So to make this work there are two approaches. 

1: This is by far the easiest one. If you look into the ble_app_uart example, you will see this implementation. Please note that the application itself will receive an interrupt on every byte, but the application logic is used to trigger only in certain events. Either if the buffer is full, or if the last received byte is \n (newline) (or any other special character that you decide). So in this case you would want to make your buffer large enough, so that you will only trigger on the special character that you are looking for.

2: This is a bit more complex. It uses a timer to detect when the last received UART byte was received. If X time passes (x can be 1 second, 5 ms, or whatever you set). If the timer times out before you receive a new byte, it will assume that the "message" is done, and turn off the timer until a new byte is received.

If you have some sort of special character that is present at the end of your incoming UART messages, I suggest that you use this. If you control the application on the transmitting side, consider adding it there if possible. If not, you will need to look into the timing approach. In that case, you can check out the SDK\examples\peripheral\libuarte example.

Best regards,

Edvin

[jerome.sc]

Interesting, I'll look into this way of implementing things.

What if a PC was sending data over the UART to the nRF microcontroller, with the same conditions, i.e. random amount of bytes. Would the RXTO be used in this case? To detect when the RX registers has stopped receiving data?

[Edvin]

jerome.sc said:

What if a PC was sending data over the UART to the nRF microcontroller, with the same conditions, i.e. random amount of bytes. Would the RXTO be used in this case?

No. You can read about the RXTO event here:

https://infocenter.nordicsemi.com/topic/ps_nrf52833/uarte.html?cp=4_1_0_5_31_2#concept_uzb_p2m_wr

The RXTO event will only occur after you have aborted the RX (which the driver usually handlers). It can not be used as a generic timeout.

If you are sending data from a PC to the nRF over UART, you can probably add e.g. a '\n' (newline) character at the end of all "complete messages".