SAMD20 timer counter 1 läuft nicht

[chris_ (Gast)]

Für ein MC-System brauche ich einen Systemcounter mit Microsekunden 
Auflösung.
Ursprünglich wollte ich den ARM0 Systemcounter verwenden und diesen mit 
den ASF-Treibern ansprechen:

Beitrag "ARM Cortex M0 system timer"

Nach einigen Ratschlägen bin ich zum Schluss gekommen, auf die ASF und 
sonstige fertige Treiber zu verzichten, alles von Hand zu machen und 
einen 32 Timer/Counter zu verwenden.

Hier gibt es ein Beispiel:
http://community.atmel.com/forum/timerscounters-0?skey=samd%20timer%20example

#define true 1
#define false 0

typedef union {
  struct {
    uint16_t SWRST:1;          /*!< bit:      0  Software Reset                     */
    uint16_t ENABLETC:1;         /*!< bit:      1  Enable                             */
    uint16_t MODE:2;           /*!< bit:  2.. 3  TC Mode                            */
    uint16_t :1;               /*!< bit:      4  Reserved                           */
    uint16_t WAVEGEN:2;        /*!< bit:  5.. 6  Waveform Generation Operation      */
    uint16_t :1;               /*!< bit:      7  Reserved                           */
    uint16_t PRESCALER:3;      /*!< bit:  8..10  Prescaler                          */
    uint16_t RUNSTDBY:1;       /*!< bit:     11  Run in Standby                     */
    uint16_t PRESCSYNC:2;      /*!< bit: 12..13  Prescaler and Counter Synchronization */
    uint16_t :2;               /*!< bit: 14..15  Reserved                           */
    } bit;                       /*!< Structure used for bit  access                  */
    uint16_t reg;                /*!< Type      used for register access              */
  } TC_CTRLA_TypeX;

void Init_TC1(void)
{
  // Turn on the digital interface clock 
  PM->APBCMASK.reg |= PM_APBCMASK_TC1;

  // Turn on the analog interface clock and select GCLK 
  GCLK_CLKCTRL_Type clkctrl =
  {
    .bit.WRTLOCK = false,
    .bit.CLKEN = true,
    .bit.ID = TC1_GCLK_ID,
    .bit.GEN = 0,
  };
  
  GCLK->CLKCTRL.reg = clkctrl.reg;
  TC1->COUNT32.CTRLA.bit.SWRST = true;

  // wait for synchronization to complete 
  while (TC1->COUNT32.STATUS.bit.SYNCBUSY == true);

  // set the access mode for the timer 
  TC1->COUNT32.CTRLA.reg = TC_CTRLA_MODE_COUNT32;

  TC_CTRLA_TypeX tc_ctrla =
  {
    .bit.PRESCSYNC = 0,
    .bit.RUNSTDBY = 0,
    .bit.PRESCALER = 4, // TC_PRESCALER_DIV16 
    .bit.WAVEGEN = 0,   // Normal Frequency
    .bit.MODE = 2,      // TC_MODE_COUNT32 
    .bit.ENABLETC = 1,
  };

  TC1->COUNT32.CTRLA.reg = tc_ctrla.reg;
  // wait for synchronization to complete 
  while (TC1->COUNT32.STATUS.bit.SYNCBUSY == true);
 
}

In Atmel Studio sieht man, dass die Register initialisiert werden, aber 
der Zähler zählt einfach nicht.

Liegt es vielleicht am Input-Clock? Hat jemand eine Idee?

[Marco H. (damarco)]

PMC Clock für die Timer aktiviert ? Auch für die PIO ?

pmc_enable_periph_clk(ID_PIOB);

Auch die PIO entsprechen Konfiguriert ?

pio_configure(PIOB,PIO_PERIPH_B,PIO_PB25,PIO_DEFAULT);    // Port PIO_PB25 auf TIOA vom Timer TC0

pmc_enable_periph_clk(ID_TC0);

NVIC_DisableIRQ(TC0_IRQn);

NVIC_ClearPendingIRQ(TC0_IRQn);

NVIC_SetPriority(TC0_IRQn,5);

NVIC_EnableIRQ(TC0_IRQn);

tc_init(TC0,0,  TC_CMR_TCCLKS_TIMER_CLOCK5|                  // set clock slow clock 32768HZ
          TC_CMR_LDRA_FALLING|                    // load RA by falling edge 
          TC_CMR_ETRGEDG_RISING|                    // set TC zero by rising edge
          TC_CMR_ABETRG|                        // trigger from TIOA
          TC_CMR_CPCTRG                        // interrupt by RC compare  
          );)

// set RC on 1.1sec  timeout                                                 
    tc_write_rc(TC0,0,36045);

tc_enable_interrupt(TC0,0,TC_IER_CPCS|
              TC_IER_LDRAS);

tc_start(TC0,0);      // ab hier läuft er los ;)

Wenn Interrupts aktiv

void TC0_Handler(void){
tc_get_status(TC0,0); // unbedingt auslesen damit das Flag zurückgesetzt wird 

}

Eigentlich nicht schwer ;) welche Flags man setzen muss kann man aus dem 
Referenz Manual entnehmen. Bitte den Code nicht per Copy übernehmen. Sie 
sind für einen sam3x. Das ASF sollte aber ähnlich sein :)

[chris_ (Gast)]

>Auch die PIO entsprechen Konfiguriert ?

Danke für die Antwort. Die Ports brauche ich nicht. Ich brauche nur den 
Zählerstand des Counters. Der Counter wird mit dem Systemclock 
getacktet.

[Marco H. (damarco)]

Also beim SAM3 kann man das Umstellen. Jeder Timerchannel hat seinen 
eignen Teiler und man kann ihn auf den Slowclock stellen.

In der Referenz ist mit Sicherheit eine Übersicht voraus man die 
Möglichkeiten entnehmen kann.

 tc_start(TC0,0); Startet den Channel sonst läuft dieser nicht los. 
Dieser gibt den Clock frei.

[Jörg W. (dl8dtl) (Moderator)]

Bitte möglichst keine Hardware-Bitfields selbst definieren.  Diese
sind normalerweise alle über "sam.h" bereits da.  Wenn nicht, musst
du sehen, wie du sie ranbekommst.

Ich habe hier beispielsweise sowas für einen 1-Hz-Takt im TC3:

  /*
   * TC3: 1 Hz MFRQ mode: prescaler 1024 (= 15625 Hz clock)
   */
  GCLK->CLKCTRL.reg = GCLK_CLKCTRL_CLKEN | GCLK_CLKCTRL_GEN(0) | GCLK_CLKCTRL_ID_20;
  TC3->COUNT16.CTRLA.reg = TC_CTRLA_MODE(TC_CTRLA_MODE_COUNT16_Val) |
    TC_CTRLA_WAVEGEN(TC_CTRLA_WAVEGEN_MFRQ_Val) |
    TC_CTRLA_PRESCALER(TC_CTRLA_PRESCALER_DIV1024_Val);
  while (TC3->COUNT16.STATUS.bit.SYNCBUSY) {}
  TC3->COUNT16.CTRLA.reg |= TC_CTRLA_ENABLE;
  while (TC3->COUNT16.STATUS.bit.SYNCBUSY) {}
  TC3->COUNT16.CC[0].bit.CC = 15625;            /* => 1 Hz */
  while (TC3->COUNT16.STATUS.bit.SYNCBUSY) {}
  TC3->COUNT16.CC[1].bit.CC = 3000;
  while (TC3->COUNT16.STATUS.bit.SYNCBUSY) {}
  TC3->COUNT16.INTENSET.bit.MC0 = 1; /* interrupt on reload */
  TC3->COUNT16.INTENSET.bit.MC1 = 1; /* interrupt on match */
  NVIC_SetPriority(TC3_IRQn, 1);
  NVIC_EnableIRQ(TC3_IRQn);

[Jörg W. (dl8dtl) (Moderator)]

Marco H. schrieb:
> Also beim SAM3 kann man das Umstellen.

SAMD und Konsorten sind in den Peripherals völlig anders (allerdings
meiner Meinung nach durchaus in vielen Dingen besser).

[chris_ (Gast)]

>Bitte möglichst keine Hardware-Bitfields selbst definieren.

Hallo Jörg,

ich weiß, ich weiß. Leider gab es in dem Atmel-Framwork einen Fehler in 
"compile.h" weil dort ein

#define ENABLE 1

stand. Was mit der Defintion in "tc.h" kollidiert ist. Deshalb habe ich 
die Struktur zum Test raus genommen und umbenannt.

Ich habe es gerade noch mal mit einer anderen Version der probiert, da 
haben sie den Fehler wohl beseitigt.

[Jörg W. (dl8dtl) (Moderator)]

Das liegt daran, dass die Jungs dort sich nicht an gängige
Konventionen halten: Makros schreibt man GROSS, andere Bezeichner
(wie bspw. in Bitfeldern) schreibt man klein oder camelCase.

Das gleiche passiert einem bei sowas:

PM->APBBMASK.bit.PORT = 1;

Ist zum Glück nicht nötig, da der Takt für PORT standardmäßig im
PM aktiv ist.  Wenn man die Zeile compilieren will, stolpert man
drüber, dass das Bitfield namens PORT mit einem gleichnamigen Makro
kollidiert.

[chris_ (Gast)]

>Ich habe hier beispielsweise sowas für einen 1-Hz-Takt im TC3:

Danke dafür. Jetzt bewegt sich der Counter endlich. Ich musste noch eine 
kleine Änderung für den SAMD20 machen, weil es eine Definition anders 
ist ( siehe Programmtext ).
Jetzt muss ich nur noch auf 32bit und 1us Tick umstellen.

void Init_TC3(void)
{
  // Turn on the digital interface clock 
  PM->APBCMASK.reg |= PM_APBCMASK_TC3;
  /*
   * TC3: 1 Hz MFRQ mode: prescaler 1024 (= 15625 Hz clock)
   */
 // GCLK->CLKCTRL.reg = GCLK_CLKCTRL_CLKEN | GCLK_CLKCTRL_GEN(0) | GCLK_CLKCTRL_ID_20;
 GCLK->CLKCTRL.reg = GCLK_CLKCTRL_CLKEN | GCLK_CLKCTRL_GEN(0) |GCLK_CLKCTRL_ID_TC2_TC3;
  TC3->COUNT16.CTRLA.reg = TC_CTRLA_MODE(TC_CTRLA_MODE_COUNT16_Val) |
    TC_CTRLA_WAVEGEN(TC_CTRLA_WAVEGEN_MFRQ_Val) |
    TC_CTRLA_PRESCALER(TC_CTRLA_PRESCALER_DIV1024_Val);
  while (TC3->COUNT16.STATUS.bit.SYNCBUSY) {}
  TC3->COUNT16.CTRLA.reg |= TC_CTRLA_ENABLE;
  while (TC3->COUNT16.STATUS.bit.SYNCBUSY) {}
  TC3->COUNT16.CC[0].bit.CC = 15625;            /* => 1 Hz */
  while (TC3->COUNT16.STATUS.bit.SYNCBUSY) {}
  TC3->COUNT16.CC[1].bit.CC = 3000;
  while (TC3->COUNT16.STATUS.bit.SYNCBUSY) {}
}
...
while(1)
{
  uint16_t counterValue=TC3->COUNT16.COUNT.reg;
  printNumber(counterValue);
  delay_ms(100);
  print_CR();
}

[chris_ (Gast)]

Leider funktioniert genau die gleiche Konfiguration nur mit 32bit nicht.
Woran könnte das denn liegen? Laut Datenblatt müsste der Counter 32bit 
können.

void Init_TC3_32bit(void)
{
  // Turn on the digital interface clock 
  PM->APBCMASK.reg |= PM_APBCMASK_TC3;
  
  // clock source configuration
  GCLK->CLKCTRL.reg = GCLK_CLKCTRL_CLKEN | GCLK_CLKCTRL_GEN(0) |GCLK_CLKCTRL_ID_TC2_TC3;
  
  TC3->COUNT32.CTRLA.reg = TC_CTRLA_MODE(TC_CTRLA_MODE_COUNT32_Val) |
  TC_CTRLA_WAVEGEN(TC_CTRLA_WAVEGEN_MFRQ_Val) |
  TC_CTRLA_PRESCALER(TC_CTRLA_PRESCALER_DIV1024_Val);
  while (TC3->COUNT32.STATUS.bit.SYNCBUSY) {}
  TC3->COUNT32.CTRLA.reg |= TC_CTRLA_ENABLE;
  while (TC3->COUNT32.STATUS.bit.SYNCBUSY) {}
  TC3->COUNT32.CC[0].bit.CC = 15625;            //=> 1 Hz 
  while (TC3->COUNT32.STATUS.bit.SYNCBUSY) {}
  TC3->COUNT32.CC[1].bit.CC = 3000;
  while (TC3->COUNT32.STATUS.bit.SYNCBUSY) {}  
}

..
  while(1)
  {
    //uint16_t counterValue=TC3->COUNT16.COUNT.reg;
    uint32_t counterValue=TC3->COUNT32.COUNT.reg;
    printNumber(counterValue);
    delay_ms(100);
    print_CR();
  }

[Jörg W. (dl8dtl) (Moderator)]

chris_ schrieb:
> Leider funktioniert genau die gleiche Konfiguration nur mit 32bit nicht.

32-bit-TC braucht zwei unmittelbar aufeinanderfolgende TCs.  Ist
ein bisschen tricky.  Wenn ich mich recht erinnere, muss man dann
alles auf TC2 konfigurieren, und TC3 wird dabei implizit mit
herangezogen.

Lies diesbezüglich nochmal genau das Datenblatt.  Hab' gerade keine
Zeit dafür.

[chris_ (Gast)]

Danke für den Hinweis. Ich denke, das ist einer der Punkte, bei denen 
man lange suchen kann.

Ich kopiere mal die entsprechende Stelle aus dem Datenblatt und 
versuche, daraus schlau zu werden:

COUNT32: This mode is achieved by pairing two 16-bit TC peripherals. This pairing is explained in “Clocks” on
page 443. The even-numbered TC instance will act as master to the odd-numbered TC peripheral, which will act
as a slave. The slave status of the slave is indicated by reading the Slave bit in the Status register
(STATUS.SLAVE). The registers of the slave will not reflect the registers of the 32-bit counter. Writing to any of the
slave registers will not affect the 32-bit counter. Normal access to the slave COUNT and CCx registers is not
allowed.

Was mich wundert: Du hast TC3 als counter verwendet. Das scheinen einige 
so zu tun. Die Frage ist: Warum nicht bei TC0 beginnen? Hat das auch 
etwas mit den "Inhomogenitäten" dieser Peripherie zu tun?

[chris_ (Gast)]

So, jetzt läuft der Microsekunden Systemcounter endlich:

/*
  initialize timer 2 and 3 as 32 bit system timer
  
  This configuration is for 8Mhz system frequency.
  
*/
void Init_TC2_32bit(void)
{
  
  PM->APBCMASK.reg |= PM_APBCMASK_TC2; // Turn on the digital interface clock for timer 2
  
  // clock source configuration
  GCLK->CLKCTRL.reg = GCLK_CLKCTRL_CLKEN      |
                      GCLK_CLKCTRL_GEN(0)     | // use clock generator 0 as source
            GCLK_CLKCTRL_ID_TC2_TC3 ;
  
  TC2->COUNT32.CTRLA.reg = TC_CTRLA_MODE      ( TC_CTRLA_MODE_COUNT32_Val    ) | // 32 bit count
                           TC_CTRLA_WAVEGEN   ( TC_CTRLA_WAVEGEN_MFRQ_Val    ) | // 32 bit frequency generator
                           TC_CTRLA_PRESCALER ( TC_CTRLA_PRESCALER_DIV8_Val  ) ; // 1us clock tick at 8Mhz CLK
  while (TC2->COUNT32.STATUS.bit.SYNCBUSY) {} // wait for setup
  
  // reload value    
  TC2->COUNT32.CC[0].bit.CC = 0xFFFFFFFF;
  while (TC2->COUNT32.STATUS.bit.SYNCBUSY) {} // wait for setup

  // start counter
  TC2->COUNT32.CTRLA.reg |= TC_CTRLA_ENABLE;
  while (TC2->COUNT32.STATUS.bit.SYNCBUSY) {} // wait for setup
    
}

/*
  get the system time in micro seconds
*/
uint32_t micros()
{
  return TC2->COUNT32.COUNT.reg;
}

Vielen Dank, Jörg.

[Marco H. (damarco)]

Ich wollte es gerade hinschreiben ;) Im 32 bit Mode werden zwei TC 
gepaart. Gezählt wird von TC0 -> gerade Master -> ungerade Slave. Der 
Clock wird auch so im PM aktiviert. Du wolltest den TC 3 als Master 
Konfigurieren das geht nicht im 32bit Mode.

Nicht unwichtig

The following registers need synchronization when read:
  Control B Clear register (CTRLBCLR)
  Control B Set register (CTRLBSET)
  Control C register (CTRLC)
  Count Value register (COUNT)
  Period Value register (PERIOD)
  Compare/Capture Value registers (CCx)

Read-synchronization is denoted by the Read-Synchronized property in the 
register description.

[chris_ (Gast)]

>Nicht unwichtig
>The following registers need synchronization when read:

Das heißt dann für jedes dieser Register eine Zeile dieser Art:

  while (TC2->COUNT32.STATUS.bit.SYNCBUSY) {} // wait for setup

oder?

[Jörg W. (dl8dtl) (Moderator)]

chris_ schrieb:
> Du hast TC3 als counter verwendet. Das scheinen einige so zu tun. Die
> Frage ist: Warum nicht bei TC0 beginnen?

Hing in diesem Falle mit der IO-Zuordnung für die waveform generation
ab.  Die Alternativfunktionen für die einzelnen IO-Pins sind ja nicht
beliebig frei wählbar.

chris_ schrieb:
>> The following registers need synchronization when read:
>
> Das heißt dann für jedes dieser Register eine Zeile dieser Art:

Ja.  Kann man auch in einem Makro schieben, dann sieht der Code
nicht ganz so „verwürgt“ aus.

[Marco H. (damarco)]

Ich bin noch was schuldig ;)

struct tc_module tc_instance;

void configure_tc(void){
  
  struct tc_config config_tc;
  tc_get_config_defaults(&config_tc);
  config_tc.clock_source=GCLK_GENERATOR_3;
  config_tc.clock_prescaler=TC_CLOCK_PRESCALER_DIV8;
  config_tc.counter_size=TC_COUNTER_SIZE_32BIT;
  config_tc.wave_generation=TC_WAVE_GENERATION_MATCH_FREQ_MODE;
  config_tc.pwm_channel[0].enabled=true;
  config_tc.pwm_channel[0].pin_out=PIN_PB08E_TC4_WO0;
  config_tc.pwm_channel[0].pin_mux=MUX_PB08E_TC4_WO0;
  
  tc_init(&tc_instance,TC4,&config_tc);
  tc_enable(&tc_instance);

  
}

Auslesen

uint32_t tc_get_count_value(const struct tc_module *const module_inst);

value = tc_get_count_value(&tc_instance);

Doch Vorsicht ! Bei mir schwingt der Generator 3 mit 8MHZ und dein 
gewählter Wave Mode hat bei CC 0xffffffff im 
TC_WAVE_GENERATION_NORMAL_FREQ keine Wirkung auf den WO[x]. Da der 
Ausgang beim Match und Top getoggelt wird.

Wichtig man muss zwischen TC und TCC unterscheiden. Sind zwar alles 
Timer aber mit unterschiedlichen Eigenschaften und Registern ! Beim 
SAMD21 gibt es nur 3 Timer dieser Art TC3,TC4,TC5.  Im 32Bit Mode werden 
zwei gepaart. Gerade-> Ungerade. Das geht nur mit TC4 !