SAMD21: 8bit timer problem

[timer4 (Gast)]

Hallo,
ich bin gerade etwas am verzeifeln:

TC4 im SAMD21J18 soll einfach nur zählen und bei erreichen eines 
Endwertes soll es auf ZERO springen und das Interrupt-flag dazu setzen.
Klingt nicht schwer ..

Bei meinem eingestellten TC4 wird die Prüfbedingung nie wahr, der TC4 
setzt immer das interruptflag OVF, statt CM1 oder CM0.
Lasse ich eine LED toggeln erhalte ich ein Rechteck mit einer periode 
von 16,48ms

Also für mich sieht es so aus, als würde der TC4 sogar mit 16bit laufen 
statt 8bit.

void timer4_init() {
  /*
    NFRQ:  PER = TOP
  */
  
  #define TC4_WAIT_SYNC  while(REG_TC4_STATUS & 1<<7)
  
  #define TC_PRES_DIV1  0 << 8
  #define TC_NFRQ      0 << 5
  #define TC_MFRQ      1 << 5
  #define TC_MODE_COUNT8  1 << 2
  #define TC_ENABLE    1 << 1
  #define TC_RESET    1 << 0
  REG_TC4_CTRLA = TC_RESET;
  TC4_WAIT_SYNC;
  
  REG_TC4_CTRLA = TC_PRES_DIV1 | TC_MFRQ | TC_MODE_COUNT8;
  TC4_WAIT_SYNC;
  
  #define TC_CTRLB_RETRIGGER 1 << 6
  #define ONESHOT        1 << 2
  REG_TC4_CTRLBSET = TC_CTRLB_RETRIGGER;
  TC4_WAIT_SYNC;
  
  
  #define TC__CTRLC_CPTEN1 1 << 5
  #define TC__CTRLC_CPTEN0 1 << 4
  REG_TC4_CTRLC = TC__CTRLC_CPTEN1|TC__CTRLC_CPTEN0;
  TC4_WAIT_SYNC;
  
  
  //#define TC_INTEN_CM1  1<<5
  #define MC0  1<<4
  #define MC1  1<<5
  #define OVF  1
  #define ERR 2
  REG_TC4_INTENSET = MC0|MC1|OVF|ERR;
  TC4_WAIT_SYNC;
  
  REG_TC4_COUNT8_COUNT = 125;
  TC4_WAIT_SYNC;
  REG_TC4_COUNT8_CC0 = 100;
  TC4_WAIT_SYNC;
  REG_TC4_COUNT8_CC1 = 25;
  TC4_WAIT_SYNC;
  REG_TC4_COUNT8_PER = 150;
  TC4_WAIT_SYNC;
  
  REG_TC4_CTRLA = TC_ENABLE;
  TC4_WAIT_SYNC;
}

ui8 check_tc4() {  
  if(REG_TC4_INTFLAG & MC0) {
    REG_TC4_INTFLAG =  MC0;
    return 1;
  }
  
  if(REG_TC4_INTFLAG & MC1) {
    REG_TC4_INTFLAG =  MC1;
    return 2;
  }

  if(REG_TC4_INTFLAG & OVF) {
    return 3;
  }
  
  if(REG_TC4_INTFLAG & ERR) {
    REG_TC4_INTFLAG =  ERR;
    return 4;
  }

  return 0;
}

[timer4 (Gast)]

N A C H T R A G:

Wenn ich dann in meiner main schleife check_tc4() ab-polle dann erhalte 
ich immer den Wert 3 -> OVF-bit war gesetzt.

[Jim M. (turboj)]

>   #define TC_PRES_DIV1  0 << 8

Da würde ich immer  klammern:

 
#define TC_PRES_DIV1  (0 << 8)

Ansonsten kommt man bei C mit der Reihenfolge von Operatoren 
durcheinander, d.h. in REG_TC4_CTRLA landet nicht der erwartete Wert.

[Tretbrettfahrer (Gast)]

timer4 schrieb:
> while (REG_TC4_STATUS & 1<<7)

Auch so was kann schwer missverstanden werden. Ich klammere
schon deswegen weil ich mir nie die Priorität dieser Operatoren
merken kann.

[timer4 (Gast)]

die Schiebeoperatoren haben Vorrang. Aber der Übersichtlichkeit halber 
sind Klammern besser :)

void timer4_init() {
  /*
    NFRQ:  PER = TOP
  */
  
  #define TC4_WAIT_SYNC  while(REG_TC4_STATUS & (1<<7))
  
  #define TC_PRES_DIV1  (0 << 8)
  #define TC_NFRQ      (0 << 5)
  #define TC_MFRQ      (1 << 5)
  #define TC_MODE_COUNT8  (1 << 2)
  #define TC_ENABLE    (1 << 1)
  #define TC_RESET    (1 << 0)
  REG_TC4_CTRLA = TC_RESET;
  TC4_WAIT_SYNC;
  
  REG_TC4_CTRLA = TC_PRES_DIV1 | TC_NFRQ | TC_MODE_COUNT8;
  TC4_WAIT_SYNC;
  
  #define TC_CTRLB_RETRIGGER (1 << 6)
  #define ONESHOT        (1 << 2)
  REG_TC4_CTRLBSET = TC_CTRLB_RETRIGGER;
  TC4_WAIT_SYNC;
  
  
  #define TC__CTRLC_CPTEN1 (1 << 5)
  #define TC__CTRLC_CPTEN0 (1 << 4)
  REG_TC4_CTRLC = TC__CTRLC_CPTEN1|TC__CTRLC_CPTEN0;
  TC4_WAIT_SYNC;
  
  
  #define MC0  (1<<4)
  #define MC1  (1<<5)
  #define OVF  1
  #define ERR 2
  REG_TC4_INTENSET = MC0|MC1|OVF|ERR;
  TC4_WAIT_SYNC;
  
  /*
  REG_TC4_COUNT8_COUNT = 125;
  TC4_WAIT_SYNC;
  REG_TC4_COUNT8_CC0 = 100;
  TC4_WAIT_SYNC;
  REG_TC4_COUNT8_CC1 = 25;
  TC4_WAIT_SYNC;
  REG_TC4_COUNT8_PER = 150;
  TC4_WAIT_SYNC;
  */
  REG_TC4_COUNT8_PER = 50;
  TC4_WAIT_SYNC;
  
  REG_TC4_CTRLA = TC_ENABLE;
  TC4_WAIT_SYNC;
}

ui8 check_tc4() {  
  if(REG_TC4_INTFLAG & MC0) {
    REG_TC4_INTFLAG =  MC0;
    return 1;
  }
  
  if(REG_TC4_INTFLAG & MC1) {
    REG_TC4_INTFLAG =  MC1;
    return 2;
  }

  if(REG_TC4_INTFLAG & OVF) {
    return 3;
  }
  
  if(REG_TC4_INTFLAG & ERR) {
    REG_TC4_INTFLAG =  ERR;
    return 4;
  }

  return 0;
}

[timer4 (Gast)]

N A C H T R A G:
in check_tc4 was das OVF bit nicht zurück gesetzt. Dennoch keine 
Änderung..

ui8 check_tc4() {  
  if(REG_TC4_INTFLAG & MC0) {
    REG_TC4_INTFLAG =  MC0;
    return 1;
  }
  
  if(REG_TC4_INTFLAG & MC1) {
    REG_TC4_INTFLAG =  MC1;
    return 2;
  }

  if(REG_TC4_INTFLAG & OVF) {
    REG_TC4_INTFLAG = OVF;
    return 3;
  }
  
  if(REG_TC4_INTFLAG & ERR) {
    REG_TC4_INTFLAG =  ERR;
    return 4;
  }

  return 0;
}

[timer4 (Gast)]

Ich weis nicht woran es liegt aber ich habe den TCC0 gleich beim ersten 
mal zum laufen bekommen, obwohl dieser wesentlich umfangreicher ist.
Im forum avrfreaks habe ich mehrmals gelesen das man am besten die 
einfachen TC´s nicht nutzen sollte, wegen bugs. ich dachte immer bugs 
gibt nur im zusammenhang mit der API :D

[MaWin (Gast)]

timer4 schrieb:
> der Übersichtlichkeit halber

Schreibt man irgendwelche #define nicht mitten im source code. Entweder 
sind sie Teil des Interface oder globale Schalter.

und 1 << 5 ist sowieso ein Atmel Krampf. Welche Bedeutung hat das 6te 
Bit in dem Register? Zum controller gehört doch ein header, oder?

[Elektrolurch (Gast)]

Du hast CAPTENx gesetzt. Damit hast du den Capture-Mode eingestellt!
Der macht Counter-Stamps, wenn eine Triggerquelle vorhanden ist.
Du willst aber PWM und das ist der Compare-Mode. deshalb dürfen CAPTENx 
nicht gesetzt sein.
Und ja, in Atmel Studio etc. verwendet man tunlichst die vordefinierten 
Header. Ich habe mir diese PWM-Init-Routine geschrieben. Mit Rechtsclick 
und "Goto Implementation" siehst du wo und wie die definiert sind:

#include "sam.h"
void TcPwm8Init(Tc* const tctimer, const uint8_t clkdiv, const uint8_t 
channel, uint8_t effper, uint8_t pulse)
{
  if(!effper)
    return;
  // Timer Reset
  tctimer->COUNT8.CTRLA.bit.SWRST= 1;
  while(tctimer->COUNT8.CTRLA.bit.SWRST) ;
  // Enable the TC bus clock (CLK_TCx_APB)...
  TcTimerPowerUp(tctimer);
  tctimer->COUNT8.CTRLA.reg= TC_CTRLA_PRESCSYNC_RESYNC | 
(TC_CTRLA_PRESCALER_Msk & (clkdiv << TC_CTRLA_PRESCALER_Pos)) | 
TC_CTRLA_WAVEGEN_NPWM | TC_CTRLA_MODE_COUNT8;
  while(tctimer->COUNT8.STATUS.bit.SYNCBUSY) ;
  tctimer->COUNT8.PER.reg= effper - 1;
  while(tctimer->COUNT8.STATUS.bit.SYNCBUSY) ;
  tctimer->COUNT8.CC[channel].reg= pulse;
  while(tctimer->COUNT8.STATUS.bit.SYNCBUSY) ;
}

Ich hoffe, das hilft dir.

[timer4 (Gast)]

Vielen Dank für deine Hilfe  Elektrolurch.
Ich stelle gerad enoch ein grundlegendes Problem fest. Mein Main-clock 
scheint nicht 8MHz zu sein, ich habe eher 800Khz.

#include "sam.h"

int main() {
  REG_SYSCTRL_OSC8M &= ~(3 << 8); // no prescaler
  
  REG_PORT_DIRSET1 = (1<<10);
  while(1) {
    REG_PORT_OUTTGL1 = (1<<10);
  }
}

Ich Messe 1,214µs zwischen jeden Flankenwechsel. Bei 8MHz würde ich aber 
125ns erwarten.