[XMEGA] Read ADC via DMA

[Jiri D. (Gast)]

Hallo!

Ich moechte mehrere samples vom ADCA eines ATxmega32A4U mit DMA 
auslesen, aber ich bekomme immer nur 0x0000 in den buffer geschrieben. 
Das Vorgehen ist so:
1. ADCA, differenziell zu PADGND, in FREERUNning mode setzen
1. In einer Timer ISR alle 100ms:
   - Mittelwert der 16 samples von zuvor bilden
   - DMA Transaktion starten, 2B je burst, 16 bursts gesamt

ADCA setup:

#include <string.h>     /* memset() */
#include <stdint.h>

#define NUM_SAMPLES ((sizeof(samples) / sizeof(samples[0])))
static uint16_t samples[16];

void
init(void)
{
    memset(samples, 0, sizeof(samples));

    /* configure ADCA */
    ADCA.CTRLA = ADC_DMASEL_OFF_gc | ADC_ENABLE_bm;
    ADCA.CTRLB = ADC_CURRLIMIT_NO_gc | ADC_CONMODE_bm
               | ADC_RESOLUTION_12BIT_gc;
    ADCA.REFCTRL = ADC_REFSEL_AREFB_gc;
    ADCA.PRESCALER = ADC_PRESCALER_DIV512_gc;
    ADCA.EVCTRL = 0;

    ADCA.CH0.CTRL = ADC_CH_GAIN_1X_gc | ADC_CH_INPUTMODE_DIFF_gc;
    /* "ADC_CH_MUXNEG_PADGND" undefined, corresponds to 0x05 */
    ADCA.CH0.MUXCTRL = ADC_CH_MUXPOS_PIN1_gc | 0x05;
    ADCA.CH0.INTCTRL = 0;
    ADCA.CH0.SCAN = 0;

    ADCA.CTRLA |= ADC_FLUSH_bm;
    ADCA.CTRLB |= ADC_FREERUN_bm;
    ADCA.CH0.CTRL |= ADC_CH_START_bm;
}

ISR & helper functions:

static void
start_dma(void)
{
    /* configure DMA.CH1 */
    DMA.CH1.CTRLA &= ~DMA_CH_ENABLE_bm;
    while (DMA.CH1.CTRLA & DMA_CH_ENABLE_bm)
        nop(1);
    DMA.CH1.CTRLA |= DMA_CH_RESET_bm;
    while (DMA.CH1.CTRLA & DMA_CH_RESET_bm)
        nop(1);
    DMA.CH1.ADDRCTRL =
        DMA_CH_SRCRELOAD_BURST_gc | DMA_CH_SRCDIR_INC_gc |
        DMA_CH_DESTRELOAD_NONE_gc | DMA_CH_DESTDIR_INC_gc;
    uint16_t adc_addr = (uint16_t) &ADCA.CH1.RESL;
    DMA.CH1.SRCADDR0 = adc_addr & 0xff;
    DMA.CH1.SRCADDR1 = (adc_addr >> 8) & 0xff;
    DMA.CH1.SRCADDR2 = 0;
    DMA.CH1.DESTADDR0 = ((uint16_t) samples) & 0xff;
    DMA.CH1.DESTADDR1 = (((uint16_t) samples) >> 8) & 0xff;
    DMA.CH1.DESTADDR2 = 0;
    DMA.CH1.TRIGSRC = DMA_CH_TRIGSRC_ADCA_CH0_gc;
    DMA.CH1.TRFCNT = 2;
    DMA.CH1.REPCNT = NUM_SAMPLES;
    DMA.CH1.CTRLA =
        DMA_CH_REPEAT_bm | DMA_CH_SINGLE_bm | DMA_CH_BURSTLEN_2BYTE_gc;

    DMA.CH1.CTRLA |= DMA_CH_ENABLE_bm;
}

static void
avg_flt_samples(void)
{
    uint32_t sum = 0;
    for (uint8_t i = 0; i < NUM_SAMPLES; ++i)
        sum += samples[i];
    sum += NUM_SAMPLES / 2; /* for rounding */

    /* extern: measurement_buffer
     * struct { uint8_t pending_data : 1; uint16_t measurement; }; */
    measurement_buffer.pending_data = 1;
    measurement_buffer.data = (uint16_t) (sum / NUM_SAMPLES);
}


ISR(TCC0_OVF_vect)
{
    static enum {
        INITIAL_RUN,
        LATER_RUN
    } state = INITIAL_RUN;

    if (INITIAL_RUN == state) {
        /* it's the first time that we're here, so there's
         * no data to precess yet */
        start_dma();
        state = LATER_RUN;
    } else {
        /* we're at a later run, so process the data and go for a new
         * round */
        if (!(DMA.CH1.CTRLB & (DMA_CH_CHBUSY_bm | DMA_CH_CHPEND_bm))
            && (DMA.INTFLAGS & DMA_CH1TRNIF_bm)) {
            /* DMA transaction has completed */
            avg_flt_samples();
            start_dma();
        }
    }
}

Das Problem zeigt sich nun so:
- In samples[.] stehen immer nur 0x0000en
- Der ADC laeuft (manuelles Auslesen von ADCA.CH0.RES liefert 
realistische
  Werte)
- Der DMA laeuft, macht aber nur einen burst

Ich habe auch avr-gdb+avarice drangehaengt; dabei scheinen alle Register 
usw. korrekt gesetzt zu werden, DMA wartet auf trigger, wird getriggert 
(macht einen burst, REPCNT geht um 1 runter), und ist dann disabled.

Und das erscheint mir irgendwie seltsam...
Der obige Code funktioniert analog (BURSTLEN=TRFCNT=1) fuer einen UART 
aber ohne Probleme.

Hat jemand eine Idee?

[Jiri D. (Gast)]

Fehler gefunden:

-uint16_t adc_addr = (uint16_t) &ADCA.CH1.RESL;
+uint16_t adc_addr = (uint16_t) &ADCA.CH0.RESL;

ist natuerlich bloed, wenn man ADC.CH0 initialisiert, aber die Messwerte 
bei ADC.CH1 erwartet...