AVR Freaks

I don't read C.

I've not used the DMA module on the Xmega.

That said, why do you disable the interrupt?

What does that gain you?

I would think that you want to process the ISR faster than the data are incoming, and you don't want to miss one.

I would think you would leave the USART Interrupts enabled.

On the Xmega32E5 you MIGHT need to reset an interrupt flag manually within your code.

I haven't looked at the USART interrupts and the data sheet to see if this is the case, you can do that.

On the Xmega32E5 series at least some of the interrupts need to be manually reset from within the ISR.

Have you looked at the EVENT SYSTEM to see if the DMA module can automatically load USART received data without the need for any code on your part to handle the data transfer?

That would seem to be the ideal solution, and perhaps the fastest, (although not tested by myself).

JC

I looked at this as a learning exercise and I struggled to get your code working in the Atmel Simulator basically because you didn't provide a complete example. I had to fill in a fair bit of initialisation.

That aside - it actually works now. The ISR(USARTD0_RXC_vect) receives the first character of a message frame and sets up DMA to receive the remainder of the Frame. After "TransferComplete" we again wait for the first character of the Frame.

Here it all is. It's not too different from your own code and you can run it in the Simuilator using STIM files for two test messages;  "JKL" and "PQRS".

/*
* delidado.c
*
* Created: 03/07/2020 21:34:38
* Author : Nigel
* URL    : https://www.avrfreaks.net/forum/implementing-uart-driver-interrupts-and-dma-uartrxc-isr-executed-only-first-time-character
*/

#include <avr/io.h>
#include <avr/interrupt.h>
#include <string.h>

#define RS_PRIORITY_RXC USART_RXCINTLVL_HI_gc
#define RS_PRIORITY_TXC USART_TXCINTLVL_HI_gc

// baud rate 230400
#define RS_BAUDCTRL 131
#define RS_BAUDSCALE -3

void rs_init();

typedef struct s_frame {
    char byte0;
    char buffer[16];
} Frame;

static volatile Frame frame;
static volatile uint8_t _state = 0;
static volatile uint8_t transferIsComplete;

int main (void)
{
    /* Initialize OSC Module */
    /* -- Enable the 32 MHz output of the internal RC oscillator */
    OSC.CTRL |= OSC_RC32MEN_bm;

    /* Initialize CPU & Peripheral Clock Prescalers */
    /* ClkPer4: CLK_sys */
    /* ClkPer2: CLK_sys */
    /* ClkPer:  CLK_sys */
    /* ClkCPU:  CLK_sys */
    CCP = CCP_IOREG_gc;
    CLK.PSCTRL = CLK_PSADIV_1_gc | CLK_PSBCDIV_1_1_gc;

    /* Switchover System clock source to: (32MHz Int. RC OSC) */
    while ((OSC.STATUS & OSC_RC32MRDY_bm)==0); // Wait for the 32 MHz RC oscillator to stabilize
    CCP = CCP_IOREG_gc;
    CLK.CTRL = CLK_SCLKSEL_RC32M_gc;

    /* Disable CLK Output */
    PORTCFG.CLKOUT &= ~(PORTCFG_CLKOUTSEL_gm | PORTCFG_CLKOUT_gm);

    /* Initialize PMIC Module */
    PMIC.INTPRI = 0x00;
    PMIC.CTRL   = 0 << PMIC_RREN_bp
                | 0 << PMIC_IVSEL_bp
                | 1 << PMIC_HILVLEN_bp
                | 1 << PMIC_MEDLVLEN_bp
                | 1 << PMIC_LOLVLEN_bp;

    rs_init();

    sei();
    for ( ;; ) {
        while(!transferIsComplete) {
            __builtin_avr_nop();
        }

        transferIsComplete = 0;
        memset((Frame*)(&frame), 0, 8);

    }

    return 0;
}

void rs_init()
{
    // Enable Transmit Complete Interrupt
    USARTD0.CTRLA = RS_PRIORITY_TXC;

    PORTD.REMAP = 1<<4; // Remap usart from 2,3 to 6,7
    PORTD.DIRSET = 1<<7;
    PORTD.OUTSET = 1<<7; //set TX high
    PORTD.OUTCLR = 1<<5; // DIR low = input
    USARTD0.CTRLB = 0b11100; //enable TX and RX, 2X speed
    USARTD0.CTRLC = 0b011; //no parity, async, 8bit, 1 stop bit

    // Sets-up 230.400k baud rate
    USARTD0.BAUDCTRLA = RS_BAUDCTRL & 0xff; // BSEL lo
    USARTD0.BAUDCTRLB = ((RS_BAUDSCALE & 0xf) << 4) | ((RS_BAUDCTRL >> 8) & 0xf); //BSCALE:7-4, BSEL:3-0

    // Enable Receive Complete interrupt
    USARTD0.CTRLA |= RS_PRIORITY_RXC;

    // Initialize EDMA - this is needed for SPI and RS485
    EDMA.CTRL = (1<<6); // reset
    EDMA.CTRL = (1<<7) | 0b0000; // enable, no double buffering, four perip chan

    // CH0 is for RS485 RX, CH2 for TX
    // CH1 is for SPI TX, CH3 for RX
    EDMA.CH1.CTRLA = EDMA.CH0.CTRLA = 1<<6; // reset
    EDMA.CH3.CTRLA = EDMA.CH2.CTRLA = 1<<6; // reset

}

static void setup_rx_dma(uint8_t len)
{
    EDMA.CH0.CTRLB = 0b1010; // set medium interrupt levels
    EDMA.CH0.ADDRCTRL = 0b001; // none reload, incremental transfer peripheral to memory
    EDMA.CH0.TRIGSRC = EDMA_CH_TRIGSRC_USARTD0_RXC_gc;
    EDMA.CH0.TRFCNT = len;
    EDMA.CH0.ADDR = (register16_t) &frame.buffer[0];
    EDMA.CH0.CTRLA = (1<<7) /* enable */ | (1<<2) /* single shot mode */;
}

ISR(EDMA_CH0_vect)
{
    /* Signal Transfer Complete */
    transferIsComplete = 1;

    // Disable reception of frames
    USARTD0.CTRLB &= ~USART_RXEN_bm;
    // Set RXC interrupt from 0b00 to 0b10
    USARTD0.CTRLA |= RS_PRIORITY_RXC;
    // Enable reception of frames
    USARTD0.CTRLB |= USART_RXEN_bm;

    // Reset DMA
    EDMA.CH0.CTRLA = (1<<6) /* reset */;
}

ISR(USARTD0_RXC_vect)
{
    // Read and store the received character
    frame.byte0 = USARTD0.DATA;

    // Start DMA transfer for some bytes
    uint8_t len;
    switch (frame.byte0) {
        case 'J': len = 2;
        break;
        case 'P': len = 3;
        break;
        default: len = 0;
    }
    if (len > 0) {
        /* Disable RXC interrupts by setting interrupt priority from 0b10 to 0b00 */
        USARTD0.CTRLA &= ~RS_PRIORITY_RXC;
        
        setup_rx_dma(len);
    }
}

Enjoy

If so, I'll stop searching.
I'll consider your code if I have time.