XMega DMA transfers zu UART

[stefan s. (stef89)]

Hallo,

ich moechte auf einem XMega ueber den UART debug messages mit beliebiger 
Laenge ausgeben.
Um Verzoegerungen durch das Senden am UART zu vermeiden, moeche ich fuer 
die transfers DMA nutzen.

Basierend auf der AVR Appnote AVR1522 und dem Beispielcode habe ich 
bereits eine Loesung entwickelt die zwar bereits Daten ueber den UART 
verschickt, leider jedoch auch sehr häufig einzelne Bytes verliert.

Mein Grundgedanke ist folgender:
Ich habe einen Buffer mit 100 bytes in den ich die Debug-Meldung 
hineinschreibe. Die Debug Meldung kann dabei zwar maximal 99 bytes lang 
sein (wegen dem \0 am Ende des Strings), ueblicherweise ist sie aber 
viel kuerzer.
Sobald die Daten im Buffer sind, setze ich einen neuen DMA transfer auf, 
der den Inhalt des Puffers mit der gegebenen Laenge des jeweiligen 
Debug-Strings an den UART schicken soll.
Schicke ich mehere debug Meldungen hintereinander raus, so muss ich 
jedoch warten bis der DMA transfer beendet ist. Schliesslich wuerde ich 
sonst den Buffer ueberschreiben, der in dem Augenblick noch mittels dem 
letzten DMA Transfer zum UART geschickt wird.

Wie oben erwaehnt verliert meine debug-Ausgabe jedoch trotz warten immer 
wieder einzelne Bytes. Ich schicke also etwa ein "test-test-test" und 
beim UART kommt dann lediglich ein "tst-test-test" raus.

Das Warten realisiere ich derzeit mit

while (DMA_CH_IsOngoing(DMA_TX_CHANNEL) || DMA_CH_IsPending(DMA_TX_CHANNEL));
loop_until_bit_is_set(USART.STATUS, USART_DREIF_bp);

Weiss jemand, waran das liegt und wie ich das Problem in den Griff 
bekomme ?

Mein code basiert zum groessten Teil auf dem dma_driver Code von Atmel 
aua der Appnote AVR1522:

#define DBG(...)    \
        do {        \
            while (DMA_CH_IsOngoing(DMA_TX_CHANNEL) || DMA_CH_IsPending(DMA_TX_CHANNEL)); \
            loop_until_bit_is_set(USART.STATUS, USART_DREIF_bp); \
            uart_dma_send(snprintf_P((char *)uart_tx_buf, TX_BUFSIZE, __VA_ARGS__)); \
    } while(0)

#define DMA_Enable()        ( DMA.CTRL |= DMA_ENABLE_bm )

#define TX_BUFSIZE          100
#define DMA_TX_CHANNEL      &DMA.CH0

volatile uint8_t uart_tx_buf[TX_BUFSIZE];

// taken from Atmel dma_driver
void DMA_SetupBlock(volatile DMA_CH_t * channel,
                     const void * srcAddr,
                     DMA_CH_SRCRELOAD_t srcReload,
                     DMA_CH_SRCDIR_t srcDirection,
                     void * destAddr,
                     DMA_CH_DESTRELOAD_t destReload,
                     DMA_CH_DESTDIR_t destDirection,
                     uint16_t blockSize,
                     DMA_CH_BURSTLEN_t burstMode,
                     uint8_t repeatCount,
                     uint8_t useRepeat )
{
    channel->SRCADDR0 = (( (uint16_t) srcAddr) >> 0*8 ) & 0xFF;
    channel->SRCADDR1 = (( (uint16_t) srcAddr) >> 1*8 ) & 0xFF;
    channel->SRCADDR2 = 0;

    channel->DESTADDR0 = (( (uint16_t) destAddr) >> 0*8 ) & 0xFF;
    channel->DESTADDR1 = (( (uint16_t) destAddr) >> 1*8 ) & 0xFF;
    channel->DESTADDR2 = 0;

    channel->ADDRCTRL = (uint8_t) srcReload | srcDirection |
                                  destReload | destDirection;
    channel->TRFCNT = blockSize;
    channel->CTRLA = ( channel->CTRLA & ~( DMA_CH_BURSTLEN_gm | DMA_CH_REPEAT_bm ) ) |
                      burstMode | ( useRepeat ? DMA_CH_REPEAT_bm : 0);

    if ( useRepeat ) {
        channel->REPCNT = repeatCount;
    }
}

inline void DMA_EnableSingleShot(volatile DMA_CH_t * channel)
{
    channel->CTRLA |= DMA_CH_SINGLE_bm;
}

inline void DMA_SetTriggerSource(volatile DMA_CH_t * channel, uint8_t trigger)
{
    channel->TRIGSRC = trigger;
}

inline void DMA_EnableChannel(volatile DMA_CH_t * channel)
{
    channel->CTRLA |= DMA_CH_ENABLE_bm;
}

void DMA_StartTransfer(volatile DMA_CH_t * channel)
{
    channel->CTRLA |= DMA_CH_TRFREQ_bm;
}

uint8_t DMA_IsOngoing(void)
{
    uint8_t flagMask;
    flagMask = DMA.STATUS & 0xF0;
    return flagMask;
}

uint8_t DMA_CH_IsOngoing(volatile DMA_CH_t * channel)
{
    uint8_t flagMask;
    flagMask = channel->CTRLB & DMA_CH_CHBUSY_bm;
    return flagMask;
}

uint8_t DMA_CH_IsPending(volatile DMA_CH_t * channel)
{
    uint8_t flagMask;
    flagMask = channel->CTRLB & DMA_CH_CHPEND_bm;
    return flagMask;
}

uint8_t DMA_ReturnStatus_non_blocking(volatile DMA_CH_t * channel)
{
    uint8_t relevantFlags;
    relevantFlags = channel->CTRLB & (DMA_CH_ERRIF_bm | DMA_CH_TRNIF_bm);
    //relevantFlags = channel->CTRLB & DMA_CH_CHBUSY_bm;
    return relevantFlags;
}

void DMA_ResetChannel(volatile DMA_CH_t * channel)
{
    channel->CTRLA &= ~DMA_CH_ENABLE_bm;
    channel->CTRLA |= DMA_CH_RESET_bm;
    channel->CTRLA &= ~DMA_CH_RESET_bm;
}

inline void DMA_SetBlockSize(volatile DMA_CH_t * channel, uint16_t blocksize)
{
    channel->TRFCNT = blocksize;
}

void uart_init(void)
{
    USART_PORT.DIRSET = PIN3_bm;    // pin PC3 (TXD0) as output
    USART.CTRLC = USART_CHSIZE_8BIT_gc | USART_PMODE_DISABLED_gc;   // 8N1
    USART.BAUDCTRLA = (USART_BSEL & 0xff);                          // baudrate
    USART.BAUDCTRLB = (USART_BSCALE << USART_BSCALE_gp) | ((USART_BSEL>>8) & 0x0f); // baudrate
    USART.CTRLB |= USART_TXEN_bm;   // enable TX
}

void uart_dma_init(void)
{
    uart_init();
 DMA_SetTriggerSource(DMA_TX_CHANNEL, DMA_CH_TRIGSRC_USARTC0_DRE_gc);    // copy as soon as the uart data register can be written
    DMA_EnableSingleShot(DMA_TX_CHANNEL);   // one uart trigger should only transfer one burst (i.e. 1 byte)
}

// send what's in uart_tx_buffer
int uart_dma_send(uint16_t len)
{
    // we only support sending up to TX_BUFSIZE bytes
    if (len>TX_BUFSIZE)
        return -1;
    DMA_SetupBlock(DMA_TX_CHANNEL,  // DMA channel
        (void *)uart_tx_buf,
        DMA_CH_SRCRELOAD_NONE_gc,
        DMA_CH_SRCDIR_INC_gc,
        (void *) &USART.DATA,       // Destination
        DMA_CH_DESTRELOAD_BLOCK_gc, // Reload address at end of each block transfer
        //DMA_CH_DESTRELOAD_BURST_gc,
        DMA_CH_DESTDIR_FIXED_gc,    // Neither increment or decrement index
        len,                        // Block size
        DMA_CH_BURSTLEN_1BYTE_gc,
        0,                          // Perform once
        0                           // Disable repeat
    );
    DMA_EnableChannel(DMA_TX_CHANNEL);
    DMA_StartTransfer(DMA_TX_CHANNEL);

    return len;
}

int main(void)
{
    DMA_Enable();
    uart_dma_init();

    DBG(PSTR("test\n"));
    DBG(PSTR("test1\n"));
    DBG(PSTR("test-test-test\n"));

   while(1);
}

lg,
stef

[Heiko V. (xmegaman)]

Hallo Stefan,

hier meine Theorie:

Du kannst auf DMA_StartTransfer() verzichten, da der Trigger 
(DMA_CH_TRIGSRC_USARTC0_DRE_gc) vor der Aktion normalerweise immer TRUE 
ist.
D.h. der DMA-Vorgang wird schon bei DMA_Enable() gestartet!
Der danach folgende StartTransfer haut dann mehr oder weniger asynchron 
dazwischen und hat zur Folge, dass du ein Byte verlierst.

Ich nutze übrigens auch den DMA-Controller zur Ausgabe auf dem UART, 
starte den Vorgang aber immer nur mit CHEN und nie mit TRFREQ. Und es 
klappt...

Gruß vom

Xmegaman

[stefan s. (stef89)]

Hallo Heiko !

Heiko vG schrieb:
> Hallo Stefan,
>
> hier meine Theorie:
>
> Du kannst auf DMA_StartTransfer() verzichten, da der Trigger
> (DMA_CH_TRIGSRC_USARTC0_DRE_gc) vor der Aktion normalerweise immer TRUE
> ist.
> D.h. der DMA-Vorgang wird schon bei DMA_Enable() gestartet!
> Der danach folgende StartTransfer haut dann mehr oder weniger asynchron
> dazwischen und hat zur Folge, dass du ein Byte verlierst.

Ich habe jetzt ganz auf den Atmel Code verzichtet und alles selbst 
implementiert.
Das Resultat: Weniger Code wird ausgefuehrt und es funktioniert ;)
Ich habe nicht mehr weiter nachgeschaut weshalb der obige Code nicht 
funktioniert hat.
Jedenfalls habe ich jetzt den DMA channel so aufgesetzt, dass er fuer 
jede transaction die src und dst Addressen reloaded.
Die bursts (1 byte zum UART.DATA register) triggert er selbst ueber 
DMA_CH_TRIGSRC_USARTC0_DRE_gc.
Um einen Transfer zu starten setze ich auf dem DMA channel einfach das 
enable bit.
Ob ein transfer fertig ist, erkenne ich am CHBUSY bit im CTRLB Register 
des DMA channels.

Waehrend ich Atmel dafuer dankbar bin, dass sie zu ihren Appnotes auch 
example Code hinzufuegen, kann ich nur jedem empfehlen den Code 
lediglich als Referenz fuer die eigene Implementation zu verwenden.


> Ich nutze übrigens auch den DMA-Controller zur Ausgabe auf dem UART,
> starte den Vorgang aber immer nur mit CHEN und nie mit TRFREQ. Und es
> klappt...

Ja, das mache ich jetzt auch so. Ist aus meiner Sicht auch der einzig 
richtige Weg, da TRFREQ ja lediglich fuer das triggern eines Transfers 
(und nicht einer vollstaendigen transaction) gedacht ist.
Vielmehr triggern sich in unsrem Fall die einzelnen bursts ja von selbst 
durch DMA_CH_TRIGSRC_USARTC0_DRE_gc.


Was mich jedoch noch stoert ist folgendes:
Sendet man zwei Messages hintereinander, so muss man beim Senden der 
zweiten Nachricht erst recht wieder warten bis die DMA transaction der 
letzten Nachricht abgeschlossen ist.
Ansonsten wuerde man vorzeitig in den gemappten DMA buffer schreiben und 
kauderwelsch ausgeben.
Zumindest begrenzte Abhilfe wuerde aus meiner Sicht etwa ein Ringbuffer 
oder double buffering bieten.

Fuer ersteres wuerdest du einfach immer deine Nachrichten den den 
gemappten DMA buffer anhaengen.
Wuerde man ueber das Pufferende schreiben, so faehrt man einfach am 
Anfang des Buffers fort (Ringbuffer).
Natuerlich darf man noch nicht gesendete Nachrichten nicht 
ueberschreiben.
Es darf also nicht zu einem Ringbuffer-Overrun kommen.
Jedenfalls waere mein Idee dann einen Interrupt Handler fuer den DMA 
Channel aufzusetzen (transaction complete), in welcher automatisch die 
naechste DMA transaction getriggert wird.

Damit koennte man dann ohne jegliches Warten messages senden solange der 
Ringbuffer nicht voll ist.

Hast du etwas in dieser Richtung schon implementiert ?
Ich muss erst mal sehen obs nicht auch ohne Ringbuffer in meiner 
Applikation geht.

lg,
Stef

[Heiko V. (xmegaman)]

stefan m. schrieb:

> Ich habe jetzt ganz auf den Atmel Code verzichtet und alles selbst
> implementiert.
> Das Resultat: Weniger Code wird ausgefuehrt und es funktioniert ;)

Hat den weiteren Vorteil, dass man wirklich versteht, was passiert ;)

> Ich habe nicht mehr weiter nachgeschaut weshalb der obige Code nicht
> funktioniert hat.

Je länger ich darüber nachdenke, desto sicherer bin ich, dass das 
nachträgliche Anschubsen mittels DMA_StartTransfer() absolut 
kontraproduktiv ist. Der Witz besteht bei Quellen, die aus der 
xmega-Peripherie kommen, ja gerade darin, dass diese selbst den Transfer 
anstoßen!
Das manuelle Triggern wird nur für DMA-Tranfers gebraucht, die selbst 
keinen Trigger auslösen können, z. B. blockweise Daten vom internen ins 
externe RAM kopieren.

> Jedenfalls habe ich jetzt den DMA channel so aufgesetzt, dass er fuer
> jede transaction die src und dst Addressen reloaded.

Ich denke mal dst reload ist sogar überflüssig, da kein 
Adress-Inkr./Dekr. benötigt wird.

> Die bursts (1 byte zum UART.DATA register) triggert er selbst ueber
> DMA_CH_TRIGSRC_USARTC0_DRE_gc.

Kann auch nur so funktionieren, da der UART trotz FIFO nur 1 Byte pro 
Trigger verarbeiten kann (Stichwort Handshake).

> Um einen Transfer zu starten setze ich auf dem DMA channel einfach das
> enable bit.
> Ob ein transfer fertig ist, erkenne ich am CHBUSY bit im CTRLB Register
> des DMA channels.

Achtung: Hier kann eine weitere Falle lauern. Obwohl der DMA-Vorgang 
fertig ist, ist der UART u. U. noch am Senden, was ja deutlich langsamer 
ist (je nach Baudrate) als der DMA-Zufgriff. Will man nämlich den UART 
nach dem Transfer umprogrammieren oder ein DTR-Signal o. ä. erzeugen, 
muss man auch noch warten bis der UART kopmplett fertig ist. (Ich weiß, 
das ist bei dir nicht der Fall).

> Waehrend ich Atmel dafuer dankbar bin, dass sie zu ihren Appnotes auch
> example Code hinzufuegen, kann ich nur jedem empfehlen den Code
> lediglich als Referenz fuer die eigene Implementation zu verwenden.

Und man sollte IMMER ins aktuellste Datenblatt schauen...

> ... Ringbuffer ...
>
> Hast du etwas in dieser Richtung schon implementiert ?
> Ich muss erst mal sehen obs nicht auch ohne Ringbuffer in meiner
> Applikation geht.

Ich sehe ein Problem dabei: Du müsstest mit unlimited repeat arbeiten. 
Das geht solange gut, wie immer messages im Buffer stehen. Was aber wenn 
der Buffer 'leer' ist (d. h. alle messages abgearbeitet) ?

Aber eigentlich ist genau für dieses Probelm der Double Buffer Modus 
gedacht. Natürlich kann es hier zum Busy Waiting kommen, aber immerhin 
kann man nahtlos messages rausschicken.

Gruß

Xmegaman

[stefan s. (stef89)]

Heiko vG schrieb:
>> ... Ringbuffer ...
>>
>> Hast du etwas in dieser Richtung schon implementiert ?
>> Ich muss erst mal sehen obs nicht auch ohne Ringbuffer in meiner
>> Applikation geht.
>
> Ich sehe ein Problem dabei: Du müsstest mit unlimited repeat arbeiten.
> Das geht solange gut, wie immer messages im Buffer stehen. Was aber wenn
> der Buffer 'leer' ist (d. h. alle messages abgearbeitet) ?

Nein, ich wuerde bei jedem Schreibvorgang in den Ringbuffer immer nur 
genau eine DMA transaction starten (und das auch nur wenn nicht bereits 
eine laeuft).
Falls die Nachricht ueber die obere Grenze des Ringpuffers hinaus geht, 
wird nur der aktuelle Chunk vor dem Bufferende transferiert.

Damit das ganze funktioniert, gibt es zusaetzlich einen (high-level) 
transaction-complete interrupt handler.
In dem werden die ringbuffer Datenstrukturen upgedatet (etwa wie viele 
bytes noch frei oder noch zu senden sind) und falls noch Daten im 
Ringpuffer sind, wird wieder (gleich wie oben) eine neue DMA transaction 
fuer einen chunk angestossen.

Nehmen wir an, dass mein Ringbuffer 20 bytes gross ist.

Im ersten Fall moechte ich lediglich ein "Hallo!" (6 bytes) ausgeben, 
danach folgen keine weiteren Daten.
In diesem Fall wird das "Hallo!" sofort in den Ringpuffer geschrieben 
(es sind ja noch 20 bytes frei) und eine DMA transaction wird gestartet.
Irgendwann ist die transaction complete und im interrupt werden die 
Datenstrukturen upgedatet (free=20, tosend=0).
Nachdem es keine Daten mehr zu senden gibt, wird keine neue DMA 
transaction durch den interrupt handler angestossen.

Im zweiten Fall moechte ich 3 mal hintereinander "Hallo!" ausgeben.
Das erste "Hallo!" wird in den Ringpuffer kopiert (free=14, tosend=6) 
und eine DMA transaction fuer 6 bytes wird angestossen.
Waehrend die transaction laeuft, schreibe ich noch zwei weitere "Hallo!" 
in den Ringpuffer: zuerst (free=8, tosend=12), dann (free=2, tosend=18).
Das geht ohne Warten, weil im Ringpuffer ja genug Platz ist.
Beim Schreiben in den Ringbuffer werden keine neue DMA transactions 
gestartet, weil ja noch die erste DMA transaction (fuer 6 byte) im Gange 
ist.
Irgendwann ist die DMA transaction fertig und wir landen im transaction 
complete interrupt.
Dort werden die Datenstrukturen upgedatet: (free=8, tosend=12).
Nachdem nun noch 12 bytes "Hallo!Hallo!" zu senden sind, wird eine neue 
DMA transaction fuer 12 bytes angeworfen).
Ist diese fertig (und es sind keine Daten mehr im Ringbuffer), so wird 
schliesslich keine neue DMA transaction mehr gestartet (es gaebe ja 
nichts mehr zu senden).

Im dritten Fall moechte ich 4 mal hintereinander "Hallo!" senden.
Das funktioniert gleich wie im vorherigen Fall, jedoch ist nach dem 3. 
Schreibvorgang der Ringbuffer so voll, dass das letzte "Hallo!" nicht 
mehr in den Puffer passt (free=2, tosend=18).
Man koennte zwar die 2 bytes noch schreiben und den Rest spaeter, aber 
einfacherweise lassen wir das und warten (busy-waiting) stattdessen bis 
wieder zumindest 6 bytes im Ringpuffer frei sind.
Nach dem ersten transaction complete interrupt ist im Ringpuffer wieder 
genug Platz und das 4. "Hallo!" kann in den Ringbuffer geschrieben 
werden (das "Ha" steht am Ende des Buffers, das "llo!" am Anfang.
Wie oben werden durch den transaction complete interrupt handler weitere 
transactions angestossen. Fuer das "[......]Ha" und das "llo!" gibt es 
aber eine eigene transaction, da der Lesevorgang wieder am Beginn des 
Puffers stattfinden soll (ist ja ein Ringbuffer).

Damit lassen sich nahtlos messages schicken. Je groesser man den 
Ringbuffer macht, dest unwahrscheinlicher wird es, dass man irgendwann 
busy-waiten muss weil der Ringbuffer voll ist.

> Aber eigentlich ist genau für dieses Probelm der Double Buffer Modus
> gedacht. Natürlich kann es hier zum Busy Waiting kommen, aber immerhin
> kann man nahtlos messages rausschicken.

Aus meiner Sicht geht das nur solange ich nicht mehr als 2 messages 
schicken will.
Erste message: channel1, zweite message: channel2.
Ist das Senden der ersten Message fertig, wird automatisch der transfer 
der zweiten message gestartet.

Will ich aber 3 oder noch mehr Nachrichten hintereinander schicken, muss 
ich erst recht wieder warten. Nach der ersten message ist die DMA 
transaction auf channel1 im gange. Bei der zweiten message ist noch 
immer die DMA transaction auf channel1 im Gange, ich kann aber schon 
channel2 aufsetzen. Bei der dritten message ist noch immer die erste 
transaction im Gange, die zweite transaction schon vorbereitet und ich 
muesste warten, bis die erste transaction fertig ist.

Mit der ringbuffer-Loesung hast du dieses Problem nicht so schnell:

 * man kann ihn mit mehreren messages vollschreiben (verfuegbarer Platz 
wird weniger)
 * der Puffer wird gleichzeitig wieder durch die DMA transactions 
geleert (verfuegbarer Platz wird mehr)
 * bei vielen messages im Ringbuffer wird nicht jede message einzeln 
uebertragen, sondern stattdessen lediglich eine grosse DMA transaction 
durchgefuehrt (bei einem Uebergang im Ringbuffer sind es zwei 
transactions)
 * die Groesse des Ringbuffers ist frei waehlbar


Aktuell ist mir jedoch (unabhaengig von der Ringbuffer Idee) was 
eigenartiges aufgefallen:

Ich werfe eine DMA transaction an und habe den transaction complete 
interrupt aktiviert.
Wurden meine Daten mittels der DMA transaction transferiert, so sollte 
sich der DMA channel deaktivieren und ich einen interrupt bekommen.
Stattdessen wird mein interrupt handler aber endlos aufgerufen, obwohl
der channel bereits deaktiviert (DMA_CH_ENABLE_bp clear) und nicht mehr 
busy (DMA_CH_CHBUSY_bp clear) ist.
Im Datenblatt kann ich nichts zu dem Verhalten finden. Muss ich da die 
interrupt flag selbst loeschen ? Ist das ein bug ?


lg,
Stef

[stefan s. (stef89)]

stefan m. schrieb:
> Stattdessen wird mein interrupt handler aber endlos aufgerufen, obwohl
> der channel bereits deaktiviert (DMA_CH_ENABLE_bp clear) und nicht mehr
> busy (DMA_CH_CHBUSY_bp clear) ist.
> Im Datenblatt kann ich nichts zu dem Verhalten finden.

Ich hab nun doch was bei den flags gefunden:

"Since the DMA Channel Transaction Complete Channel Error Interrupt 
share interrupt address with DMA Channel Error Interrupt, the TRNIF will 
not be cleared when the interrupt vector is executed. This flag is 
cleared by writing a one to the bit location."

Demnach muss man zwei Dinge beachten:
1) bei einem interrupt muss man die flag selbst loeschen
2) die flag geloescht, indem man das jeweilige bit setzt (und nicht 
loescht)

lg,
stef

[Heiko V. (xmegaman)]

Super, wenn's mit Ringbuffer klappt!

Weiterer Vorteil: Du brauchst nur einen DMA-Channel anstatt zweien.

> Ich hab nun doch was bei den flags gefunden:
>
> "Since the DMA Channel Transaction Complete Channel Error Interrupt
> share interrupt address with DMA Channel Error Interrupt, the TRNIF will
> not be cleared when the interrupt vector is executed. This flag is
> cleared by writing a one to the bit location."
>
> Demnach muss man zwei Dinge beachten:
> 1) bei einem interrupt muss man die flag selbst loeschen
> 2) die flag geloescht, indem man das jeweilige bit setzt (und nicht
> loescht)

Wie gesagt, Datenblatt studieren hilft ungemein.

Manchmal ist es aber auch irritierend. Es fehlt z. B. ein eindeutiger 
Hinweis zum TRFREQ-Flag (s. o.).

Hat Spaß gemacht mit dir zu fachsimpeln, Stef!

Gruß

Xmegaman

[stefan s. (stef89)]

Heiko vG schrieb:
> Weiterer Vorteil: Du brauchst nur einen DMA-Channel anstatt zweien.

Stimmt, das natuerlich auch ;)

> Manchmal ist es aber auch irritierend. Es fehlt z. B. ein eindeutiger
> Hinweis zum TRFREQ-Flag (s. o.).

Ja, manchmal muss man dann eben doch einfach probieren.
Ich hab die Atmel Datenblaetter trotzdem lieb gewonnen. Das meiste wird 
nach wie vor kurz und buendig beschrieben.
In einigen Faellen sind mir da schon ganz andere Datenblaetter ueber den 
Weg gekommen ;)


> Hat Spaß gemacht mit dir zu fachsimpeln, Stef!

Ebenfalls !
War sicher nicht mein letzter xmega post ;)

lg und schoenes wochenende noch,
Stef

[Mats M. (elektrofreak)]

Hallo,

ich habe deine Beiträge gelesen und stecke bei dem selben Problem bzw. 
einer sinnvollen Implementierung eines Ringbuffers. Möchtest du deinen 
Code hochladen, sodass auch andere Forenmitglieder den Code aus der 
Appnote und von dir als Vorlage verwenden können? Mir persönlich würde 
er viel helfen, da ich leider keinen JTAG debugger habe und somit nur 
per trial und error zum Ziel kommen würde.

Vielen herzlichen Dank!
Elektrofreak

[stefan s. (stef89)]

Hallo,

Mats Marcus schrieb:
> Möchtest du deinen
> Code hochladen, sodass auch andere Forenmitglieder den Code aus der
> Appnote und von dir als Vorlage verwenden können?

ich stelle den Code hier unter der GPLv2 zur Verfuegung und wuerde mich 
freuen an evt. Verbesserungen teilhaben zu koennen.
Aktuell hat der Code noch den Nachteil, dass er nicht verlaesslich aus 
einer ISR heraus aufgerufen werden kann.
Ich habe zwar eine entsprechende Funktion erstellt 
(isr_write_to_txringbuf()), da sie nicht warten kann, arbeitet sie 
jedoch nur nach dem "best effort" Prinzip.

Hier ist der (hoffentlich vollstaendige) Code:

#define DEBUG
#define F_CPU         32000000UL    // 32 MHz (after crystal clock initialization)
#define LED_PORT      PORTE
#define USART_PORT       PORTC      // USART connected to USB bridge
#define USART         USARTC0
#define USART_BSEL      2094      // 115200 baud at 32MHz sys clock
#define USART_BSCALE    (-7)


#ifdef DEBUG
#define DBG(...)  \
    do {    \
      printf_P(__VA_ARGS__); \
  } while(0)
#else
#define DBG(...)
#endif

#define ENTER_CRITICAL_REGION( ) saved_sreg = SREG; \
                                     cli();
#define LEAVE_CRITICAL_REGION( ) SREG = saved_sreg;

#define TX_RINGBUFSIZE    0xff
#define DMA_TX_CHANNEL     DMA.CH0

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/eeprom.h>
#include <util/delay.h>
#include <util/atomic.h>
#include <math.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

int uart_putchar(char c, FILE *unused);
int uart_dma_putchar(char c, FILE *unused);
int isr_uart_dma_putchar(char c, FILE *unused);

FILE mystdout = FDEV_SETUP_STREAM(uart_putchar, NULL, _FDEV_SETUP_WRITE);
FILE mystdout_dma = FDEV_SETUP_STREAM(uart_dma_putchar, NULL, _FDEV_SETUP_WRITE);
FILE mystdout_isr_dma = FDEV_SETUP_STREAM(isr_uart_dma_putchar, NULL, _FDEV_SETUP_WRITE);

volatile uint8_t saved_sreg;

volatile struct {
  char buf[TX_RINGBUFSIZE];
  uint16_t read_index;          // start of area currently used for DMA reading
  uint16_t write_index;          // start of area that can be written to
  uint16_t new_data_len;          // length of new data to transfer
  uint16_t free;              // number of free bytes that can be written
  uint8_t isr_done;
} tx_ringbuf;

void uart_init(void)
{
  USART_PORT.DIRSET = PIN3_bm;  // pin PC3 (TXD0) as output
  USART.CTRLC = USART_CHSIZE_8BIT_gc | USART_PMODE_DISABLED_gc;  // 8N1
  USART.BAUDCTRLA = (USART_BSEL & 0xff);              // baudrate
  USART.BAUDCTRLB = (USART_BSCALE << USART_BSCALE_gp) | ((USART_BSEL>>8) & 0x0f);  // baudrate
  USART.CTRLB |= USART_TXEN_bm;  // enable TX
}

void uart_send(uint8_t *buffer, uint16_t len)
{
  uint16_t i;

  for (i=0; i<len; i++)
  {
    loop_until_bit_is_set(USART.STATUS, USART_DREIF_bp);
    USART.DATA=buffer[i];
  }
}

int uart_putchar(char c, FILE *unused)
{
  loop_until_bit_is_set(USART.STATUS, USART_DREIF_bp);
  USART.DATA=c;
  
  return 0;
}

void init_tx_ringbuf(void)
{
  tx_ringbuf.read_index=0;
  tx_ringbuf.write_index=0;
  tx_ringbuf.new_data_len=0;
  tx_ringbuf.isr_done=1;
  tx_ringbuf.free=TX_RINGBUFSIZE;
}

// this can not be called from within an ISR !
int write_to_txringbuf(char *buf, int len)
{
  uint16_t i, maxlen, transfer_len, src_addr;

  if (len>TX_RINGBUFSIZE)
    return -1;
  
  // busy wait until there is enough space in the ringbuffer
  while (tx_ringbuf.free<len);

  // busy wait until ISR is done
  while (!tx_ringbuf.isr_done);

  for (i=0; i<len; i++)
    tx_ringbuf.buf[(tx_ringbuf.write_index+i) % TX_RINGBUFSIZE] = buf[i];
  
  ENTER_CRITICAL_REGION();
  tx_ringbuf.write_index = (tx_ringbuf.write_index + len) % TX_RINGBUFSIZE;
  tx_ringbuf.free-=len;
  tx_ringbuf.new_data_len+=len;


  // if there is no DMA transfer in progress already, initiate a new one
  if (bit_is_clear(DMA_TX_CHANNEL.CTRLB, DMA_CH_CHBUSY_bp) && bit_is_clear(DMA_TX_CHANNEL.CTRLA, DMA_CH_ENABLE_bp) && tx_ringbuf.isr_done)
  {
    maxlen=TX_RINGBUFSIZE-tx_ringbuf.read_index;  // maximum length for this transfer

    // only transfer data up to the buffer boundary
    if (tx_ringbuf.new_data_len>maxlen)
      transfer_len=maxlen;
    else
      transfer_len=tx_ringbuf.new_data_len;

    //printf_P(PSTR("write_to_txringbuf: starting transfer (%i of %i)\n"), transfer_len, tx_ringbuf.new_data_len);

    src_addr = ((uint16_t)tx_ringbuf.buf) + tx_ringbuf.read_index;
    
    DMA_TX_CHANNEL.SRCADDR0 = (src_addr >> 0) & 0xff;
    DMA_TX_CHANNEL.SRCADDR1 = (src_addr >> 8) & 0xff;
    DMA_TX_CHANNEL.SRCADDR2 = 0;
    DMA_TX_CHANNEL.TRFCNT = transfer_len;
    DMA_TX_CHANNEL.CTRLA |= DMA_CH_ENABLE_bm;

    tx_ringbuf.isr_done=0;
  }


  LEAVE_CRITICAL_REGION();
  return len;
}

int isr_write_to_txringbuf(char *buf, int len)
{
  uint16_t i, maxlen, transfer_len, src_addr;

  if (len>TX_RINGBUFSIZE)
    return -1;
  
  // busy wait until there is enough space in the ringbuffer
  if (tx_ringbuf.free<len)
    return -1;

  // busy wait until ISR is done
  //while (!tx_ringbuf.isr_done);

  for (i=0; i<len; i++)
    tx_ringbuf.buf[(tx_ringbuf.write_index+i) % TX_RINGBUFSIZE] = buf[i];
  
  //ENTER_CRITICAL_REGION();
  tx_ringbuf.write_index = (tx_ringbuf.write_index + len) % TX_RINGBUFSIZE;
  tx_ringbuf.free-=len;
  tx_ringbuf.new_data_len+=len;


  // if there is no DMA transfer in progress already, initiate a new one
  if (bit_is_clear(DMA_TX_CHANNEL.CTRLB, DMA_CH_CHBUSY_bp) && bit_is_clear(DMA_TX_CHANNEL.CTRLA, DMA_CH_ENABLE_bp) && tx_ringbuf.isr_done)
  {
    maxlen=TX_RINGBUFSIZE-tx_ringbuf.read_index;  // maximum length for this transfer

    // only transfer data up to the buffer boundary
    if (tx_ringbuf.new_data_len>maxlen)
      transfer_len=maxlen;
    else
      transfer_len=tx_ringbuf.new_data_len;

    //printf_P(PSTR("write_to_txringbuf: starting transfer (%i of %i)\n"), transfer_len, tx_ringbuf.new_data_len);

    src_addr = ((uint16_t)tx_ringbuf.buf) + tx_ringbuf.read_index;
    
    DMA_TX_CHANNEL.SRCADDR0 = (src_addr >> 0) & 0xff;
    DMA_TX_CHANNEL.SRCADDR1 = (src_addr >> 8) & 0xff;
    DMA_TX_CHANNEL.SRCADDR2 = 0;
    DMA_TX_CHANNEL.TRFCNT = transfer_len;
    DMA_TX_CHANNEL.CTRLA |= DMA_CH_ENABLE_bm;

    tx_ringbuf.isr_done=0;
  }


  //LEAVE_CRITICAL_REGION();
  return len;
}

int uart_dma_putchar(char c, FILE *unused)
{
  write_to_txringbuf(&c, 1);
  return 0;
}

int isr_uart_dma_putchar(char c, FILE *unused)
{
  isr_write_to_txringbuf(&c, 1);
  return 0;
}

void setup_dma_tx_channel(void)
{
  // reset source address
  DMA_TX_CHANNEL.SRCADDR0 = 0;
  DMA_TX_CHANNEL.SRCADDR1 = 0;
  DMA_TX_CHANNEL.SRCADDR2 = 0;

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

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

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

  DMA_TX_CHANNEL.CTRLB |= DMA_CH_TRNINTLVL_LO_gc;          // enable DMA transfer complete interrupt for this channel, low priority
}


int main(void)
{
  stdout = &mystdout;      // redirect STDOUT

  setup_dma_tx_channel();

  // enable DMA controller
  DMA.CTRL |= DMA_ENABLE_bm;

  // allow low- and high-level interrupts
  PMIC.CTRL |= PMIC_LOLVLEN_bm | PMIC_HILVLEN_bm;

  // enable interrupts
  sei();

  // switch stdout to DMA
  stdout = &mystdout_dma;
  printf_P(PSTR("Test ! This is a message sent over DMA\n"));


  while(1)
  {
  }
}

// This ISR is called whenever a transaction on the DMA_TX_CHANNEL has completed
ISR(DMA_CH0_vect, ISR_BLOCK)
{
  uint16_t read_index, new_data_len, len, maxlen, last_read_len;
  uint16_t src_addr;

  if (bit_is_set(DMA_TX_CHANNEL.CTRLB, DMA_CH_CHBUSY_bp))
  {
    printf_P(PSTR("DMA_CH0_vect: ieeeeee: DMA_TX_CHANNEL is still busy !\n"));
    while(1);
  }

  last_read_len=DMA_TX_CHANNEL.TRFCNT;  // number of bytes transferred in the last DMA transaction
  tx_ringbuf.read_index=(tx_ringbuf.read_index+last_read_len) % TX_RINGBUFSIZE;

  if (last_read_len>tx_ringbuf.new_data_len)
  {
    printf_P(PSTR("DMA_CH0_vect: ieeeeee: last_read_len(%i)>tx_ringbuf.new_data_len(%i) !!!\n"), 
      last_read_len, tx_ringbuf.new_data_len);
    while(1);
  }

  tx_ringbuf.new_data_len-=last_read_len;
  tx_ringbuf.free+=last_read_len;
  read_index=tx_ringbuf.read_index;
  new_data_len=tx_ringbuf.new_data_len;
    
  //printf_P(PSTR("DMA_CH0_vect: last_read_len: %i, new_data_len: %i\n"), last_read_len, new_data_len);

  // if there is data left to transfer, initiate a new DMA transaction
  if (new_data_len>0)
  {
    // maximum length for this transfer
    maxlen=TX_RINGBUFSIZE-read_index;

    // only transfer data up to the buffer boundary
    if (new_data_len>maxlen)
      len=maxlen;
    else
      len=new_data_len;
    
    //printf_P(PSTR("DMA_CH0_vect: starting transfer (%i of %i)\n"), len, tx_ringbuf.new_data_len);

    // set source address
    src_addr = ((uint16_t)tx_ringbuf.buf) + read_index;

    DMA_TX_CHANNEL.SRCADDR0 = (src_addr >> 0) & 0xff;
    DMA_TX_CHANNEL.SRCADDR1 = (src_addr >> 8) & 0xff;
    DMA_TX_CHANNEL.SRCADDR2 = 0;
    DMA_TX_CHANNEL.TRFCNT = len;                    // set up size of transaction
    DMA_TX_CHANNEL.CTRLA |= DMA_CH_ENABLE_bm;              // enable channel, transfer data to uart now
  }
  else
  {
    // otherwise reset the DMA channel
    DMA_TX_CHANNEL.TRFCNT = 0;
    DMA_TX_CHANNEL.CTRLA &= ~DMA_CH_ENABLE_bm;  // this shouldn't be necessary
    
  }

  // since ERRIF and TRNIF share the same interrupt, we need to clear
  // the interrupt flag manually by *setting* the corresponding flag bits
  DMA_TX_CHANNEL.CTRLB |= (DMA_CH_TRNIF_bm | DMA_CH_ERRIF_bm);

  tx_ringbuf.isr_done=1;
}

lg,
stef

[Tim (Gast)]

Hallo, bin auch gerade beim Einarbeiten. Meine Idee zum Transfer einer 
Anzahl Pufferbytes zum USART wäre einfach die Initialisierung eines 
Blocktransfers mit inkrementierender Source- und fixer USART-Data 
Adresse... Synchronisiert sich das hinsichtlich Speed dann selber oder 
geht das so prinzipiell nicht?

[peter (Gast)]

es synct sich nur, wenn du vom usart aus triggerst. Also DRE als 
transaction start.

  #define DMA_F_TX_CHANNEL 0  //dma channel
  #define USART_TX_BUFF_SIZE 32 //size of the tx buffer

  char TX[USART_TX_BUFF_SIZE];//tx  buffer
  struct dma_channel_config dmach_tx_conf; //

  dma_channel_set_burst_length(&dmach_tx_conf, DMA_CH_BURSTLEN_1BYTE_gc);//1 byte bursts
  dma_channel_set_transfer_count(&dmach_tx_conf, USART_TX_BUFF_SIZE);//set tx buffer size as transfer size
  dma_channel_set_src_reload_mode(&dmach_tx_conf,DMA_CH_SRCRELOAD_TRANSACTION_gc);//transaction reload for src
  dma_channel_set_dest_reload_mode(&dmach_tx_conf,DMA_CH_SRCRELOAD_NONE_gc); //no reload
  dma_channel_set_src_dir_mode(&dmach_tx_conf, DMA_CH_SRCDIR_INC_gc);//inc src for tx buff
  dma_channel_set_source_address(&dmach_tx_conf,(uint16_t)(uintptr_t)&TX);//tx buffer as src
  dma_channel_set_dest_dir_mode(&dmach_tx_conf, DMA_CH_DESTDIR_FIXED_gc);//dest fixed
  dma_channel_set_destination_address(&dmach_tx_conf,(uint16_t)(uintptr_t)&USARTF0.DATA);// usart data register as destination
  dma_channel_set_trigger_source(&dmach_tx_conf, DMA_CH_TRIGSRC_USARTF0_DRE_gc);//set data register empty as trigger src
  dma_channel_set_single_shot(&dmach_tx_conf);//set channel to single shot
  dma_channel_set_repeats(&dmach_tx_conf,1);//disable repeat feature


  dma_enable();//enable dma controller
  dma_set_priority_mode(DMA_PRIMODE_CH0123_gc);//set fixed pri mode
  
    dma_set_callback(DMA_F_TX_CHANNEL, dma_F_TX_transfer_done);//set transfer done callback for channel
    dma_channel_set_interrupt_level(&dmach_tx_conf, DMA_INT_LVL_LO);//set iterrupt lvl low
  dma_channel_write_config(DMA_F_TX_CHANNEL, &dmach_tx_conf);//write config to channel


//callback:
static inline void dma_F_TX_transfer_done(enum dma_channel_status status)
{
      for(;;)
      {
        if(usart_tx_is_complete(&USARTF0)==true)//wait for the byte to leave the shift reg
        {
          break;
        }
      }
}

ein dma_channel_enable(DMA_F_TX_CHANNEL); startet den transfer. wenn 
USARTF0 DRE interrupt feuert wird das nächste bit nach USARTF0.DATA 
gepackt. wenn USART_TX_BUFF_SIZE errweicht wird, dann ruft er den 
callback aus der dma ISR auf.

[peter (Gast)]

obriger code ist für ASF 3.7.3 asf.atmel.com/docs/latest/