ATXmega Erfahrungen

Erfahrungen und Tipps zum ATXmega

english page is missing - you can help the project with a translation!

Im Folgenden gebe ich ein paar Erfahrungen wieder, die ich bei meinen Entwicklungen mit dem xmega gemacht habe.

Analogsystem

Einstellungen:
2 MHz Samplerate
Single Measurement, Signed Mode, Resolution 12 Bit
interne Bandgap Referenz mit 1V, Gain 1
Chip mit Längsregler 3V3 versorgt
Einspeisung der Meßspannung aus (längsgeregeltem) Labornetzteil via 1k
Kontrolle der Spannung mit 4-1/2 stelligem DVM.
Ergebnisse:
Rauschen: so ca. 4 Digit, d.h. 2mV.
Meßbereich: 0 .. 1V, danach geht der Wandler bei Code 2047 sauber in die Sättigung;
DC-Offset ca. 3mV, Nichtlinearität ca. 3mV.
Negative Spannungen: linearer Meßbereich: 0 .. -340mV, dannach wird der Wandler nichtlinear und sättigt etwa bei -400mV

Bootloader, Flash schreiben

Achtung: für Pagegrößen < 512 (also z.B. atxmega128A4) ist ein Bug in diesen Routinen, in SP_ReadFlashPage muß die Zeile

        ldi        r21, ((FLASH_PAGE_SIZE)&0xFF)   ; Load R21 with byte count.

durch

        ldi        r21, ((FLASH_PAGE_SIZE/2)&0xFF)   ; Load R21 with word(!) count.

ersetzt werden. Falls die Orginalversion verwendet wird, überschreibt die Routine benachbarten RAM-Speicher und der Programmcode stürzt ab. Stand 04/2014 ist dieser Fehler noch immer in den Appnotes enthalten.

.section .BOOT

-Wl,-section-start=.BOOT=0x21fc0

-avr-objcopy

-R .BOOT

// Code zum Abpruefen des Bootloaders
//
// hier zuerst der Code aus Hexfile, als Referenz zum Vergleich (512 byte / block)
#if (SPM_PAGESIZE == 256)
const unsigned char sp_code_from_hex[] PROGMEM =
  {
    0xEE, 0x27, 0xFF, 0x27, 0x19, 0xBE, 0xDC, 0x01, 0x43, 0xE2, 0x40, 0x93, 0xCA, 0x01, 0x50, 0xE8,
    0x2D, 0xE9, 0x0D, 0x90, 0x1D, 0x90, 0x20, 0x93, 0x34, 0x00, 0xE8, 0x95, 0x32, 0x96, 0x5A, 0x95,
    0xC1, 0xF7, 0x11, 0x24, 0x08, 0x95, 0xFC, 0x01, 0x40, 0x93, 0xCA, 0x01, 0x2D, 0xE9, 0x20, 0x93,
    0x34, 0x00, 0xE8, 0x95, 0x11, 0x24, 0x3B, 0xBF, 0x08, 0x95
  };
#elif (SPM_PAGESIZE == 512)
const unsigned char sp_code_from_hex[] PROGMEM =
  {
    0xEE, 0x27, 0xFF, 0x27, 0x19, 0xBE, 0xDC, 0x01, 0x43, 0xE2, 0x40, 0x93, 0xCA, 0x01, 0x50, 0xE0,
    0x2D, 0xE9, 0x0D, 0x90, 0x1D, 0x90, 0x20, 0x93, 0x34, 0x00, 0xE8, 0x95, 0x32, 0x96, 0x5A, 0x95,
    0xC1, 0xF7, 0x11, 0x24, 0x08, 0x95, 0xFC, 0x01, 0x40, 0x93, 0xCA, 0x01, 0x2D, 0xE9, 0x20, 0x93,
    0x34, 0x00, 0xE8, 0x95, 0x11, 0x24, 0x3B, 0xBF, 0x08, 0x95,
  };
#else
    #warning info: SPM_PAGESIZE = void
#endif


static unsigned char spm_is_available(void)
  {
    uint8_t i;
    uint32_t spm_code_addr = 0x10FE0L * 2;   // word-addr -> byte-addr
    const uint8_t *ref = sp_code_from_hex;

    for (i=0; i < sizeof(sp_code_from_hex); i++)
      {
        if (pgm_read_byte(ref++) != pgm_read_byte_far(spm_code_addr++))
          {
            led_fire();led_fire();led_fire();led_fire();led_fire();
            led_fire();led_fire();led_fire();led_fire();led_fire();
            return(0);
          }
      }
    return(1);
  }

Besondere Optimierungen

Timer

Wenn ein Waveform Generation Mode gewählt ist, kann man trotzdem noch auf die Pins zugreifen - nützlich z.B. einer H-Brücke, welche in der Richtung umgesteuert wird oder kurz aus dem PWM raus soll (z.B. für die Cutout von DCC BiDi).
Es gibt ein extra Register, um Timer-Ereignisse auszulösen. Man kann über dieses Register den Timer neu starten, einen Update provozieren (also z.B. mehrere Compareregister parallel umladen).

Xmega und DCC

DCC Dekodieren

Der DCC Eingang wird so programmiert, daß er auf Flanke (steigend oder fallend) reagiert. Diese Ereignis wird dann auf die Event-Leitung gelegt.
Ein Timer wird freilaufend programmiert, ein Ausgangs-Compare auf die Zeitspanne von 87µs (=DCC Period_1 * 0,75= programmiert. In Event-Aktions-Register des Timer wird nun 'RESTART' auf das obige Event eingetragen.
Dadurch wird beim Flankenwechsel des DCC-Signals der Timer zurückgesetzt, und exakt nach 87µs erfolgt das Auslösen des Compares.
Nun kann man da entweder eine Interruptroutine anhängen und den Port einlesen oder wiederum ein Event auslösen, welches dann den DMA-Controller veranlaßt, den Port einzulesen und im Speicher abzulegen.

DCC erzeugen

      static void init_timer_d0(void)
        {
          TCD0.CNT = 0;
          TCD0.PER = 0;
          TCD0.CCA = TIME_DCC_HALF1;
          TCD0.CTRLE = (1 << TC0_BYTEM_bp);       // Byte mode: 1 run as 8-bit counter
          TCD0.CTRLA = ( TCD0.CTRLA & ~TC0_CLKSEL_gm ) | TC_CLKSEL_DIV64_gc;
          TCD0.CTRLB = (0 << TC0_CCDEN_bp)
                     | (0 << TC0_CCCEN_bp)
                     | (0 << TC0_CCBEN_bp)
                     | (1 << TC0_CCAEN_bp)        // enable A (dcc)
                     | TC_WGMODE_FRQ_gc;
          TCD0.INTCTRLA = ( TCD0.INTCTRLA & ~TC0_OVFINTLVL_gm ) | TC_OVFINTLVL_OFF_gc;
        }

     static void init_dma(void)
        {
          DMA.CTRL = (1 << DMA_ENABLE_bp)
                   | (0 << DMA_RESET_bp)
                   | DMA_PRIMODE_CH0123_gc
                   | DMA_DBUFMODE_CH23_gc;
          DMA.CH2.REPCNT = 0;                        // run forever

          DMA.CH2.CTRLA = (0 << DMA_CH_ENABLE_bp)    //  Channel Enable
                        | (0 << DMA_CH_RESET_bp)   // Channel Software Reset
                        | (1 << DMA_CH_REPEAT_bp)   // Channel Repeat Mode bit position.
                        | (0 << DMA_CH_TRFREQ_bp)   // Channel Transfer Request bit position.
                        | (1 << DMA_CH_SINGLE_bp)   // Channel Single Shot Data Transfer bit position.
                        | DMA_CH_BURSTLEN_1BYTE_gc;
          DMA.CH2.CTRLB = DMA_CH_ERRINTLVL_OFF_gc
                        | DMA_CH_TRNINTLVL_LO_gc;  // transaction complete

          DMA.CH2.ADDRCTRL = DMA_CH_SRCRELOAD_BLOCK_gc  // Source address reload mode : _NONE, BLOCK, BURST, TRANSACTION
                           | DMA_CH_SRCDIR_INC_gc       // Source addressing mode: FIXED, INC, DEC
                           | DMA_CH_DESTRELOAD_NONE_gc  // Destination adress reload mode: NONE, BLOCK, BURST, TRANSACTION
                           | DMA_CH_DESTDIR_FIXED_gc;   // Destination adressing mode: FIXED, INC, DEC

          DMA.CH2.TRIGSRC = DMA_CH_TRIGSRC_TCD0_CCA_gc;   // Counter D, comp. A

          src.as_uint32 = dcc_buffer_0;
          DMA.CH2.SRCADDR0 = src.low8;
          DMA.CH2.SRCADDR1 = src.high8;
          DMA.CH2.SRCADDR2 = src.upper8;

          dest.as_uint32 = &TCD0.CCAL;
          DMA.CH2.DESTADDR0 = dest.low8;
          DMA.CH2.DESTADDR1 = dest.high8;
          DMA.CH2.DESTADDR2 = dest.upper8;

          DMA.CH3.REPCNT = 0;

          DMA.CH3.CTRLA = (0 << DMA_CH_ENABLE_bp)    //  Channel Enable
                        | (0 << DMA_CH_RESET_bp)     // Channel Software Reset
                        | (1 << DMA_CH_REPEAT_bp)   // Channel Repeat Mode bit position.
                        | (0 << DMA_CH_TRFREQ_bp)   // Channel Transfer Request bit position.
                        | (1 << DMA_CH_SINGLE_bp)   // Channel Single Shot Data Transfer bit position.
                        | DMA_CH_BURSTLEN_1BYTE_gc;
          DMA.CH3.CTRLB = DMA_CH_ERRINTLVL_OFF_gc
                        | DMA_CH_TRNINTLVL_LO_gc;  // transaction complete

          DMA.CH3.ADDRCTRL = DMA_CH_SRCRELOAD_BLOCK_gc  // Source address reload mode : _NONE, BLOCK, BURST, TRANSACTION
                           | DMA_CH_SRCDIR_INC_gc       // Source addressing mode: FIXED, INC, DEC
                           | DMA_CH_DESTRELOAD_NONE_gc  // Destination adress reload mode: NONE, BLOCK, BURST, TRANSACTION
                           | DMA_CH_DESTDIR_FIXED_gc;   // Destination adressing mode: FIXED, INC, DEC

          DMA.CH3.TRIGSRC = DMA_CH_TRIGSRC_TCD0_CCA_gc;   // Counter D, comp. A

          src.as_uint32 = dcc_buffer_1;
          DMA.CH3.SRCADDR0 = src.low8;
          DMA.CH3.SRCADDR1 = src.high8;
          DMA.CH3.SRCADDR2 = src.upper8;

          dest.as_uint32 = &TCD0.CCAL;
          DMA.CH3.DESTADDR0 = dest.low8;
          DMA.CH3.DESTADDR1 = dest.high8;
          DMA.CH3.DESTADDR2 = dest.upper8;

          dma_active_channel = 2;

          // and fire the DMA (we start with channel 2)

          DMA.CH2.CTRLA = (1 << DMA_CH_ENABLE_bp)     //  Channel Enable
                        | (0 << DMA_CH_RESET_bp)      // Channel Software Reset
                        | (1 << DMA_CH_REPEAT_bp)     // Channel Repeat Mode
                        | (0 << DMA_CH_TRFREQ_bp)     // Channel Transfer Request
                        | (1 << DMA_CH_SINGLE_bp)     // Channel Single Shot Data Transfer
                        | DMA_CH_BURSTLEN_1BYTE_gc;
        }

      ISR(DMA_CH2_vect)
        {
          DMA.INTFLAGS = DMA_CH2ERRIF_bm  | DMA_CH2TRNIF_bm;

          dma_active_channel = 3;
          actual_index++;
          actual_index &= 0x3;  // modulo 4
          isr_set_task_ready(TASK_DCC_GEN);
        }

      ISR(DMA_CH3_vect)
        {
          DMA.INTFLAGS = DMA_CH3ERRIF_bm  | DMA_CH3TRNIF_bm;

          dma_active_channel = 2;
          actual_index++;
          actual_index &= 0x3;  // modulo 4
          isr_set_task_ready(TASK_DCC_GEN);
        }

   #define WRITE_1 {*dcc_buffer++ = TIME_DCC_HALF1;*dcc_buffer++ = TIME_DCC_HALF1;}
   #define WRITE_0 {*dcc_buffer++ = TIME_DCC_HALF0;*dcc_buffer++ = TIME_DCC_HALF0;}

   static void prepare_dma_buffer(t_dcc_message* dcc_message)
     {
       uint16_t size; uint8_t* dcc_buffer;
       uint8_t i,prebits; uint8_t my_xor = 0; // dcc checksum

       if (dma_active_channel == 2) dcc_buffer = dcc_buffer_1;
       else dcc_buffer = dcc_buffer_0;

       // ----- now fill this buffer with timing data

       if (dcc_message->type == is_prog) prebits = MAX_PREAMBLE_BITS;
       else prebits = NORMAL_PREAMBLE_BITS;

       for (i=0; i<prebits; i++)  {  WRITE_1; }                // preamble
       WRITE_0;                                                    // dcc starts
       for (i=0; i<dcc_message->size; i++)
         {
           uint8_t current_byte = dcc_message->dcc[i];
           my_xor ^= current_byte;
           for (uint8_t mask=0x80; mask; mask >>= 1)  // msb first
             {
               if (current_byte & mask) { WRITE_1; }
               else  { WRITE_0; }
             }
           WRITE_0;                                                // byte delimiter
         }
       for (uint8_t mask=0x80; mask; mask >>= 1)
         {
           if (my_xor & mask) { WRITE_1; }
           else  { WRITE_0; }
         }
       WRITE_1;                                                    // packet end bit

       if (dma_active_channel == 2)                              // ---- load to isr / dma
         {
           size = dcc_buffer - dcc_buffer_1;
           DMA.CH3.TRFCNT = size;
         }

       else
         {
           size = dcc_buffer - dcc_buffer_0;
           DMA.CH2.TRFCNT = size;
         }
     }

Xmega und DMX erzeugen

Framebeginn: es wird ein Break (d.h. TX=Low) für die Dauer von mind. 88us gesendet.
Es folgt ein Mark after Break (d.h. TX=High) für die Dauer von mind. 8us.
Startbyte, für normale Datenübertragung wird 0x00 gesendet.
Schleife über alle DMX Byte, wobei jedes Byte exakt einem Kanal zugewiesen ist: erstes Byte - erster Kanal, zweites Byte - zweiter Kanal, usw. Die Daten sind nicht weiter kodiert oder gesichert, es können max. 512 Byte übertragen werden.

Trick

DMX Ausgeben
Start:	UART auf 57600 einstellen. UART.DATA mit 0xC0 beschreiben. TXC-Interrupt freigeben (TX-complete)
ISR(TXC):	UART auf 250000 einstellen. Schleifenzähler = 0. UART.DATA mit 0x00 beschreiben. TXC-Interrupt sperren, DRE-Interrupt freigeben (Data Register Empty)
ISR(DRE):	UART.DATA mit dmx[Schleifenzähler] beschreiben. Schleifenzähler inkrementieren. Wenn Ende erreicht: DRE-Interrupt sperren

OneDMX-Projekt

Speichern von Daten im Flash bei atxmega

-R .boot

CRC-Schutz von Firmwarepaketen

An einer wohldefinierten Stelle im Flash wird die Länge der Firmware hinterlegt. Wohldefinierte Stellen sind leider nicht so leicht verfügbar: unten liegen die Vektoren, danach der Code; der Rest vom Flash könnte Daten enthalten. In der Bootarea wäre eine Möglichkeit, allerdings ist dann die Länge immer ein extra Anhängsel an das Hexfile - und Beschreiben der Bootarea aus dem Bootloader heraus auch nicht kugelsicher. Als Ort für die Länge verwende ich den Interruptvektor für 'Ausfall externer Oszillator' (OSC_XOSCF_vect), dieser liegt bei 0x0004 bis 0x0007 und damit zumindest an einer eindeutigen Stelle innerhalb der Firmware. Klar, diesen Interrupt darf man dann nie mehr verwenden.
Um die Länge dort abzulegen, benutze ich srec_cat. Srec_cat ein sehr universelles Tool, um Manipulationen an Hex-Dateien vorzunehmen:
- Im ersten Schritt liest man das hex-file ein, nimmt dabei aber den Bereich von 0x0004 bis 0x0008 aus. (Parameter: -exclude 0x0004 0x0008)
- Dann holt man sich die Länge im Format Little-Endian und deponiert das an der Stelle 0x0004: (Parameter: -MAximum_Little_Endian 0x0004 -fill 0x00 -over \( file.hex -I \)
Jetzt liegt also eine gepatchte Hexdatei mit der Länge (in Bytes) statt des Interruptverktors vor.
Im nächsten Schritt wird nun an diese Datei eine CRC angehängt.
Da der Bootloader auf maximale Record-Längen von 16 Byte je Zeile beschränkt ist, muß srec_cat anweisen, nur kurze Zeilen zu erzeugen: Parameter -Output_Block_Size=16

Erzeugen von Ansteuersignalen für WS2812-LEDs

Beitrag

Lösung mit Timer und DMA

Aufsetzen eines Timers mit Periodendauer = 1,25µs und Verwenden eines Comparekanals zur Implementierung der Kodierung.
Nachladen des Comparewertes für jedes Bit mittels DMA-Controller. Der DMA-Controller schiebt den Comparewert mittels Cycle-Stealing direkt vom Speicher ins Register und verursacht dadurch nur geringe Beeinflussung der CPU.
Nach Übertragen eines kompletten Ausgabestromes Einfügen einer Pause und Neuaufsetzen des DMA-Kanals.

Achtung!

Besonderheiten der Xmega E-Serie

NVM-Controller, EEPROM Zugriff

Bei der Portierung bin über fehlendes NVM_CMD_READ_EEPROM 0x06 und NVM_CMD_LOAD_EEPROM_BUFFER 0x33 im header gestolpert. Blick ins Datenblatt: jo, ist so, gibt es nicht mehr. Neu: EEPROM Lesen geht jetzt über direkte oder indirekte Loadbefehle, dazu wird das EEPROM hinter dem normalen SRAM eingeblendet. Offset: MAPPED_EEPROM_START (= 0x1000); das ist eine Vereinfachung. EEPROM Schreiben geht jetzt ein Stück komplizierter: Es gibt einen vorgelagerten Pagebuffer (dessen Partitionierung man anhand E2PAGE und E2BYTE ermitteln muß), diesen muß man zu Fuß aus dem EEPROM befüllen (der NVM tut es nicht mehr, NVM_CMD_LOAD_EEPROM_BUFFER gibt es ja nicht mehr), dann kann man EEPROM erasen und neu schreiben. Oder: da das Schreiben ein Nullsetzen ist, einfach vorher flush und nur das Byte schreiben.

UART

#if defined(__AVR_ATxmega8E5__) || defined(__AVR_ATxmega16E5__) || defined(__AVR_ATxmega32E5__)
    #if (MY_UART_CHAN == 0)
        #define MY_USART0_REMAP   0
    #else
        #undef MY_UART_CHAN
        #define MY_UART_CHAN      0         // take ISR from chan0
        #define MY_USART0_REMAP   1         // but introduce a remap flag
    #endif
#else
    #define MY_USART0_REMAP   0
#endif

    #if (MY_UART_CHAN == 1)
        MY_PORT.DIRSET   = PIN7_bm;       // pin 7 (TXD1) as output
        MY_PORT.DIRCLR   = PIN6_bm;       // pin 6 (RXD1) as input
    #else
        #if (MY_USART0_REMAP == 1)
            MY_PORT.DIRSET   = PIN7_bm;       // pin 7 (TXD1) as output
            MY_PORT.DIRCLR   = PIN6_bm;       // pin 6 (RXD1) as input
            MY_PORT.REMAP |= PORT_USART0_bm;
        #else
            MY_PORT.DIRSET   = PIN3_bm;       // pin 3 (TXD0) as output
            MY_PORT.DIRCLR   = PIN2_bm;       // pin 2 (RXD0) as input
        #endif

Ports

Die Option PORT_SRLEN je Port ist entfallen, das entsprechende Bit ist mit 0 zu initialisieren. Dafür gibt es jetzt ein neues Register SRLCTRL, welches Slewrate-Control für den ganzen Port einstellt. Was genau da dann die Rise/Falltime mit und ohne Control ist, da schweigt das Datenblatt bzw. verweist auf das 'device' Datenblatt - wo dann auch nichts steht.
Es gibt nur noch einen Interrupt je PORT, aus PORT_INT0LVL_HI_gc wird PORT_INTLVL_HI_gc, gleiches natürlich auch bei INT0MASK. INTMASK
Neu ist das REMAP: man kann Funktionen aus dem unteren Nibble nach oben verschieben. Hilft beim Layout einer Schaltung.

GPIO

Es gibt nur 4 GPIOR Register: GPIOR0...GPIOR3

Timer

Bootloader in kleinen Chips

'da bau ich Dir locker einen XY-Bootloader rein'

Es werden drei Bereiche definiert:
- .text: das kommt nach 0x6000 bis 0x7FFF (belegt also die oberen 8k des Appflash). Dort soll der normale Code rein.
- .boot_int_vectors: das kommt nach 0x8000 bis 0x81FF (belegt also den Beginn des Bootbereiches). Dort kommt das Trampolin rein.
- .boot_rw: das kommt nach 0x8fc0: dort ist der Code für read/write aufs Flash drin.

Inhalt Trampolin

#define START_OF_BOOT_LOADER   0x06000
void boot_vector_jumptable(void) \
     __attribute__((naked)) \
     __attribute__((section(".boot_int_vectors")));
void boot_vector_jumptable(void)
{
   //Adjust to the number of interrupts for your device / and destination
   __asm__ __volatile__ ( \
      "jmp 0x06000+0x000  \n\t" \
      "jmp 0x06000+0x004  \n\t" \
      "jmp 0x06000+0x008  \n\t" \
      ....
      "jmp 0x06000+0x1F4  \n\t" \
      "jmp 0x06000+0x1F8  \n\t" \
      "jmp 0x06000+0x1FC  \n\t" \
      ::                \
   );
}

Linkerspruch

LDFLAGS += -Wl,-section-start=.boot_int_vectors=0x8000
LDFLAGS += -Wl,-section-start=.boot_rw=0x8fc0
LDFLAGS += -Wl,-section-start=.text=0x6000

OpenDCC

Erfahrungen und Tipps zum ATXmega

Analogsystem

Bootloader, Flash schreiben

Besondere Optimierungen

Timer

Xmega und DCC

DCC Dekodieren

DCC erzeugen

Xmega und DMX erzeugen

Speichern von Daten im Flash bei atxmega

CRC-Schutz von Firmwarepaketen

Erzeugen von Ansteuersignalen für WS2812-LEDs

Besonderheiten der Xmega E-Serie

NVM-Controller, EEPROM Zugriff

UART

Ports

GPIO

Timer

Bootloader in kleinen Chips

Inhalt Trampolin

Linkerspruch