Timer aktivieren

[Gast (Gast)]

um irgend einen Timer zu aktivieren liest man oft, z.B. Timer0:

TCCR0 = (1<<CS00)|(1<<CS02);

müsste es abeer nicht so aussehen:

TCCR0 |= (1<<CS00)|(1<<CS02);

[Karl H. (kbuchegg)]

Sehr oft ist das Setzen des Vorteilers die erste Aktion, die
in diesem Steuerregister gemacht wird.
Dadurch dass man keine Oder Verknüpfung macht, hat man dann die
Gewissheit, dass die restlichen Bits in einer definierten Stellung
(nämlich 0) sind.

Aber im Prinzip hast du recht.
Will man nur den Timer Einschalten, dann ist es sicherer dies
so zu machen, dass nur die Vorteiler Bits verändert werden.
Wobei. Um es ganz exakt zu machen, müsste man es so machen:

  TCCR0 & = ~( 1 << CS01 );
  TCCR0 |=   ( 1 << CS00 ) | ( 1 << CS02 );

weil du ja mit einem | Bits nur setzen kannst.

Aber wie gesagt: Wenn das die erste Operation auf diesem Register
ist, spielt es in der Praxis keine wirkliche Rolle und man nimmt
die einfachere Variante.

[Johannes M. (johnny-m)]

Gast wrote:
> um irgend einen Timer zu aktivieren liest man oft, z.B. Timer0:
>

TCCR0 = (1<<CS00)|(1<<CS02);

> müsste es abeer nicht so aussehen:
>

TCCR0 |= (1<<CS00)|(1<<CS02);

Nö, das hängt ganz davon ab, was man machen will. Wenn man nur CS00 und 
CS02 setzen will und alle anderen Bits Null sein sollen, dann ist die 
erste Version völlig korrekt. Wenn man will, dass die anderen Bits 
unverändert bleiben, dann ist die zweite Variante angesagt. Außerdem 
muss beachtet werden, dass "|=" ausschließlich Bits setzt. Alle Bits, 
die vorher schon gesetzt sind, bleiben das auch.

[Gast (Gast)]

also lieber immer

 TCCR0 = (1<<CS00)|(1<<CS02);

verwenden um einen Timer oder ähnliches zu konfigurieren
(im Tutorial ist es ja auch mal so und mal so erklärt, hat mich dann ein 
wenig irritiert)
oder halt umständlicher

TCCR0 = 0x00;
TCCR0 |= (1<<CS00)|(1<<CS02);

[Falk B. (falk)]

@ Gast (Gast)

>oder halt umständlicher

>TCCR0 = 0x00;
>TCCR0 |= (1<<CS00)|(1<<CS02);

Das ist nicht umständlicher, das ist einfach Unsinn. Am Ende ist es doch 
recht einfach.

Zum Beginn des Programms werden die Register einmal komplett gesetzt

TCCR0 = (1<<CS00)|(1<<CS02);

Im laufenden Programm werden nur individuelle Bits angesprochen, um den 
Rest der Konfiguration nicht zu zerstören. Das gilt praktisch für alle 
Register.

TCCR0 |= (1<<CS00)|(1<<CS02);

Wobei man beim Wechsel des Vorteilers erstmal alle Bits löschen muss, 
da man ja nicht weiss, welche nun gesetzt sind

//                 alle Prescalerbits löschen      nur einzelne setzen
TCCR0 = TCCR0 & ~((1<<CS00)|(1<<CS01)|(1<<CS02)) | (1<<CS00)|(1<<CS02);
// oder so, besser lesbar,
// verwendet die Nummerierung der Prescalercodierung gemäss Datenblatt
//                clear         set
TCCR0 = TCCR0 & ~(7<<CS00) | (5<<CS00);

MFG
Falk

[Johannes M. (johnny-m)]

@Falk:
Dann bleib aber auch bei einer Schreibweise. Also anstatt

TCCR0 = TCCR0 & ~((1<<CS00)|(1<<CS01)|(1<<CS02)) | (1<<CS00)|(1<<CS02);

einfach

TCCR0 &= ~((1<<CS00)|(1<<CS01)|(1<<CS02)) | (1<<CS00)|(1<<CS02);

[Falk B. (falk)]

@ Johannes M. (johnny-m)

>Dann bleib aber auch bei einer Schreibweise. Also anstatt

>TCCR0 = TCCR0 & ~((1<<CS00)|(1<<CS01)|(1<<CS02)) | (1<<CS00)|(1<<CS02);

>einfach

>TCCR0 &= ~((1<<CS00)|(1<<CS01)|(1<<CS02)) | (1<<CS00)|(1<<CS02);

OHHHHH, VORSICHT. DAS geht schief! Was passiert, wenn CS02 in TCCR0 
vorher nicht gesetzt ist? :-0
Manchmal darf man nicht zuuuu tippfaul sein.

MFG
Falk

[Johannes M. (johnny-m)]

Falk Brunner wrote:
> OHHHHH, VORSICHT. DAS geht schief! Was passiert, wenn CS02 in TCCR0
> vorher nicht gesetzt ist? :-0
> Manchmal darf man nicht zuuuu tippfaul sein.
Ja, hab grad auch gesehen, dass in der Zeile hinten noch was steht... 
Ist natürlich korrekt. Ich hatte nicht gesehen, dass Du den Vorteiler in 
einem Rutsch umschalten (und nicht nur die CS-Bits löschen) wolltest, 
weshalb mir die Klammerung entgangen ist...

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

Falk Brunner wrote:

> Im laufenden Programm werden nur individuelle Bits angesprochen, um den
> Rest der Konfiguration nicht zu zerstören. Das gilt praktisch für alle
> Register.

Naja, wenn die Applikation hinreichend klein bzw. gut genug gekapselt
ist, dass es sowieso klar ist, welche Bits ggf. außer dem Vorteiler
da noch alles gesetzt sind, dann ist es einfacher (und schneller),
das Register komplett neu zu beschreiben, statt des umständlichen
read/modify/write-Codes.  Wenn man bspw. den Timer immer nur eine
Zeit lang laufen lassen möchte und danach wieder anhalten, ist es
völlig legitim, beim Anhalten einfach komplett 0 drauf zu schreiben
und beim nächsten Start dann wieder alle gewünschten Bits zu setzen.

[Falk B. (falk)]

@  Jörg Wunsch (dl8dtl)

>Naja, wenn die Applikation hinreichend klein bzw. gut genug gekapselt
>ist, dass es sowieso klar ist, welche Bits ggf. außer dem Vorteiler

Jaja, WENN. Aber die Erfahrung zeigt, dass selbst kleine Programme 
immer wieder gern komlexer werden als man denkt. Und die 
Wiederverwertbarkeit leidet auch. Im Übrigen spricht eben gerade 
Kapselung GEGEN das komplette Überschreiben.

MfG
Falk