ATtiny1624, Timer B läuft zu schnell ab

[Holger L. (symetron)]

Moin

Bisweilen etwas frustrierend, woran man(n) scheitert...

Ich möchte Timer/Interruptgesteuert eine LED im Sekundentakt blinken 
lassen. Also folgendes zu Papier gebracht:

#include <xc.h>
#include <avr/interrupt.h>

volatile uint32_t milli_ticks;

void led1on()... 
void led1off()...
 
ISR(TCB0_INT_vect) {
  milli_ticks++;
}

void main(void) {

  //Timer auf 20000 (bei 20MHz Takt -> 1 ms)
  TCB0.CCMPL = 0b00100000;
  TCB0.CCMPH = 0b01001110;
  //Enable Timer
  TCB0.CTRLA |= 1;
  //Enable Capture
  //DS: Bit 0 – CAPT Capture Interrupt Enable
  //    Writing this bit to ‘1’ enables interrupt on capture.
  TCB0.INTCTRL |= 1;

  sei();


  while (1) {
    //0-1000 an, 1001-2000 aus
    if (milli_ticks > 100000) {
      milli_ticks = 0;
    } else if (milli_ticks > 50000) {
      led1off();
    } else {
      led1on();
    }

  }
}

Jetzt war meine Idee, dass ich jeweils 1.000 1-ms-Ticks abwarte, und 
dann ist die Sekunde um. Tatsächlich muss ich etwa 50.000 Ticks warten.

Denk- oder Programmfehler?

Gruß
Holger


Auszug aus dem DS:

By default, the TCB is in Periodic Interrupt mode. Follow these steps to 
start using it:
* 1.Write a TOP value to the Compare/Capture (TCBn.CCMP) register.
* 2.Optional: Write the Compare/Capture Output Enable (CCMPEN) bit in 
the Control B (TCBn.CTRLB) register to
‘1’. This will make the waveform output available on the corresponding 
pin, overriding the value in the
corresponding PORT output register. The corresponding pin direction must 
be configured as an output in the
PORT peripheral.
* 3.Enable the counter by writing a ‘1’ to the ENABLE bit in the Control 
A (TCBn.CTRLA) register.
The counter will start counting clock ticks according to the prescaler 
setting in the Clock Select (CLKSEL) bit
field in the Control A (TCBn.CTRLA) register.
* 4.The counter value can be read from the Count (TCBn.CNT) register. 
The peripheral will generate a CAPT
interrupt and event when the CNT value reaches TOP.
* 4.1. If the Compare/Capture register is modified to a value lower than 
the current CNT, the peripheral will
count to MAX and wrap around.
* 4.2.At MAX, an OVF interrupt and event will be generated.

[Volker B. (Firma: L-E-A) (vobs)]

Holger L. schrieb:

> Denk- oder Programmfehler?

Ich sehe zwei Programmierfehler:
1. Dein Zugriff auf die 32-Bit-Zählervariable ist nicht atomic
2. Konstanten größer 2^15 sollten explizit als long definiert werden, 
also
   z.B. 50000ul

Grüßle,
Volker

[Εrnst B. (ernst)]

Ein Programmierfehler ist zumindest der nicht-atomare Zugriff auf 
"millis".

Besser:

uint32_t get_millis() {
  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
     return milli_ticks;
  }
}

und das konsequent zum Zugriff auf die millis-Variable verwenden.

Dann: die Variable durchlaufen lassen. Deine Timer dann so 
umformulieren:

static uint32_t last_action_millis;
if (get_millis() - last_action_millis > 5000) {
   do_something();
   last_action_millis = get_millis();
}

(Achtung, nicht "if (last_action_millis+5000 < get_millis()) {...".
Ließt sich ähnlich, ist was anderes)

[Oliver S. (oliverso)]

Holger L. schrieb:
> 1415  //Timer auf 20000 (bei 20MHz Takt -> 1 ms)
> 16  TCB0.CCMPL = 0b00100000;
> 17  TCB0.CCMPH = 0b01001110;

Nun ja. Mag ja das gewünschte sein, weiß aber niemand. Der Compiler kann 
aber tatsächlich mit 16-Bit Registern umgehen, du musstest ihm nur 
zutrauen.

Oliver

[S. L. (sldt)]

"CAPT Capture Interrupt Flag ... This bit is cleared by writing a ‘1’ to 
it or ..."

Fehlt - die ISR wird also wohl permanent aufgerufen.

Und CCMP sollte auf 20000-1 gesetzt werden.

[Holger L. (symetron)]

> "CAPT Capture Interrupt Flag ... This bit is cleared by writing a ‘1’ to
> it or ..."

Mööp. Das scheint mir die 90%-Antwort zu sein. Die restlichen 10% gehen 
an den atomic-Zugriff. Vielen Dank für die Hinweise.

Da hätte ich mir eine Zeile mehr der Datenblatt-Beschreibung gewünscht, 
wenn da schon explizit aufgeführt wird, wie man den periodischen 
Interrupt umsetzt.

Jetzt ist eine Sekunde ca. 200 Ticks lang. Müssten doch eigentlich so um 
die 1000 sein, +/- X Prozent. Andere Größenordnung, immmer noch 
unerwartet.

Ich hänge den Code nachmal an. Vielleicht können wir das auch noch 
aufklären.

[Volker B. (Firma: L-E-A) (vobs)]

Holger L. schrieb:

> Jetzt ist eine Sekunde ca. 200 Ticks lang. Müssten doch eigentlich so um
> die 1000 sein, +/- X Prozent. Andere Größenordnung, immmer noch
> unerwartet.

Vorteiler des Systemtakts auf 1 umgestellt? Dieser ist auf 6 
voreingestellt.

Grüßle,
Volker

[Holger L. (symetron)]

> Vorteiler des Systemtakts auf 1 umgestellt? Dieser ist auf 6
> voreingestellt.

Womit dann auch das letzte Rätsel gelöst wäre.

Jetzt kann ich meinem Söhnle stolz eine blinkende LED präsentieren, und 
mich damit aus dem Urschlamm zum Gott erheben...

[Peter D. (peda)]

S. L. schrieb:
> "CAPT Capture Interrupt Flag ... This bit is cleared by writing a ‘1’ to
> it or ..."
>
> Fehlt - die ISR wird also wohl permanent aufgerufen.

Im Unterschied zu den klassik Tiny/Mega muß bei den neuen Typen jedes 
Interruptflag der Timer händisch gelöscht werden.
Automatisches Löschen bei Eintritt in die ISR gibt es nicht mehr.
ISR_NOBLOCK ist somit verboten.

[S. L. (sldt)]

"With a few stupid exceptions of course" - ich hätte vollständig 
zitieren sollen:

This bit is cleared by writing a ‘1’ to it or when the Capture register 
is read in Capture mode.

[Peter D. (peda)]

S. L. schrieb:
> This bit is cleared by writing a ‘1’ to it or when the Capture register
> is read in Capture mode.

Mit "händisch löschen" meinte ich eine passende Codesequenz lt. 
Datenblatt innerhalb der ISR. Je nach Flag kann es mehrere Varianten 
dafür geben.

[S. L. (sldt)]

an Peter Dannegger:

Ich bezog mich auf
> Automatisches Löschen bei Eintritt in die ISR gibt es nicht mehr.

[Georg M. (g_m)]

Der Code sollte nicht länger sein als nötig.
Hier ist ein Beispiel:

#include <avr/io.h>

uint8_t cnt;                               // SW counter

int main(void)
{
  _PROTECTED_WRITE(CLKCTRL.MCLKCTRLB, CLKCTRL_PDIV_2X_gc | CLKCTRL_PEN_bm);  // 10 MHz Main Clock

  EVSYS.CHANNEL0 = EVSYS_CHANNEL0_TCB0_CAPT_gc;       // Event generator: TCB0 CAPT
  EVSYS.USERTCB1COUNT = EVSYS_USER_CHANNEL0_gc;       // Event user: TCB1 COUNT

  TCB0.CCMP = 0x1387;                                 // 1 kHz
  TCB0.CTRLA = TCB_CLKSEL_DIV2_gc | TCB_ENABLE_bm;    // CLK_PER/2, enable TCB0

  TCB1.CCMP = 0x0031;                                 // 20 Hz
  TCB1.CTRLA = TCB_CLKSEL_EVENT_gc | TCB_ENABLE_bm;   // select EVENT as clock, enable TCB1

  PORTB.DIRSET = PIN0_bm;                             // PB0 output (LED)

  while(1) 
  {
    if(TCB1.INTFLAGS)
    {
      TCB1.INTFLAGS = TCB_CAPT_bm;                    // clear TCB1 interrupt flag
      cnt++;
      if(cnt == 19)
      {
        PORTB.OUTSET = PIN0_bm;                       // LED ON        
      }
      else if(cnt == 20)
      {
        PORTB.OUTCLR = PIN0_bm;                       // LED OFF
        cnt = 0;   
      }
    }
  }
}