ATxMega: DMA arbeitet nicht wie erwartet

[Curby23523 N. (Gast)]

Hallo,

ich möchte zwei DMA Kanäle (0/1) dazu benutzen, meinen DAC mit Daten zu 
versorgen, aber soweit kommt es noch gar nicht.

Meine Konfiguration sieht folgendermaßen aus:

PORTD_DIR = 0xFF;
  PORTB_DIR = 0xFF;
  PORTC_DIR = 0xFF;
  PORTC_OUT = 0;
  TCC1_CTRLA = TC_CLKSEL_DIV1_gc;
  TCC1_PERBUF = 256;
  //TCC1_INTCTRLA = 0x02;
  
  DMA.CH0.CTRLA = DMA_CH_SINGLE_bm | DMA_CH_BURSTLEN_2BYTE_gc;              //DMA Block macht bei jedem Trigger 2 Byte (signle)
  DMA.CH0.CTRLB = 0x03;                                  //Interrupt mit höchster Priorität
  DMA.CH0.ADDRCTRL = DMA_CH_SRCRELOAD_BLOCK_gc;                      //Nach jedem Block die Quelladresse reseten
  DMA.CH0.ADDRCTRL |= DMA_CH_DESTDIR_INC_gc;                        //Quelladresse immer +1
  DMA.CH0.ADDRCTRL |= DMA_CH_DESTRELOAD_BURST_gc;                      //Zieladresse nach jedem Burst (2Byte) neu laden
  DMA.CH0.ADDRCTRL |= DMA_CH_DESTDIR_FIXED_gc;                      //Zieladresse ist FIX
  DMA.CH0.TRIGSRC = DMA_CH_TRIGSRC_TCC1_OVF_gc;                      //Triggerevtn ist Timer TCC1 overflow
  DMA.CH0.TRFCNT = BUFFER_SIZE*2;                              //buffer_SIZE*2 Bytes
  DMA.CH0.REPCNT = 1;                                    //0 WIederholungen - nach 1 Block ist Transaction fertig
  DMA.CH0.SRCADDR0 = (DWORD)&DMA_Buffer1 & 0xFF;
  DMA.CH0.SRCADDR1 = ((DWORD)&DMA_Buffer1>>8) & 0xFF;
  DMA.CH0.SRCADDR2 = ((DWORD)&DMA_Buffer1>>16) & 0xFF;
  DMA.CH0.DESTADDR0 = (DWORD)&DACB.CH0DATA & 0xFF;
  DMA.CH0.DESTADDR1 = ((DWORD)&DACB.CH0DATA>>8) & 0xFF;
  DMA.CH0.DESTADDR2 = ((DWORD)&DACB.CH0DATA>>16) & 0xFF;
  
  DMA.CH1.CTRLA = DMA_CH_SINGLE_bm | DMA_CH_BURSTLEN_2BYTE_gc;              //DMA Block macht bei jedem Trigger 2 Byte (signle)
  DMA.CH1.CTRLB = 0x03;                                  //Interrupt mit höchster Priorität
  DMA.CH1.ADDRCTRL = DMA_CH_SRCRELOAD_BLOCK_gc;                      //Nach jedem Block die Quelladresse reseten
  DMA.CH1.ADDRCTRL |= DMA_CH_DESTDIR_INC_gc;                        //Quelladresse immer +1
  DMA.CH1.ADDRCTRL |= DMA_CH_DESTRELOAD_BURST_gc;                      //Zieladresse nach jedem Burst (2Byte) neu laden
  DMA.CH1.ADDRCTRL |= DMA_CH_DESTDIR_FIXED_gc;                      //Zieladresse ist FIX
  DMA.CH1.TRIGSRC = DMA_CH_TRIGSRC_TCC1_OVF_gc;                      //Triggerevtn ist Timer TCC1 overflow
  DMA.CH1.TRFCNT = BUFFER_SIZE*2;                              //buffer_SIZE*2 Bytes
  DMA.CH1.REPCNT = 1;                                    //0 WIederholungen - nach 1 Block ist Transaction fertig
  DMA.CH1.SRCADDR0 = (DWORD)&DMA_Buffer2 & 0xFF;
  DMA.CH1.SRCADDR1 = ((DWORD)&DMA_Buffer2>>8) & 0xFF;
  DMA.CH1.SRCADDR2 = ((DWORD)&DMA_Buffer2>>16) & 0xFF;
  DMA.CH1.DESTADDR0 = (DWORD)&DACB.CH0DATA & 0xFF;
  DMA.CH1.DESTADDR1 = ((DWORD)&DACB.CH0DATA>>8) & 0xFF;
  DMA.CH1.DESTADDR2 = ((DWORD)&DACB.CH0DATA>>16) & 0xFF;
  
  DMA.CTRL = DMA_ENABLE_bm | DMA_DBUFMODE_CH01_gc;
  DMA.CH0.CTRLA |= DMA_CH_ENABLE_bm;
    
  DACB.CTRLA = DAC_CH1EN_bm | DAC_CH0EN_bm | DAC_ENABLE_bm;                //Alle kanäle vom DAC aktivieren
  DACB.CTRLB = DAC_CHSEL_DUAL_gc;                              //Kanäle getrennt steuern
  DACB.CTRLC = DAC_REFSEL_AVCC_gc;                            //VCC als Referenzspannung

Zusätzlich ist das Interrupt definiert mit:

#define BUFFER_SIZE 256

WORD DMA_Buffer1[BUFFER_SIZE];
WORD DMA_Buffer2[BUFFER_SIZE];

ISR(DMA_CH0_vect){
  PORTC_OUTTGL = PIN6_bm;
  //reloadBuffer(DMA_Buffer1);
}


ISR(DMA_CH1_vect){
  PORTC_OUTTGL = PIN5_bm;
  DMA.CH0.CTRLA |= DMA_CH_ENABLE_bm;
  //reloadBuffer(DMA_Buffer2);
}

Es sollen also aus Buffer1 mit jedem Timerüberlauf zwei Bytes in den DAC 
geschrieben werden. Nach dem Block - ich möchte nur einen machen - soll 
der DMA.CH0 aktiviert werden - ping pong Modus. Der Timer macht jede 
256/14745600 Sekunden einen Überlauf - das macht ca. 57600 Überläufe pro 
Sekunde. 57600 / BUFFER_SIZE = 225. Ich erwarte also eigentlich eine 
Interruptfrequenz von 225Hz, nicht 114kHz.

Meine Beobachtung ist nun die folgende, dass der DMA.CH0 mit einer 
Frequenz von 114kHz ständig ein Interrupt schmeißt. CH1 wird nie 
aktiviert. Meine Parameter scheinen keinen Einfluss auf das Verhalten zu 
haben.

Habe ich ein Verdtänsnisproblem?

Vielen dank schonmal :)

[Knut B. (Firma: TravelRec.) (travelrec)]

Das DMA Interrupt Flag muss manuell durch das Schreiben einer 1 an die 
Bitposition gelöscht werden. Ansonsten feuert der Interrupt unentwegt, 
was die hohe Frequenz erklärt.

[Curby23523 N. (Gast)]

Danke, das hat insofern etwas geholfen, dass der Interrupt jetzt mit 
einer Frequenz von 800Hz statt 114kHz springt. Er sollte aber mit ca. 
25Hz laufen.

Auch wenn ich die Triggerquelle, den Timer, DEUTLICH verlangsamer - 
esbleiben jetzt immernoch 800Hz.

Ich lösche das Interrupt Flag mit dem Schreiben einer 1:

ISR(DMA_CH0_vect){
  PORTC_OUTTGL = PIN6_bm;
  DMA.CH0.CTRLB |= (1<<4);
  DMA.CH1.CTRLA |= DMA_CH_ENABLE_bm;
  //reloadBuffer(DMA_Buffer1);
}


ISR(DMA_CH1_vect){
  PORTC_OUTTGL = PIN5_bm;
  DMA.CH1.CTRLB |= (1<<4);
  DMA.CH0.CTRLA |= DMA_CH_ENABLE_bm;
  //reloadBuffer(DMA_Buffer2);
}

[Bastian W. (jackfrost)]

Hi,

damit deaktiviere ich den DMA Channel nachdem die Daten gesendet wurden.
Hast du geschaut ob ggf. das Errorbit gesetzt ist ?

In der ISR steht :

DMA_TX_CHANNEL.TRFCNT = 0;
DMA_TX_CHANNEL.CTRLA &= ~DMA_CH_ENABLE_bm;  // this shouldn't be necessary
DMA_TX_CHANNEL.CTRLB |= (DMA_CH_TRNIF_bm | DMA_CH_ERRIF_bm);

Ich lade aber die Adressen für Quelle und Ziel nicht nach. Du willst ja 
den ganzen Buffer senden, und bei jedem Timerüberlauf zwei Byte senden , 
oder ?

Ich sende bei mir immer den ganzen Inhalt des Arrays, aber bei dir 
sollte es auch gehen wenn du die Adressen nicht neu lädtst. Nur am Ende 
müsstest du den Buffer neu laden.

Hier meine Initialisierung, die Quelle weise ich bei mir erst kurz vor 
dem aufrufden zu. :

void DMA_TX_Raspi_Init()
{
  // reset source address
  DMA_TX_Raspi_CHANNEL.SRCADDR0 = 0;
  DMA_TX_Raspi_CHANNEL.SRCADDR1 = 0;
  DMA_TX_Raspi_CHANNEL.SRCADDR2 = 0;

  // set up destination address
  DMA_TX_Raspi_CHANNEL.DESTADDR0 = (((uint16_t) &USART_Netzwerk.DATA) >> 0) & 0xff;
  DMA_TX_Raspi_CHANNEL.DESTADDR1 = (((uint16_t) &USART_Netzwerk.DATA) >> 8) & 0xff;
  DMA_TX_Raspi_CHANNEL.DESTADDR2 = 0;

  DMA_TX_Raspi_CHANNEL.ADDRCTRL = DMA_CH_SRCRELOAD_NONE_gc;        // never reload source address
  DMA_TX_Raspi_CHANNEL.ADDRCTRL |= DMA_CH_SRCDIR_INC_gc;        // increment source address during transfer
  DMA_TX_Raspi_CHANNEL.ADDRCTRL |= DMA_CH_DESTRELOAD_NONE_gc;      // destination address does not need to be reloaded
  DMA_TX_Raspi_CHANNEL.ADDRCTRL |= DMA_CH_DESTDIR_FIXED_gc;        // the destination address should be fixed

  DMA_TX_Raspi_CHANNEL.TRIGSRC = DMA_CH_TRIGSRC_USARTF0_DRE_gc;      // automatically trigger a new burst when UARTF0 is ready
  DMA_TX_Raspi_CHANNEL.TRFCNT = 0;                    // reset block size
  DMA_TX_Raspi_CHANNEL.REPCNT = 0;                    // do not repeat block transfers
  DMA_TX_Raspi_CHANNEL.CTRLA = DMA_CH_SINGLE_bm;            // single shot mode (i.e. one burst transfer per trigger event)
  DMA_TX_Raspi_CHANNEL.CTRLA |= DMA_CH_BURSTLEN_1BYTE_gc;        // 1 byte bursts
  DMA_TX_Raspi_CHANNEL.CTRLB |= DMA_CH_TRNINTLVL_LO_gc;
}

Gruß JackFrost