DMX Lib für Xmega bekannt?

[Chris N. (Gast)]

Hallo zusammen,

hat jemand von euch eine brauchbare Library für DMX Senden und Empfangen 
auf Atmel XMEGA in C zu Hand oder ist über sowas schonmal gestolpert? Am 
besten währe natürlich mit Einsatz des DMA Controllers, damit die 
Systemlast gering bleibt.

Bei Elektor gab es wohl mal eine solche Codesammelung, leider hat der 
Author die Dateien wieder gelöscht.

Gruß Chris

[Chris N. (Gast)]

Hallo zusammen,

da scheinbar keiner eine Lösung hat, habe ich angefangen einen DMX 
Sender für den Atxmega256A3U zu schreiben. Zur Verbesserung der 
Systemperformance nutzte ich den DMA Modus für den Datentransfer aus dem 
DMX Datenarray hinüber zum UART. Bis dahin funktioniert das Programm 
auch schon. Daten senden via UART läuft.
Probleme macht mir die Erzeugung des DMX spezifischen Frame Starts. DMX 
Verlangt ja einen 88µs Break, gefolgt von 8µs Mark vor der eigentlichen 
Datenübertragung. Zur Erzeugung dieser Bedingung wollte ich mit 
verlangsamter Datenrate eine 0x00 senden. Zusammen mit der "Null" vom 
Start Bit und den zwei "Eins" Stop Bits kommt man bei 100 kBaud so auf 
90µs für den Break und 20 µs Mark.
Leider schaffe ich es nicht die Datenrate zur Laufzeit zu ändern. Die 
grandiosen Debug Fähigkeiten des AVR Studio 6 sind dort auch keine große 
Hilfe. In meinem Programm warte ich darauf, dass das Data Register Empty 
flag gelöscht wird, ehe ich neue Daten in den Sendepuffer stelle. Der 
Debugger steppt auch schön durch, jedoch erhalte ich das gesamte 
Datenpacket immer mit der 250kBaud Datenrate an einem Stück.
Jemand eine Idee wie man den XMega dazu bewegen kann die Datenrate des 
UART zur Laufzeit zu änder? Oder geht das beim XMega nicht mehr? Wobei 
mir kommt gerade eine Idee, geht das ändern der Datenrate vielleicht nur 
während einer ISR?

Wie dem auch sei, hier mal der Quelltext für den DMX Output. Im 
Hautprogramm stelle ich eigentlich nur einen Systemtakt von 32 MHz ein 
und rufe dann die 3 Funktionen aus der dmx.h

/*
dmx.c
Functions to send DMX data via USART 
Uses DMA to minimize system load during transfer of 512 bytes payload 
 */ 


#include "dmx.h"
#include <stdlib.h>
#include <avr/io.h>

//The Buffer from where the DMX Data is read, Filled for test purpose with ABCDEABC...
uint8_t dmxdata[dmxchannels] = {0x41,0x42,0x43,0x44,0x45,0x41,0x42,0x43,0x44,0x45,0x41,0x42,0x43,0x44,0x45,0x41,0x42,0x43,0x44,0x45}; 

//Configure DMA to transfer data from dmx buffer into usart buffer
void dma_init(void){
  
  // activate single buffer, burst size 1Byte
  DMA.CTRL = DMA_CH_ENABLE_bm; 
  
  //Modus transaction, increase and decrease, Burst
  DMA.CH0.ADDRCTRL = DMA_CH_SRCRELOAD_TRANSACTION_gc | DMA_CH_SRCDIR_INC_gc| DMA_CH_DESTRELOAD_NONE_gc | DMA_CH_DESTDIR_FIXED_gc;

  // Trigger Source is USARTC1 trigger if data buffer is empty
  DMA.CH0.TRIGSRC = DMA_CH_TRIGSRC_USARTC0_DRE_gc;

  //Set number of dmx channels to transfer
  DMA.CH0.TRFCNT = dmxchannels;

  //8Bit source register
  DMA.CH0.SRCADDR0  =(((uint16_t)(&dmxdata))>>0*8)&0xFF;
  DMA.CH0.SRCADDR1  =(((uint16_t)(&dmxdata))>>1*8)&0xFF;
  DMA.CH0.SRCADDR2  = 0;

  //8Bit target register at USARTC1
  DMA.CH0.DESTADDR0 = ((uint16_t) &USARTC0.DATA >>0*8)&0xFF;
  DMA.CH0.DESTADDR1 = ((uint16_t) &USARTC0.DATA >>1*8)&0xFF;
  DMA.CH0.DESTADDR2 = 0;
}

//DMA Start
void start_dmx(void){
  
  //DMX is 250 kBaud 8N2 format 
  //Each package is frames by 1 start bit (0) and 2 stop bits (1)
  //Start Condition is a >88µs break followed by >8 µs mark 
  //Than always transfer a Null package to determine data type for channel transmission
  //To generate Start condition reconfigure baud rate setting to 100 kBaud and send 0x00
  //0x00 is 0000 0000 together with normal start bit = 9 low bits followed by two high bits from stop bits of 8N2 format
  //At 100 kBaud a single bit time is 10µs
  //9 x 10 µs = 90 µs & 2 x 10 µs = 20 µs
  //Calculated register settings for 100 kBaud are BSCALE = 0 & BSEL = 019
  //Calculated register settings for 250 kBaud are BSCALE = 0 & BSEL = 007


    
    //Start DMX protocol with break condition
    if(DMXStatus == BREAK)
    {
      //Wait for TX buffer to be empty
      while (!( USARTC0.STATUS & USART_DREIF_bm));
      {
        //Reconfigure baud rate to 100 kBaud
        USARTC0.BAUDCTRLA = 19;
        USARTC0.BAUDCTRLB =(0 << USART_BSCALE0_bp)|(19 >> 8);
        //Send a Zero to generate Break and Mark 
        USARTC0.DATA = 0x00;
        //Switch to next step in DMX protocol the start byte 0x00
        DMXStatus = STARTBYTE;
      }
    }
    


    //Send information about type of DMX transmission 
    if(DMXStatus == STARTBYTE)
    {
      //Wait for TX buffer to be empty
      while (!( USARTC0.STATUS & USART_DREIF_bm));
      {
        //Reconfigure baud rate to 250 kBaud
        USARTC0.BAUDCTRLA = 007;
        USARTC0.BAUDCTRLB =(0 << USART_BSCALE0_bp)|(007 >> 8);
        //Send a Zero to let DMX receivers know that now channels values will be send
        USARTC0.DATA = 0x00;
        //Switch to next step in DMX protocol and send channel informations
        DMXStatus = DMXDATA;
      }
    }


    //Send DMX channel data
    if(DMXStatus == DMXDATA)
    {
      //Wait for TX buffer to be empty
      while (!( USARTC0.STATUS & USART_DREIF_bm));
      {
        // DMA CH0 activate send rest of DMX stream via DMA access
        DMA.CH0.REPCNT = 0;
        DMA.CH0.CTRLA = DMA_CH_ENABLE_bm |DMA_CH_SINGLE_bm|DMA_CH_BURSTLEN_1BYTE_gc;
        //Go back to start of DMX protocol 
        DMXStatus = BREAK;
      }
    }


}

void usart_init(void){
  
  //configure usart
  // Pin from USARTC0 TxD C3 set to output
  PORTC.DIRSET = PIN3_bm;
  // Pin from USARTC0 TxD C3 to high 
  PORTC.OUTSET = PIN3_bm;
  // Asynchronous Modus 
  USARTC0.CTRLC = (USARTC0.CTRLC & ~USART_CMODE_gm ) | USART_CMODE_ASYNCHRONOUS_gc;
  // No parity 
  USARTC0.CTRLC = (USARTC0.CTRLC & ~USART_PMODE_gm ) | USART_PMODE_DISABLED_gc;
  // 8 data bits
  USARTC0.CTRLC = (USARTC0.CTRLC & ~USART_CHSIZE_gm ) | USART_CHSIZE_8BIT_gc;
  // 2 stop bits
  USARTC0.CTRLC = (USARTC0.CTRLC & ~USART_SBMODE_bm) | (0x01<<3);
  // 100 kBaud
  USARTC0.BAUDCTRLA = 19;
  // 100 kBaud 
  USARTC0.BAUDCTRLB =(0 << USART_BSCALE0_bp)|(19 >> 8);
  // activate USARTC1 
  USARTC0.CTRLB = USART_TXEN_bm;
  //Set DMX Status to Break Condition
  DMXStatus = BREAK;
}

dmx.h

/*
 * dmx.h
 */ 


#ifndef DMX_H_
#define DMX_H_


#define dmxchannels 20

void dma_init(void);
void start_dmx(void);
void usart_init(void);

enum{BREAK, STARTBYTE, DMXDATA};
unsigned char DMXStatus;

#endif /* DMX_H_ */

[Falk B. (falk)]

@ Chris N. (Gast)

>Probleme macht mir die Erzeugung des DMX spezifischen Frame Starts. DMX
>Verlangt ja einen 88µs Break, gefolgt von 8µs Mark vor der eigentlichen
>Datenübertragung. Zur Erzeugung dieser Bedingung wollte ich mit
>verlangsamter Datenrate eine 0x00 senden. Zusammen mit der "Null" vom
>Start Bit und den zwei "Eins" Stop Bits kommt man bei 100 kBaud so auf
>90µs für den Break und 20 µs Mark.
>Leider schaffe ich es nicht die Datenrate zur Laufzeit zu ändern.

Machs nicht zu kompliziert. Erzeuge den BREAK + Pause danach einfach per 
_delay_us() IN der ISR, JA, IN der ISR. Das ist hier schon OK.

>Hilfe. In meinem Programm warte ich darauf, dass das Data Register Empty
>flag gelöscht wird, ehe ich neue Daten in den Sendepuffer stelle.

Falsch. Du musst das TXC Flag prüfen, erst DANN ist das Byte 
vollständiug gesendet.

>UART zur Laufzeit zu änder? Oder geht das beim XMega nicht mehr?

Das glaube ich nicht.

[Chris N. (Gast)]

Hallo Falk,

das mit dem TXC Flag hatte ich auch schon versucht, aber wohl ein großes 
Brett vor dem Kopf gehabt. Ich habe schon im Break geprüft, ob das TXC 
Flag gesetzt ist, kann natürlich nicht, weil ich zuvor ja nie was 
gesendet habe. Also im Break weiterhin auf DREIF prüfen und bei Start 
und Daten dann auf TXC. Schon klappt es auch ganz ohne Interrupts oder 
Timer

/*
dmx.c
Functions to send DMX data via USART 
Uses DMA to minimize system load during transfer of 512 bytes payload 
 */ 


#include "dmx.h"
#include <stdlib.h>
#include <avr/io.h>

//The Buffer from where the DMX Data is read, Filled for test purpose with ABCDEABC...
uint8_t dmxdata[dmxchannels] = {0x41,0x42,0x43,0x44,0x45,0x41,0x42,0x43,0x44,0x45,0x41,0x42,0x43,0x44,0x45,0x41,0x42,0x43,0x44,0x45}; 

//Configure DMA to transfer data from dmx buffer into usart buffer
void dma_init(void){
  
  // activate single buffer, burst size 1Byte
  DMA.CTRL = DMA_CH_ENABLE_bm; 
  
  //Modus transaction, increase and decrease, Burst
  DMA.CH0.ADDRCTRL = DMA_CH_SRCRELOAD_TRANSACTION_gc | DMA_CH_SRCDIR_INC_gc| DMA_CH_DESTRELOAD_NONE_gc | DMA_CH_DESTDIR_FIXED_gc;

  // Trigger Source is USARTC1 trigger if data buffer is empty
  DMA.CH0.TRIGSRC = DMA_CH_TRIGSRC_USARTC0_DRE_gc;

  //Set number of dmx channels to transfer
  DMA.CH0.TRFCNT = dmxchannels;

  //8Bit source register
  DMA.CH0.SRCADDR0  =(((uint16_t)(&dmxdata))>>0*8)&0xFF;
  DMA.CH0.SRCADDR1  =(((uint16_t)(&dmxdata))>>1*8)&0xFF;
  DMA.CH0.SRCADDR2  = 0;

  //8Bit target register at USARTC1
  DMA.CH0.DESTADDR0 = ((uint16_t) &USARTC0.DATA >>0*8)&0xFF;
  DMA.CH0.DESTADDR1 = ((uint16_t) &USARTC0.DATA >>1*8)&0xFF;
  DMA.CH0.DESTADDR2 = 0;
}

//DMA Start
void start_dmx(void){
  
  //DMX is 250 kBaud 8N2 format 
  //Each package is frames by 1 start bit (0) and 2 stop bits (1)
  //Start Condition is a >88µs break followed by >8 µs mark 
  //Than always transfer a Null package to determine data type for channel transmission
  //To generate Start condition reconfigure baud rate setting to 100 kBaud and send 0x00
  //0x00 is 0000 0000 together with normal start bit = 9 low bits followed by two high bits from stop bits of 8N2 format
  //At 100 kBaud a single bit time is 10µs
  //9 x 10 µs = 90 µs & 2 x 10 µs = 20 µs
  //Calculated register settings for 100 kBaud are BSCALE = 0 & BSEL = 019
  //Calculated register settings for 250 kBaud are BSCALE = 0 & BSEL = 007


    
    //Start DMX protocol with break condition
    if(DMXStatus == BREAK)
    {
      //Wait for TX buffer to be empty
      while (!( USARTC0.STATUS & USART_DREIF_bm));
      {
        //Reconfigure baud rate to 100 kBaud
        USARTC0.BAUDCTRLA = 19;
        USARTC0.BAUDCTRLB =(0 << USART_BSCALE0_bp)|(19 >> 8);
        //Send a Zero to generate Break and Mark 
        USARTC0.DATA = 0x00;
        //Switch to next step in DMX protocol the start byte 0x00
        DMXStatus = STARTBYTE;
      }
    }
    


    //Send information about type of DMX transmission 
    if(DMXStatus == STARTBYTE)
    {
      //Wait for TX buffer to be empty
      while (!( USARTC0.STATUS & USART_TXCIF_bm));
      {
        //Reconfigure baud rate to 250 kBaud
        USARTC0.BAUDCTRLA = 07;
        USARTC0.BAUDCTRLB =(0 << USART_BSCALE0_bp)|(07 >> 8);
        //Send a Zero to let DMX receivers know that now channels values will be send
        USARTC0.DATA = 0x00;
        //Switch to next step in DMX protocol and send channel informations
        DMXStatus = DMXDATA;
      }
    }


    //Send DMX channel data
    if(DMXStatus == DMXDATA)
    {
      //Wait for TX buffer to be empty
      while (!( USARTC0.STATUS & USART_TXCIF_bm));
      {
        // DMA CH0 activate send rest of DMX stream via DMA access
        DMA.CH0.REPCNT = 0;
        DMA.CH0.CTRLA = DMA_CH_ENABLE_bm |DMA_CH_SINGLE_bm|DMA_CH_BURSTLEN_1BYTE_gc;
        //Go back to start of DMX protocol 
        DMXStatus = BREAK;
      }
    }


}

void usart_init(void){
  
  //configure usart
  // Pin from USARTC0 TxD C3 set to output
  PORTC.DIRSET = PIN3_bm;
  // Pin from USARTC0 TxD C3 to high 
  PORTC.OUTSET = PIN3_bm;
  // Asynchronous Modus 
  USARTC0.CTRLC = (USARTC0.CTRLC & ~USART_CMODE_gm ) | USART_CMODE_ASYNCHRONOUS_gc;
  // No parity 
  USARTC0.CTRLC = (USARTC0.CTRLC & ~USART_PMODE_gm ) | USART_PMODE_DISABLED_gc;
  // 8 data bits
  USARTC0.CTRLC = (USARTC0.CTRLC & ~USART_CHSIZE_gm ) | USART_CHSIZE_8BIT_gc;
  // 2 stop bits
  USARTC0.CTRLC = (USARTC0.CTRLC & ~USART_SBMODE_bm) | (0x01<<3);
  // 100 kBaud
  USARTC0.BAUDCTRLA = 19;
  // 100 kBaud 
  USARTC0.BAUDCTRLB =(0 << USART_BSCALE0_bp)|(19 >> 8);
  // activate USARTC1 
  USARTC0.CTRLB = USART_TXEN_bm;
  //Set DMX Status to Break Condition
  DMXStatus = BREAK;
}

Somit haben wir hier ein einfaches Grundgerüst für das Senden von DMX 
via UART mit DMA auf einem XMega.

[Chris N. (Gast)]

Mist zu früh gefreut, klappt nur beim ersten mal. Danach stimmt am 
Anfang wieder die Datenrate nicht argh

[Chris N. (Gast)]

Ok,

ich kommme nicht dahinter was der UART in meiner Software treibt.

Die erste Übertragung von DMX Daten funktioniert wie gewünscht. Bei der 
zweiten stimmt das Timing nicht. Ich habe das Programm jetzt so 
umgebaut, dass ich sicherstelle, dass die DMA Übertragung abgeschlossen 
ist, der UART die Daten auch wirklich auf den PIN ausgegeben hat und ich 
deaktiviere sogar den UART vor dem Umkonfigurieren auf die langsame 
Baudrate wieder. Dennoch ist im zweiten DMX durchgang immer der Wurm 
drin. Zur besseren Übersichtlichkeit der Daten habe ich das erste Null 
Bit mal auf CC gesetzt. Lasse ich nun die Break Erzeugung auf 00 stehen 
kommen alle Daten mit 250 kBaud raus, auch das Break.
Änder ich die Break Erzeugung einfach mal auf zum Beispiel 0x46 passt 
gleich die ganze Datenübertragung nicht mehr.

Noch jemand eine Idee was mit dem UART nicht stimmt?

/*
dmx.c
Functions to send DMX data via USART 
Uses DMA to minimize system load during transfer of 512 bytes payload 
 */ 


#include "dmx.h"
#include <stdlib.h>
#include <avr/io.h>

//The Buffer from where the DMX Data is read, Filled for test purpose with ABCDEABC...
uint8_t dmxdata[dmxchannels] = {0x41,0x42,0x43,0x44,0x45,0x41,0x42,0x43,0x44,0x45,0x41,0x42,0x43,0x44,0x45,0x41,0x42,0x43,0x44,0x45}; 

//Configure DMA to transfer data from dmx buffer into usart buffer
void dma_init(void){
  
  // activate single buffer, burst size 1Byte
  DMA.CTRL = DMA_CH_ENABLE_bm; 
  
  //Modus transaction, increase and decrease, Burst
  DMA.CH0.ADDRCTRL = DMA_CH_SRCRELOAD_TRANSACTION_gc | DMA_CH_SRCDIR_INC_gc| DMA_CH_DESTRELOAD_NONE_gc | DMA_CH_DESTDIR_FIXED_gc;

  // Trigger Source is USARTC1 trigger if data buffer is empty
  DMA.CH0.TRIGSRC = DMA_CH_TRIGSRC_USARTC0_DRE_gc;

  //Set number of dmx channels to transfer
  DMA.CH0.TRFCNT = dmxchannels;

  //8Bit source register
  DMA.CH0.SRCADDR0  =(((uint16_t)(&dmxdata))>>0*8)&0xFF;
  DMA.CH0.SRCADDR1  =(((uint16_t)(&dmxdata))>>1*8)&0xFF;
  DMA.CH0.SRCADDR2  = 0;

  //8Bit target register at USARTC1
  DMA.CH0.DESTADDR0 = ((uint16_t) &USARTC0.DATA >>0*8)&0xFF;
  DMA.CH0.DESTADDR1 = ((uint16_t) &USARTC0.DATA >>1*8)&0xFF;
  DMA.CH0.DESTADDR2 = 0;
}

//DMA Start
void start_dmx(void){
  
  //DMX is 250 kBaud 8N2 format 
  //Each package is frames by 1 start bit (0) and 2 stop bits (1)
  //Start Condition is a >88µs break followed by >8 µs mark 
  //Than always transfer a Null package to determine data type for channel transmission
  //To generate Start condition reconfigure baud rate setting to 100 kBaud and send 0x00
  //0x00 is 0000 0000 together with normal start bit = 9 low bits followed by two high bits from stop bits of 8N2 format
  //At 100 kBaud a single bit time is 10µs
  //9 x 10 µs = 90 µs & 2 x 10 µs = 20 µs
  //Calculated register settings for 100 kBaud are BSCALE = 0 & BSEL = 019
  //Calculated register settings for 250 kBaud are BSCALE = 0 & BSEL = 007


    
    //Start DMX protocol with break condition
    if(DMXStatus == BREAK || FIRSTBREAK)
    {

      
      //Wait for TX buffer to be empty
      if(DMXStatus==FIRSTBREAK)
      {
        //Send a Zero to generate Break and Mark
        USARTC0.DATA = 0x00;
        //Switch to next step in DMX protocol the start byte 0x00
        DMXStatus = STARTBYTE;
      }
      else
      {
        //Check is DMA transaction is running in background
        while (!(DMA.INTFLAGS & DMA_CH0TRNIF_bm) || (DMA.CH0.CTRLB & (DMA_CH_CHBUSY_bm | DMA_CH_CHPEND_bm)));
        DMA.INTFLAGS |= DMA_CH0TRNIF_bm;
  
        //Deactivate DMA
        DMA.CH0.CTRLA &= ~DMA_CH_ENABLE_bm;
        
        //Check for UART Data has been physical shifted out
        while (!( USARTC0.STATUS & USART_TXCIF_bm));
        
        //Deactivate USART
        USARTC0.CTRLB = 0x00;
        
      
  //configure usart
  // Pin from USARTC0 TxD C3 set to output
  PORTC.DIRSET = PIN3_bm;
  // Pin from USARTC0 TxD C3 to high 
  PORTC.OUTSET = PIN3_bm;
  // Asynchronous Modus 
  USARTC0.CTRLC = (USARTC0.CTRLC & ~USART_CMODE_gm ) | USART_CMODE_ASYNCHRONOUS_gc;
  // No parity 
  USARTC0.CTRLC = (USARTC0.CTRLC & ~USART_PMODE_gm ) | USART_PMODE_DISABLED_gc;
  // 8 data bits
  USARTC0.CTRLC = (USARTC0.CTRLC & ~USART_CHSIZE_gm ) | USART_CHSIZE_8BIT_gc;
  // 2 stop bits
  USARTC0.CTRLC = (USARTC0.CTRLC & ~USART_SBMODE_bm) | (0x01<<3);
  // 100 kBaud
  USARTC0.BAUDCTRLA = 19;
  // 100 kBaud 
  USARTC0.BAUDCTRLB =(0 << USART_BSCALE0_bp)|(19 >> 8);
  // activate USARTC1 
  USARTC0.CTRLB = USART_TXEN_bm;
  //Set DMX Status to Break Condition
      
        //Send a Zero to generate Break and Mark
        USARTC0.DATA = 0x00;
        //Switch to next step in DMX protocol the start byte 0x00
        DMXStatus = STARTBYTE;
      }
    }
    


    //Send information about type of DMX transmission 
    if(DMXStatus == STARTBYTE)
    {
      //Check for UART Data has been physical shifted out
      while (!( USARTC0.STATUS & USART_TXCIF_bm));

        //Reconfigure baud rate to 250 kBaud
        USARTC0.BAUDCTRLA = 07;
        USARTC0.BAUDCTRLB =(0 << USART_BSCALE0_bp)|(07 >> 8);
        //Send a Zero to let DMX receivers know that now channels values will be send
        USARTC0.DATA = 0xCC;
        //Switch to next step in DMX protocol and send channel informations
        DMXStatus = DMXDATA;

    }


    //Send DMX channel data
    if(DMXStatus == DMXDATA)
    {
      //Check for UART Data has been physical shifted out
      while (!( USARTC0.STATUS & USART_TXCIF_bm));

        // DMA CH0 activate send rest of DMX stream via DMA access
        DMA.CH0.REPCNT = 0;
        DMA.CH0.CTRLA = DMA_CH_ENABLE_bm |DMA_CH_SINGLE_bm|DMA_CH_BURSTLEN_1BYTE_gc;
        //Go back to start of DMX protocol 
        DMXStatus = BREAK;
    }


}

void usart_init(void){
  
  //configure usart
  // Pin from USARTC0 TxD C3 set to output
  PORTC.DIRSET = PIN3_bm;
  // Pin from USARTC0 TxD C3 to high 
  PORTC.OUTSET = PIN3_bm;
  // Asynchronous Modus 
  USARTC0.CTRLC = (USARTC0.CTRLC & ~USART_CMODE_gm ) | USART_CMODE_ASYNCHRONOUS_gc;
  // No parity 
  USARTC0.CTRLC = (USARTC0.CTRLC & ~USART_PMODE_gm ) | USART_PMODE_DISABLED_gc;
  // 8 data bits
  USARTC0.CTRLC = (USARTC0.CTRLC & ~USART_CHSIZE_gm ) | USART_CHSIZE_8BIT_gc;
  // 2 stop bits
  USARTC0.CTRLC = (USARTC0.CTRLC & ~USART_SBMODE_bm) | (0x01<<3);
  // 100 kBaud
  USARTC0.BAUDCTRLA = 19;
  // 100 kBaud 
  USARTC0.BAUDCTRLB =(0 << USART_BSCALE0_bp)|(19 >> 8);
  // activate USARTC1 
  USARTC0.CTRLB = USART_TXEN_bm;
  //Set DMX Status to Break Condition
  DMXStatus = FIRSTBREAK;
}

[Falk B. (falk)]

//Reconfigure baud rate to 250 kBaud
        USARTC0.BAUDCTRLA = 07;
        USARTC0.BAUDCTRLB =(0 << USART_BSCALE0_bp)|(07 >> 8);

Schau mal in XMEGA Manual unter

BAUDCTRLB – Baud Rate register B

Writing BAUDCTRLA will trigger an immediate update of the baud rate 
prescaler.

Ich glaube, du solltest erst CTRLB und danach CTRLA beschreiben.

[tim (Gast)]

//Check for UART Data has been physical shifted out
      while (!( USARTC0.STATUS & USART_TXCIF_bm));

ist ja schön und gut. Aber wo setzt du das flag zurück?
Einen IRQ scheinst du ja nicht konfiguriert zu haben.
Und so wie ich das lese:

This flag is set when the entire frame in the transmit shift register has been shifted out and there are no new data in the
transmit buffer (DATA). TXCIF is automatically cleared when the transmit complete interrupt vector is executed. The flag
can also be cleared by writing a one to its bit location.

geht das nicht von selbst wieder auf 0.

BTW: wo ist das Problem mit 31K Interrupts / Sec?
Da bleiben doch ewig lange 1024 Ticks zwischen 2 Bytes...