SAMD21 Probleme mit den Timern (Interrupt)

[Horst W. (wassolldas)]

Hallo Freunde der Microcontroller,

ich bin gerade an einem Projekt in welchem ich einen SAMD21 einsetze.
In diesem Projekt benötige ich einen Timerinterrupt der einen Interrupt 
im Takt von 160KHz auslöst. (Zweck Gepollte Manchesterdecodierung)
Alles im Grunde kein Problem mit einem Arduino MoPro und Arduino 
Umgebung flux ausprobiert..läuft.
Dann ein eigenes Board erstellen lassen auf dem der SAM mit dem internen 
Clock laufen soll.

Diesen habe ich dann ohne die Arduino Bibliotheken mit Atmel Studio 
programmiert. Der Timer läuft auch im Interrupt nur ich erreiche die 
160kHz nicht mehr, es gibt eine Schwelle die ich nicht überschreiten 
kann. (unter dieser Schwellenfrequenz entspricht alles den Erwartungen)
Der Prescaler läuft auf 1 und auch der Compare Wert wird ins Compare 
Register übernommen. Nur wird der Interrupt mit einer niedriegeren Rate 
aufgerufen als es nach dem Compare Register sein müßte. Stelle ich den 
Prescaler auf 1/2 so gibt es auch hier eine Schwelle welche ich nicht 
überschreiten kann obwohl auch hier das Compare Register den richtigen 
Wert bekommt. Dasselbe mit Prescaler 1/4.

Der einzige Unterschied zum MoPro ist ja der interne Takt.

Hat irgendjemand eine Idee was das sein kann. Gibt es einen Errata 
Eintrag den ich nicht gefunden habe?

[Stromverdichter (Gast)]

Wie hoch ist denn nun dein Takt? 8Mhz?
Wie hoch war dein Takt? 48Mhz?
Welche Taktquelle verwendest du?
Ohne Sourcecode ist das jedoch wieder mal Rätselraten.
Hast du gar noch den Timer-Interrupt mit übermäßig viel Code 
vollgepackt?
Etwa auch Delays?
Ich hol mir die nächste Glaskugel, die hier ist kaputt :-(

[Horst W. (wassolldas)]

Mein Prozessortakt ist 48MHz.
Ich habe aber auch Spaßeshalber den Takt mal auf 1MHz runtergesetzt. Das 
selbe Phänomen. Nur mit eben 1/48 Frequenz. (Taktquelle interne 32kHz)

Nein nein, in meinem Interrupt wird im Moment nur ein Port getoggelt. 
Wie gesagt auf dem MoPro mit Arduino Bibliothek gehts ja. Dieselbe 
Bibliothek habe ich auch schon ohne den ganzen Arduino Plunder in meinen 
Source Code eingebaut. Funzt auch nur eben bis zu dieser Grenze.
Source Code habe ich hier auf dem Rechner nicht, den kann ich erst 
morgen einstellen.
Ich hatte eben die Hoffung, dass jemand so etwas ähnliches schon hatte.

Eventuell muss man etwas Besonderes bei dem internen Takt beachten?

Kann es eventuell sein dass der Interruptcontroller, zu langsam läuft 
und so die auflaufenden Interrupt ab einer gewissen Frequenz nicht mehr 
mitbekommt?

[Marco H. (damarco)]

Trotzdem könnte die Taktquelle die Ursache sein. Ohne Code kann man nur 
raten... Schau mal in Datenblatt -> Clock

[Horst W. (wassolldas)]

Danke für die Antwort.

Du weißt gar nicht wie oft ich den Abschnitt Clock und Timer im 
Datenblatt schon gelesen habe.
Ich stell Morgen mal ein wie ich den internen Takt und die Timer 
konfiguriert habe. Irgendwo wird wahrscheinlich der Fehler liegen. Nur 
im Moment habe ich keine Idee mehr.

[Kai P. (n_2)]

Hi Horst,

Du hast uns relativ wenig Informationen zur Verfügung gestellt....

Über welche Frequenz kommst Du nicht rüber ? Wie stellst Du das fest ?
Gehst Du mit dem Compare Wert runter und irgendwann erhöht sich die 
Frequenz der Interrupt nicht mehr ? Was sind die Werte, die Du 
einstellst ?

Benutzt Du ASF ? Oder programmierst Du bare metal ?

Oder stimmt nur Dein berechneter Compare-Wert nicht ? Wie hoch ist der 
denn ?

Auf die Schnelle 3 Ideen:

1) Der Prozessor braucht zu viel Zeit in den ganzen Interrupts. Das wäre 
der Fall, wenn Du den Compare-Wert immer weiter erniedrigst, und die 
Frequenz bleibt "stehen".
2) Dein Clock-Distribution-System ist nicht i.O. z.B. der Timer läuft 
mit 48MHz aber Deine Main Clock mit 1MHz(was typischerweise zu dem 
Fehler unter 1 führt, weil angenommen wird, die Main Clock ist auch auf 
48MHz)
3) Falls Dein Compare-Wert nur nicht passt: Der D21 hat keine 48MHz. 
Häufig werden die 48MHz über die internen 32kHz erzeugt. Der hat aber 
einen relativ großen Fehler. Die Clock läuft dann mit 47MHz oder auch 
49MHz.
Die 48MHz dann für den UART benutzen führt zu schicken 
Baudsratenfehlern…
Für den UART dann besser die 8MHz Clock nehmen.



Gruß N2

[Horst W. (wassolldas)]

Kai P. schrieb:
> Über welche Frequenz kommst Du nicht rüber ? Wie stellst Du das fest ?
> Gehst Du mit dem Compare Wert runter und irgendwann erhöht sich die
> Frequenz der Interrupt nicht mehr ? Was sind die Werte, die Du
> einstellst ?

Der Compare Wert stimmt bis zu einer bestimmten Frequenz dann erhöht 
sich die Frequenz nicht mehr obwohl der Compare Wert weiter erniedrigt 
wird.
Ich stelle dies fest indem ich einen Port toggle und mir das Ergebnis 
auf einem Oska anschaue.

> Benutzt Du ASF ? Oder programmierst Du bare metal ?

Nein ich programiere an der Basis

> Oder stimmt nur Dein berechneter Compare-Wert nicht ? Wie hoch ist der
> denn ?

Der berchnete Wert stimmt, wie gesagt bei höheren Frequenzen passt er.

Mehr Details später.

[Horst W. (wassolldas)]

Ich stelle mal den Source Code ein. Dies ist Code aus Beispielen von 
Microchip entsprechend geändert auf internen Oszi32k.
Hier Clock Init:

void ClocksInit(void){
  
  uint32_t tempDFLL48CalibrationCoarse;  /* used to retrieve DFLL48 coarse calibration value from NVM */

  /* ----------------------------------------------------------------------------------------------
  * 1) Set Flash wait states for 48 MHz (per Table 37-40 in data sheet)
  */
  
  NVMCTRL->CTRLB.bit.RWS = 1;    /* 1 wait state required @ 3.3V & 48MHz */
  
  /* ----------------------------------------------------------------------------------------------
  * 2) Enable XOSC32K clock (External on-board 32.768kHz oscillator), will be used as DFLL48M reference.
  */
  
  // Configure SYSCTRL->XOSC32K settings
  SYSCTRL_XOSC32K_Type sysctrl_xosc32k = {
    .bit.WRTLOCK = 0,    /* XOSC32K configuration is not locked */
    .bit.STARTUP = 0x2,    /* 3 cycle start-up time */
    .bit.ONDEMAND = 0,    /* Osc. is always running when enabled */
    .bit.RUNSTDBY = 0,    /* Osc. is disabled in standby sleep mode */
    .bit.AAMPEN = 0,    /* Disable automatic amplitude control */
    .bit.EN32K = 1,      /* 32kHz output is disabled */
    .bit.XTALEN = 1      /* Crystal connected to XIN32/XOUT32 */
  };
  
  SYSCTRL_OSC32K_Type sysctrl_osc32k = {
    .bit.WRTLOCK = 0,    /* OSC32K configuration is not locked */
    .bit.STARTUP = 0x2,    /* 3 cycle start-up time */
    .bit.ONDEMAND = 0,    /* Osc. is always running when enabled */
    .bit.RUNSTDBY = 0,    /* Osc. is disabled in standby sleep mode */
    .bit.EN32K = 1,      /* 32kHz output is disabled */
  };
  
  // Write these settings
//  SYSCTRL->XOSC32K.reg = sysctrl_xosc32k.reg;
  SYSCTRL->OSC32K.reg = sysctrl_osc32k.reg;
  // Enable the Oscillator - Separate step per data sheet recommendation (sec 17.6.3)
  SYSCTRL->OSC32K.bit.ENABLE = 1;
//  SYSCTRL->XOSC32K.bit.ENABLE = 1;
  
  // Wait for XOSC32K to stabilize
  while(!SYSCTRL->PCLKSR.bit.OSC32KRDY);
  
  /* ----------------------------------------------------------------------------------------------
  * 3) Put XOSC32K as source of Generic Clock Generator 1
  */
  
  // Set the Generic Clock Generator 1 output divider to 1
  // Configure GCLK->GENDIV settings
  GCLK_GENDIV_Type gclk1_gendiv = {
    .bit.DIV = 1,                /* Set output division factor = 1 */
//    .bit.ID = GENERIC_CLOCK_GENERATOR_XOSC32K  /* Apply division factor to Generator 1 */
    .bit.ID = 0x04  
  };
  // Write these settings
  GCLK->GENDIV.reg = gclk1_gendiv.reg;
  
  // Configure Generic Clock Generator 1 with XOSC32K as source
  GCLK_GENCTRL_Type gclk1_genctrl = {
    .bit.RUNSTDBY = 0,    /* Generic Clock Generator is stopped in stdby */
    .bit.DIVSEL =  0,    /* Use GENDIV.DIV value to divide the generator */
    .bit.OE = 0,      /* Disable generator output to GCLK_IO[1] */
    .bit.OOV = 0,      /* GCLK_IO[1] output value when generator is off */
    .bit.IDC = 1,      /* Generator duty cycle is 50/50 */
    .bit.GENEN = 1,      /* Enable the generator */
    .bit.SRC = 0x05,    /* Generator source: XOSC32K output */
//    .bit.ID = GENERIC_CLOCK_GENERATOR_XOSC32K      /* Generator ID: 1 */
    .bit.ID = 0x04      
  };
  // Write these settings
  GCLK->GENCTRL.reg = gclk1_genctrl.reg;
  // GENCTRL is Write-Synchronized...so wait for write to complete
  while(GCLK->STATUS.bit.SYNCBUSY);
  
  /* ----------------------------------------------------------------------------------------------
  * 4) Put Generic Clock Generator 1 as source for Generic Clock Multiplexer 0 (DFLL48M reference)
  */
  
  GCLK_CLKCTRL_Type gclk_clkctrl = {
    .bit.WRTLOCK = 0,    /* Generic Clock is not locked from subsequent writes */
    .bit.CLKEN = 1,      /* Enable the Generic Clock */
//    .bit.GEN = GENERIC_CLOCK_GENERATOR_XOSC32K,   /* Generic Clock Generator 1 is the source */
    .bit.GEN = 0x04,   /* Generic Clock Generator 1 is the source */
    .bit.ID = 0x00    /* Generic Clock Multiplexer 0 (DFLL48M Reference) */
  };
  // Write these settings
  GCLK->CLKCTRL.reg = gclk_clkctrl.reg;
  
  /* ----------------------------------------------------------------------------------------------
  * 5) Enable DFLL48M clock
  */
  
  // DFLL Configuration in Closed Loop mode, cf product data sheet chapter
  // 17.6.7.1 - Closed-Loop Operation
  
  // Enable the DFLL48M in open loop mode. Without this step, attempts to go into closed loop mode at 48 MHz will
  // result in Processor Reset (you'll be at the in the Reset_Handler in startup_samd21.c).
  // PCLKSR.DFLLRDY must be one before writing to the DFLL Control register
  // Note that the DFLLRDY bit represents status of register synchronization - NOT clock stability
  // (see Data Sheet 17.6.14 Synchronization for detail)
  while(!SYSCTRL->PCLKSR.bit.DFLLRDY);
  SYSCTRL->DFLLCTRL.reg = (uint16_t)(SYSCTRL_DFLLCTRL_ENABLE);
  while(!SYSCTRL->PCLKSR.bit.DFLLRDY);
  
  // Set up the Multiplier, Coarse and Fine steps
  SYSCTRL_DFLLMUL_Type sysctrl_dfllmul = {
    .bit.CSTEP = 31,    /* Coarse step - use half of the max value (63) */
    .bit.FSTEP = 511,    /* Fine step - use half of the max value (1023) */
    .bit.MUL = 1465      /* Multiplier = MAIN_CLK_FREQ (48MHz) / EXT_32K_CLK_FREQ (32768 Hz) */
  };
  // Write these settings
  SYSCTRL->DFLLMUL.reg = sysctrl_dfllmul.reg;
  // Wait for synchronization
  while(!SYSCTRL->PCLKSR.bit.DFLLRDY);
  
  // To reduce lock time, load factory calibrated values into DFLLVAL (cf. Data Sheet 17.6.7.1)
  // Location of value is defined in Data Sheet Table 10-5. NVM Software Calibration Area Mapping
  
  // Get factory calibrated value for "DFLL48M COARSE CAL" from NVM Software Calibration Area
  tempDFLL48CalibrationCoarse = *(uint32_t*)FUSES_DFLL48M_COARSE_CAL_ADDR;
  tempDFLL48CalibrationCoarse &= FUSES_DFLL48M_COARSE_CAL_Msk;
  tempDFLL48CalibrationCoarse = tempDFLL48CalibrationCoarse>>FUSES_DFLL48M_COARSE_CAL_Pos;
  // Write the coarse calibration value
  SYSCTRL->DFLLVAL.bit.COARSE = tempDFLL48CalibrationCoarse;
  // Switch DFLL48M to Closed Loop mode and enable WAITLOCK
  while(!SYSCTRL->PCLKSR.bit.DFLLRDY);
  SYSCTRL->DFLLCTRL.reg |= (uint16_t) (SYSCTRL_DFLLCTRL_MODE | SYSCTRL_DFLLCTRL_WAITLOCK);
  
  /* ----------------------------------------------------------------------------------------------
  * 6) Switch Generic Clock Generator 0 to DFLL48M. CPU will run at 48MHz.
  */
  
  // Now that DFLL48M is running, switch CLKGEN0 source to it to run the core at 48 MHz.
  // Enable output of Generic Clock Generator 0 (GCLK_MAIN) to the GCLK_IO[0] GPIO Pin
  GCLK_GENCTRL_Type gclk_genctrl0 = {
    .bit.RUNSTDBY = 0,    /* Generic Clock Generator is stopped in stdby */
    .bit.DIVSEL =  0,    /* Use GENDIV.DIV value to divide the generator */
    .bit.OE = 1,      /* Enable generator output to GCLK_IO[0] */
    .bit.OOV = 0,      /* GCLK_IO[0] output value when generator is off */
    .bit.IDC = 1,      /* Generator duty cycle is 50/50 */
    .bit.GENEN = 1,      /* Enable the generator */
    .bit.SRC = 0x07,    /* Generator source: DFLL48M output */
    .bit.ID = GENERIC_CLOCK_GENERATOR_MAIN      /* Generator ID: 0 */
  };
  GCLK->GENCTRL.reg = gclk_genctrl0.reg;
  // GENCTRL is Write-Synchronized...so wait for write to complete
  while(GCLK->STATUS.bit.SYNCBUSY);
  
  // Direct the GCLK_IO[0] output to PA28
  PORT_WRCONFIG_Type port0_wrconfig = {
    .bit.HWSEL = 1,      /* Pin# (28) - falls in the upper half of the 32-pin PORT group */
    .bit.WRPINCFG = 1,    /* Update PINCFGy registers for all pins selected */
    .bit.WRPMUX = 1,    /* Update PMUXn registers for all pins selected */
    .bit.PMUX = 7,      /* Peripheral Function H selected (GCLK_IO[0]) */
    .bit.PMUXEN = 1,    /* Enable peripheral Multiplexer */
    .bit.PINMASK = (uint16_t)(1 << (28-16)) /* Select the pin(s) to be configured */
  };
  // Write these settings
  PORT->Group[0].WRCONFIG.reg = port0_wrconfig.reg;
  
  /* ----------------------------------------------------------------------------------------------
  * 7) Modify prescaler value of OSC8M to produce 8MHz output
  */

  SYSCTRL->OSC8M.bit.PRESC = 0;    /* Prescale by 1 */
  SYSCTRL->OSC8M.bit.ONDEMAND = 0 ;  /* Oscillator is always on if enabled */
  
  /* ----------------------------------------------------------------------------------------------
  * 8) Put OSC8M as source for Generic Clock Generator 3
  */
  
  // Set the Generic Clock Generator 3 output divider to 1
  // Configure GCLK->GENDIV settings
  GCLK_GENDIV_Type gclk3_gendiv = {
    .bit.DIV = 1,                /* Set output division factor = 1 */
    .bit.ID = GENERIC_CLOCK_GENERATOR_OSC8M    /* Apply division factor to Generator 3 */
  };
  // Write these settings
  GCLK->GENDIV.reg = gclk3_gendiv.reg;
  
  // Configure Generic Clock Generator 3 with OSC8M as source
  GCLK_GENCTRL_Type gclk3_genctrl = {
    .bit.RUNSTDBY = 0,    /* Generic Clock Generator is stopped in stdby */
    .bit.DIVSEL =  0,    /* Use GENDIV.DIV value to divide the generator */
    .bit.OE = 0,      /* Disable generator output to GCLK_IO[1] */
    .bit.OOV = 0,      /* GCLK_IO[2] output value when generator is off */
    .bit.IDC = 1,      /* Generator duty cycle is 50/50 */
    .bit.GENEN = 1,      /* Enable the generator */
    .bit.SRC = 0x06,    /* Generator source: OSC8M output */
    .bit.ID = GENERIC_CLOCK_GENERATOR_OSC8M      /* Generator ID: 3 */
  };
  // Write these settings
  GCLK->GENCTRL.reg = gclk3_genctrl.reg;
  // GENCTRL is Write-Synchronized...so wait for write to complete
  while(GCLK->STATUS.bit.SYNCBUSY);
  
  /* ----------------------------------------------------------------------------------------------
  * 9) Set CPU and APBx BUS Clocks to 48MHz
  */
  PM->CPUSEL.reg  = PM_CPUSEL_CPUDIV_DIV1 ;
  PM->APBASEL.reg = PM_APBASEL_APBADIV_DIV1_Val ;
  PM->APBBSEL.reg = PM_APBBSEL_APBBDIV_DIV1_Val ;
  PM->APBCSEL.reg = PM_APBCSEL_APBCDIV_DIV1_Val ;
  
} // ClockSysInit48M()

Hier Timer Init:

void AppInit(void){
  
  /*  Clock Initialization (CPU, AHB, APBx)
    The System RC Oscillator (OSC8M) provides the source for the main clock
    at chip startup. It is set to 1 MHz. Clock Generator 0 is enabled. */
    
  // Add code here to change the system clock and enable clock generator(s)
  
  /* Disable all IRQs until all application initialization completed */
  __disable_irq();
  
  /* Digital I/O Initialization */  
  
  pinMode(IO_PA15,OUTPUT); //this configures the LED pin, you can remove this it's just example code
//  PORT->Group[LED0_PORT].DIRSET.reg = LED0_PIN ;                // Assign the LED0 pin as OUTPUT
//  PORT->Group[LED0_PORT].OUTSET.reg = LED0_PIN ;                // Set the LED0 pin level, i.e. put to 3.3V -> this turns off the LED

  /* TC3 Initialization (Generate Compare Interrupts every 100mS) */
  
  // Configure asynchronous clock source
  GCLK->CLKCTRL.reg = GCLK_CLKCTRL_ID_TCC2_TC3_Val;              // select TC3 peripheral channel
  GCLK->CLKCTRL.reg |= GCLK_CLKCTRL_GEN_GCLK0;                // select source GCLK_GEN[0]
  GCLK->CLKCTRL.bit.CLKEN = 1;                        // enable generic clock
  
  // Configure synchronous bus clock
  PM->APBCSEL.bit.APBCDIV = 0;                        // no prescaler
  PM->APBCMASK.bit.TC3_ = 1;                          // enable TC3 interface
  
  // Configure Count Mode (16-bit)
  TC3->COUNT16.CTRLA.bit.MODE = 0x0;
  
  // Configure Prescaler for divide by 2 (500kHz clock to COUNT)
//  TC3->COUNT16.CTRLA.bit.PRESCALER = 0x1;
  TC3->COUNT16.CTRLA.bit.PRESCALER = 0x0;
  
  // Configure TC3 Compare Mode for compare channel 0
  TC3->COUNT16.CTRLA.bit.WAVEGEN = 0x1;                    // "Match Frequency" operation
  
  // Initialize compare value for 
//  TC3->COUNT16.CC[0].reg = 10000;            // ergibt -> 398Hz gemessen
//  TC3->COUNT16.CC[0].reg = 1000;            // ergibt -> 3,98kHz gemessen
  TC3->COUNT16.CC[0].reg = 500;            // ergibt -> 8kHz gemessen
//  TC3->COUNT16.CC[0].reg = 100;            // ergibt -> 19,7kHz gemessen  
//  TC3->COUNT16.CC[0].reg = 10;            // ergibt -> 38kHz gemessen  
//  TC3->COUNT16.CC[0].reg = 1;              // ergibt -> 38kHz gemessen  
  
  // Enable TC3 compare mode interrupt generation
  TC3->COUNT16.INTENSET.bit.MC0 = 0x1;                    // Enable match interrupts on compare channel 0   
  
  // Enable TC3
  TC3->COUNT16.CTRLA.bit.ENABLE = 1;
  
  // Wait until TC3 is enabled
  while(TC3->COUNT16.STATUS.bit.SYNCBUSY == 1);
  
  /* Configure/Enable Interrupts */
  NVIC_SetPriority(TC3_IRQn, 3);                        // Set the interrupt priority to lowest value
  NVIC_EnableIRQ(TC3_IRQn);                          // Enable the interrupt
  
  /* Enable all IRQs */
  __enable_irq();
  
}

Die Initialisierung vom Clock ist extrem kompliziert und schlecht im 
Datenblatt beschrieben.

ICh habe in den Kommentaren für den Compare Wert die resultierenden 
Frequenzen angegeben. Das ist irgendwie nicht linear.

[Horst W. (wassolldas)]

!! Ich habe nun die Fehler in der CLK Initialisierung gefunden!!!

Hatte doch einiges vermurkst beim Umschreiben des Microchip Beispielcode 
auf internen Clock. Jetzt scheint es zu funktionieren.
Allerdings ist mir aufgefallen dass der interne Clock absolut ja 
ziemlich daneben liegt. Wenn ich das vom Timer hochrechne läuft der 
jetzt mit 56MHz.

Kann das sein?

Auf jeden Fall Danke, die Antworten haben mich auf den richtigen Pfad 
gebracht.

[Kai P. (n_2)]

Hi,

Datenblatt 36.11.5:
Wenn Du den ULP nutzt, kann das theoretisch vom Internen kommen: 
38011*1500 ~ 57MHz

Aber: Du nutzt das Ding sicher bei Raumtemperatur und 3V3, dann dürfen 
es maximal knapp 52MHz sein. Der normale Interne ist ein bissle besser.

Da ich mich mit PLL nicht so gut auskenne, kann ich über den 
zusätzlichen Fehler, der über eine PLL reinkommt, leider nix sagen. Vom 
Prinzip her würde ich eine Erhöhung des Jitters erwarten aber keine 
weitere Frequenzverschiebung (da die Teiler ja ganzzahlig fest 
vorgegeben sind).

Daher würde ich bei 56MHz versuchen, herauszufinden, woran das liegt.

Gibt Dir den internen 32kHz Clock mal auf einem GPIO aus und messe erst 
mal diese Frequenz. Wenn die nach Spec ist, nochmal schauen, ob die 
Teiler der PLL alle wirklich richtig sind. Auch mal überlegen, ob der 
Messaufbau  das Messgerät  die Messmethode hinreichend genau sind. 
Kann der SAM schon "misshandelt" worden sein (ESD) ? Sich die Theorie 
einer PLL anschauen, ob dort noch Fehler entstehen können.


Dann an Microchip wenden :-)

Gruß N2