XMEGA: Zeitproblem mit zwei parallel sehr schnell laufenden Timern

[erik_wolfram]

@CrazyHarry:

Danke für den Hinweis. Das war schonmal eine große Hilfe - konnte den XMEGA128A1 bis ca. 55 MHz hochtakten - danach hat er aber gesponnen - für den vewendeten µC liegt hier wohl die Grenze (wie im Datenblatt angegeben).

Habe heute noch fleißig weiter probiert und dabei kam mir eine vermeintlich gute Idee - die jedoch in der Ausführung Zicken macht -warum weiß ich noch nicht.
Ich hatte die Idee, um die ganzen Interupts zu umgehen DMA zu verwenden. Für die Generierung des Analogen Ausgangssigals und den SPI-Lesevorgang kein Problem. Die Initiierung der AD-Wandlung lies sich auch rein Hardwaretechnisch über ein PWM-Timer lösen.
Also bis jetzt habe ich es geschafft alles ohne Software umzusetzten - lediglich beim Absetzten der 4 Bytes mittels SPI gibt es Probleme.

Zum Timing:

Ein Zyklus dauert 5 µs.
Die AD-Wandlung benötigt 1,4 µs vom Zyklusbeginn.
Dann sollen alle 0,5 µs willkürliche Bytes in das SPI-Data-Register geschrieben werden.
Das soll sich so jeden Zyklus wiederholen.

Nach langen Überlegen hatte ich folgende Idee:
Ein separater Timer löst mit jedem Overflow ein DMA-Schreibzugriff auf das SPI-Data-Register aus.
Ein weiterer DMA-Kanal greift zyklisch auf einen Array mit den Timer-Werten zu und schreibt diese in das PER-Register des benannten Timers.

Also so, dass das PER-Register des Timers rein Hardwaremäßig aktualisiert wird, ohne das der µC eine Programmzeile benötigt.

Theoretisch sollte das doch funktionieren? (2 DMA's können vom gleichen Timer ausgelöst werden - das habe ich getestet)
Leider kann ich das ganze nicht im Simulator prüfen - auf dem Board wird mir die Änderung des PER-Registers via DMA unterschlagen.

Hier nochmal der DMA-Zugriff auf das Timer-Register (vereinfacht):

volatile uint8_t TestNum = 200;

void SetupWriteChannel( DMA_CH_t * dmaChannel )
{
    DMA_SetupBlock(
        dmaChannel,
        TestNum,
        DMA_CH_SRCRELOAD_NONE_gc,
        DMA_CH_SRCDIR_FIXED_gc,
        (void *) &(TCD0.PER),
        DMA_CH_DESTRELOAD_NONE_gc,
        DMA_CH_DESTDIR_FIXED_gc,
        1,
        DMA_CH_BURSTLEN_1BYTE_gc,
        0,
        true
    );

    DMA_EnableSingleShot( dmaChannel );
    DMA_SetTriggerSource( dmaChannel, DMA_CH_TRIGSRC_TCD0_OVF_gc );
}

...
DMA_Enable();

DMA_CH_t * WriteChannel = &DMA.CH1;    
SetupWriteChannel( WriteChannel );
DMA_EnableChannel( WriteChannel );

Die Änderung des PER-Werts wird leider nicht übernommen - wo kann hier der Fehler liegen?

Vielen Dank für die Hilfe!

Gruß Erik

[Che Guevara]

Hi,

ohne zu wissen, ob deine SetupWriteChannel Funktion (und auch die anderen) richtig arbeitet, fällt mir auf, dass du den DMA auf 1Byte-Burst sowie auf SCRDIR_FIXED gestellt hast. Das PER Register der Timer ist aber 16Bit breit, das passt schonmal nicht.
Außerdem weiß ich nicht, ob du das PER Register überhaupt irgendwo veränderst? Dir ist klar, was dieses Register macht?

Gruß
Chris

[erik_wolfram]

Vielen Dank für den Hinweis - ich habe schlicht und einfach vergessen, dass es ein 16 Bit Register ist.
Jetzt funktioniert (theoretisch) alles bestens - eine komplette Messung von 400 ksps mit 16 Bit ohne jegliche CPU-Last (bzw. laufenden Programm-Code).

Der variable mit DMA veränderbare Timer sieht jetzt so aus:

void SetupWriteTimer( void )
{
    // Start Timer/Counter C0 with actual clock (32MHz) divided by 4
    TCD0.CTRLA = (TCD0.CTRLA & ~TC0_CLKSEL_gm) | TC_CLKSEL_DIV1_gc;
    // AD_Wandlung 1,5 µs - Per = 47
    TCD0.PER = 30;
    // Timer vorladen um Kollision mit Timer TCC0 zu vermeiden
    TCD0.CNT = 15;
    // Priorität setzten
    TCD0.INTCTRLA = TC_OVFINTLVL_MED_gc;
}

#define Interval 4
volatile uint16_t  WriteDelay[Interval] = { 20, 20, 20, 96 };
    
void SetupWriteDelayChannel( DMA_CH_t * dmaChannel )
{
    DMA_SetupBlock(
        dmaChannel,
        WriteDelay,
        DMA_CH_SRCRELOAD_BLOCK_gc,
        DMA_CH_SRCDIR_INC_gc,
        (void *) &(TCD0.PER),
        DMA_CH_DESTRELOAD_BURST_gc,
        DMA_CH_DESTDIR_INC_gc,
        Interval * 2,
        DMA_CH_BURSTLEN_2BYTE_gc,
        0,
        true
    );

    DMA_EnableSingleShot( dmaChannel );
    DMA_SetTriggerSource( dmaChannel, DMA_CH_TRIGSRC_TCD0_OVF_gc );
}

Ich werde jetzt noch einen Test mit der SPI-Geschwindigkeit machen und prüfen, ob fehlerfrei übertragen wird - dann geht es zum Hardware-Aufbau.