Using dma with uart

[traxanos]

We are currently facing the following issue: Whenever a flash page is erased on the RP2040, all CPU activities including interrupts need to be paused. This leads to data loss when using the UART, as the hardware buffer is only 32 bytes in size and the CPU cannot retrieve it. This applies even to your software FIFO.

To solve this problem, DMA is an option. I have started building a Proof of Concept (PoC) for our OpenKNX projects, which writes the data into a Ring Buffer in RAM without involving the CPU.

I could use this solution solely for our purposes, or implement it as a replacement for your FIFO on the Serial UART. The question is, is there any interest in doing so?

However, there are deviations from the current behavior. Due to its nature, I cannot detect "overflow" or "break". The DMA simply writes the incoming bytes into RAM and that's it.

Here a example:

#include "Arduino.h"
#include "hardware/dma.h"
#include "pico/stdlib.h"

constexpr uint16_t dmaUartTransferCount = 1024; // UINT16_MAX or UINT32_MAX but for testing only 1024
constexpr uint8_t dmaUartBufferExp = 8;         // 2**BufferExp
constexpr uint16_t dmaUartBufferSize = (1 << dmaUartBufferExp);

static uint8_t __attribute__((aligned(dmaUartBufferSize))) dmaUartBuffer[dmaUartBufferSize] = {};
static uint8_t dmaUartChannel;

static uint16_t readCount = 0;
static uint16_t restartDiff = 0;
bool test = false;

void __time_critical_func(processIRQ)()
{
    dma_hw->ints0 = 1u << dmaUartChannel; // clear DMA IRQ0 flag
    restartDiff = (dmaUartBufferSize - (readCount & dmaUartBufferSize)) + 1;
    readCount = 0;
    dma_channel_start(dmaUartChannel);
}

void setup()
{
    SERIAL_DEBUG.println("SETUP");
    while (!SERIAL_DEBUG)
        ;

    gpio_set_function(0, GPIO_FUNC_UART);
    gpio_set_function(1, GPIO_FUNC_UART);
    uart_init(uart0, 19200);
    uart_set_hw_flow(uart0, false, false);
    uart_set_format(uart0, 8, 1, UART_PARITY_NONE);

    dmaUartChannel = dma_claim_unused_channel(true);
    dma_channel_config dmaConfig = dma_channel_get_default_config(dmaUartChannel);

    channel_config_set_transfer_data_size(&dmaConfig, DMA_SIZE_8);
    channel_config_set_read_increment(&dmaConfig, false);
    channel_config_set_write_increment(&dmaConfig, true);
    channel_config_set_high_priority(&dmaConfig, true);
    channel_config_set_ring(&dmaConfig, true, dmaUartBufferExp);
    channel_config_set_dreq(&dmaConfig, DREQ_UART0_RX);
    dma_channel_set_read_addr(dmaUartChannel, &uart_get_hw(uart0)->dr, false);
    dma_channel_set_write_addr(dmaUartChannel, dmaUartBuffer, false);
    dma_channel_set_trans_count(dmaUartChannel, dmaUartTransferCount, false);
    dma_channel_set_config(dmaUartChannel, &dmaConfig, true);
    dma_channel_set_irq0_enabled(dmaUartChannel, true);

    dma_channel_set_irq0_enabled(dmaUartChannel, true);
    irq_set_exclusive_handler(DMA_IRQ_0, processIRQ);
    irq_set_enabled(DMA_IRQ_0, true);

    SERIAL_DEBUG.println("SETUP DONE");
}

/*
 * Read the transfer_count, which counts backward, and subtract it from the starting value to obtain a forward counter.
 * Since the DMA needs to be regularly restarted to avoid losing the old buffer, the read count is saved and separately decremented to preserve the old buffer.
 */
inline uint16_t currentWriterCount()
{
    return dmaUartTransferCount - (dma_channel_hw_addr(dmaUartChannel)->transfer_count) + restartDiff;
}

inline uint16_t currentReaderCount()
{
    return readCount;
}

int available()
{
    return currentWriterCount() - currentReaderCount();
}

int read()
{
    if (!available()) return -1;

    int ret = (dmaUartBuffer + (readCount % dmaUartBufferSize))[0];

    if (restartDiff > 0)
        restartDiff--;
    else
        readCount++;

    return ret;
}

void loop()
{
    if (available())
    {
        while (available())
        {
            SERIAL_DEBUG.printf("%02X ", read());
        }
        test = true;
    }
    else if (test)
    {
        test = false;
        SERIAL_DEBUG.println();
    }
    delay(2);
}

[earlephilhower]

I think you've got a very specific need that probably wouldn't warrant changing the default behavior. However, there's no reason you couldn't package this as an Arduino library and make it available. The UARTs are not touched until Serial1/2.begin(), so there is no issue using them here...