Mikrocontroller.net - Benutzerbeiträge [de]

AVR-Tutorial: Uhr

2015-03-04T01:54:46Z

2001:A60:13D1:CB01:352D:6309:9D08:7E1F: /* Das erste Programm */

Eine beliebte Übung für jeden Programmierer ist die Implementierung einer Uhr. Die meisten Uhren bestehen aus einem Taktgeber und einer Auswerte- und Anzeigevorrichtung. Wir wollen hier beides mittels eines Programmes in einem Mikrocontroller realisieren. Voraussetzung für diese Fallstudie ist das Verständnis der Kapitel über

* [[AVR-Tutorial: LCD| Ansteuerung eines LC-Displays]]
* [[AVR-Tutorial: Timer| Timer]]

== Aufbau und Funktion ==

Die Aufgabe des Taktgebers, der uns einen möglichst konstanten und genauen Takt liefert, übernimmt ein Timer. Der Timer ermöglicht einen einfachen Zugang zum Takt, den der AVR vom Quarz abgreift. Wie schon im Einführungskapitel über den [[AVR-Tutorial:_Timer|Timer]] beschrieben, wird dazu ein Timer Overflow Interrupt installiert, und in diesem Interrupt wird die eigentliche Uhr hochgezählt. Die Uhr besteht aus vier Registern. Drei davon repräsentieren die Sekunden, Minuten und Stunden unserer Uhr. Nach jeweils einer Sekunde wird das Sekundenregister um eins erhöht. Sind 60 Sekunden vergangen, wird das Sekundenregister wieder auf Null gesetzt und gleichzeitig das Minutenregister um eins erhöht. Dies ist ein Überlauf. Nach 60 Minuten werden die Minuten wieder auf Null gesetzt und für diese vergangenen 60 Minuten eine Stunde aufaddiert. Nach 24 Stunden schliesslich werden die Stunden wieder auf Null gesetzt, ein ganzer Tag ist vergangen.

Aber wozu das vierte Register?

Der Mikrocontroller wird mit 4 MHz betrieben. Bei einem Teiler von 1024 zählt der Timer also mit 4000000 / 1024 = 3906,25 Pulsen pro Sekunde. Der Timer muss einmal bis 256 zählen, bis er einen Überlauf auslöst. Es ereignen sich also 3906,25 / 256 = 15,2587 Überläufe pro Sekunde. Die Aufgabe des vierten Registers ist es nun, diese 15 Überläufe zu zählen. Bei Auftreten des 15. ist eine Sekunde vergangen. Dies stimmt jedoch nicht exakt, denn die Division weist ja auch Nachkommastellen auf, hat einen Rest, der hier im Moment der Einfachheit halber ignoriert wird. In einem späteren Abschnitt wird darauf noch eingegangen werden.

Im Überlauf-Interrupt wird also diese Kette von Zählvorgängen auf den Sekunden, Minuten und Stunden durchgeführt und anschliessend zur Anzeige gebracht. Dazu werden die in einem vorhergehenden Kapitel entwickelten [[AVR-Tutorial:_LCD|LCD Funktionen]] benutzt.

== Das erste Programm ==

<syntaxhighlight lang="avrasm">
.include "m8def.inc"

.def temp1 = r16
.def temp2 = r17
.def temp3 = r18
.def flag = r19

.def SubCount = r21
.def Sekunden = r22
.def Minuten = r23
.def Stunden = r24

.org 0x0000
rjmp main ; Reset Handler
.org OVF0addr
rjmp timer0_overflow ; Timer Overflow Handler

.include "lcd-routines.asm"

main:
ldi temp1, HIGH(RAMEND)
out SPH, temp1
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1

ldi temp1, 0xFF ; Port D = Ausgang
out DDRD, temp1

rcall lcd_init
rcall lcd_clear

ldi temp1, (1<<CS02) | (1<<CS00) ; Teiler 1024
out TCCR0, temp1

ldi temp1, 1<<TOIE0 ; TOIE0: Interrupt bei Timer Overflow
out TIMSK, temp1

clr Minuten ; Die Uhr auf 0 setzen
clr Sekunden
clr Stunden
clr SubCount
clr Flag ; Merker löschen

sei

loop:
cpi flag,0
breq loop ; Flag im Interrupt gesetzt?
ldi flag,0 ; flag löschen

rcall lcd_clear ; das LCD löschen
mov temp1, Stunden ; und die Stunden ausgeben
rcall lcd_number
ldi temp1, ':' ; zwischen Stunden und Minuten einen ':'
rcall lcd_data
mov temp1, Minuten ; dann die Minuten ausgeben
rcall lcd_number
ldi temp1, ':' ; und noch ein ':'
rcall lcd_data
mov temp1, Sekunden ; und die Sekunden
rcall lcd_number

rjmp loop

timer0_overflow: ; Timer 0 Overflow Handler

push temp1 ; temp 1 sichern
in temp1,sreg ; SREG sichern
push temp1

inc SubCount ; Wenn dies nicht der 15. Interrupt
cpi SubCount, 15 ; ist, dann passiert gar nichts
brne end_isr

; Überlauf
clr SubCount ; SubCount rücksetzen
inc Sekunden ; plus 1 Sekunde
cpi Sekunden, 60 ; sind 60 Sekunden vergangen?
brne Ausgabe ; wenn nicht kann die Ausgabe schon
; gemacht werden

; Überlauf
clr Sekunden ; Sekunden wieder auf 0 und dafür
inc Minuten ; plus 1 Minute
cpi Minuten, 60 ; sind 60 Minuten vergangen ?
brne Ausgabe ; wenn nicht, -> Ausgabe

; Überlauf
clr Minuten ; Minuten zurücksetzen und dafür
inc Stunden ; plus 1 Stunde
cpi Stunden, 24 ; nach 24 Stunden, die Stundenanzeige
brne Ausgabe ; wieder zurücksetzen

; Überlauf
clr Stunden ; Stunden rücksetzen

Ausgabe:
ldi flag,1 ; Flag setzen, LCD updaten

end_isr:

pop temp1
out sreg,temp1 ; sreg wieder herstellen
pop temp1
reti ; das wars. Interrupt ist fertig

; Eine Zahl aus dem Register temp1 ausgeben

lcd_number:
push temp2 ; register sichern,
; wird für Zwsichenergebnisse gebraucht
ldi temp2, '0'
lcd_number_10:
subi temp1, 10 ; abzählen wieviele Zehner in
brcs lcd_number_1 ; der Zahl enthalten sind
inc temp2
rjmp lcd_number_10
lcd_number_1:
push temp1 ; den Rest sichern (http://www.mikrocontroller.net/topic/172026)
mov temp1,temp2 ;
rcall lcd_data ; die Zehnerstelle ausgeben
pop temp1 ; den Rest wiederherstellen
subi temp1, -10 ; 10 wieder dazuzählen, da die
; vorhergehende Schleife 10 zuviel
; abgezogen hat
; das Subtrahieren von -10
; = Addition von +10 ist ein Trick
; da kein addi Befehl existiert
ldi temp2, '0' ; die übrig gebliebenen Einer
add temp1, temp2 ; noch ausgeben
rcall lcd_data

pop temp2 ; Register wieder herstellen
ret
</syntaxhighlight>

In der ISR wird nur die Zeit in den Registern neu berechnet, die Ausgabe auf das LCD erfolgt in der Hauptschleife. Das ist notwendig, da die LCD-Ausgabe bisweilen sehr lange dauern kann. Wenn sie länger als ~2/15 Sekunden dauert werden Timerinterrupts "verschluckt" und unsere Uhr geht noch mehr falsch. Dadurch, dass aber die Ausgabe in der Hauptschleife durchgeführt wird, welche jederzeit durch einen Timerinterrupt unterbrochen werden kann, werden keine Timerinterrupts verschluckt. Das ist vor allem wichtig, wenn mit höheren Interruptfrequenzen gearbeitet wird, z. B. 1/100s im Beispiel weiter unten. Auch wenn in diesem einfachen Beispiel die Ausgabe bei weitem nicht 2/15 Sekunden dauert, sollte man sich diesen Programmierstil allgemein angewöhnen. Siehe auch [[Interrupt]].

Eine weitere Besonderheit ist das Register '''flag''' (=r19). Dieses Register fungiert als Anzeiger, wie eine Flagge, daher auch der Name. In der ISR wird dieses Register auf 1 gesetzt. Die Hauptschleife, also alles zwischen ''loop'' und ''rjmp loop'', prüft dieses Flag und nur dann, wenn das Flag auf 1 steht, wird die LCD Ausgabe gemacht und das Flag wieder auf 0 zurückgesetzt. Auf diese Art wird nur dann Rechenzeit für die LCD Ausgabe verbraucht, wenn dies tatsächlich notwendig ist. Die ISR teilt mit dem Flag der Hauptschleife mit, dass eine bestimmte Aufgabe, nämlich der Update der Anzeige gemacht werden muss und die Hauptschleife reagiert darauf bei nächster Gelegenheit, indem sie diese Aufgabe ausführt und setzt das Flag zurück. Solche Flags werden daher auch '''Job-Flags''' genannt, weil durch ihr setzten das Abarbeiten eines Jobs (einer Aufgabe) angestoßen wird. Auch hier gilt wieder: Im Grunde würde man in diesem speziellen Beispiel kein Job-Flag benötigen, weil es in der Hauptschleife nur einen einzigen möglichen Job, die Neuausgabe der Uhrzeit, gibt. Sobald aber Programme komplizierter werden und mehrere Jobs möglich sind, sind Job-Flags eine gute Möglichkeit, ein Programm so zu organsieren, dass bestimmte Dinge nur dann gemacht werden, wenn sie notwendig sind.

Im Moment gibt es keine Möglichkeit, die Uhr auf eine bestimmte Uhrzeit einzustellen. Um dies tun zu können, müssten noch zusätzlich Taster an den Mikrocontroller angeschlossen werden, mit deren Hilfe die Sekunden, Minuten und Stunden händisch vergrößert bzw. verkleinert werden können. Studieren Sie mal die Bedienungsanleitung einer käuflichen Digitaluhr und versuchen sie zu beschreiben, wie dieser Stellvorgang bei dieser Uhr vor sich geht. Sicherlich werden Sie daraus eine Idee entwickeln können, wie ein derartiges Stellen mit der hier vorgestellten Digitaluhr funktionieren könnte. Als Zwischenlösung kann man im Programm die Uhr beim Start anstelle von 00:00:00 z. B. auch auf 20:00:00 stellen und exakt mit dem Start der Tagesschau starten. Wobei der Start der Tagesschau verzögert bei uns ankommt, je nach Übertragung können das mehrere Sekunden sein.

== Ganggenauigkeit ==

Wird die Uhr mit einer gekauften Uhr verglichen, so stellt man schnell fest, dass sie ganz schön ungenau geht. Sie geht vor! Woran liegt das? Die Berechnung sieht so aus:
* Frequenz des Quarzes: 4.0 MHz
* Vorteiler des Timers: 1024
* Überlauf alle 256 Timertakte

Daraus errechnet sich, dass in einer Sekunde 4000000 / 1024 / 256 = 15.258789 Overflow Interrupts auftreten. Im Programm wird aber bereits nach 15 Overflows eine Sekunde weitergeschaltet, daher geht die Uhr vor. Rechnen wir etwas:

:<math>F_r = (\frac {15}{15,258789}-1) \cdot 100% = -1,69%</math>

So wie bisher läuft die Uhr also rund 1.7 % zu schnell. In einer Minute ist das immerhin etwas mehr als eine Sekunde. Im Grunde ist das ein ähnliches Problem wie mit unserer Jahreslänge. Ein Jahr dauert nicht exakt 365 Tage, sondern in etwa einen viertel Tag länger. Die Lösung, die im Kalender dafür gemacht wurde - der Schalttag -, könnte man fast direkt übernehmen. Nach 3 Stück 15er Overflow Sekunden folgt eine Sekunde für die 16 Overflows ablaufen müssen. Wie sieht die Rechnung bei einem 15, 15, 15, 16 Schema aus? Für 4 Sekunden werden exakt 15.258789 * 4 = 61,035156 Overflow Interrupts benötigt. Mit einem 15, 15, 15, 16 Schema werden in 4 Sekunden genau 61 Overflow Interrupts durchgeführt. Der relative Fehler beträgt dann

:<math>F_r = (\frac {61}{61,035156}-1) \cdot 100% = -0,0575%</math>

Mit diesem Schema ist der Fehler beträchtlich gesunken. Nur noch 0.06%. Bei dieser Rate muss die Uhr immerhin etwas länger als 0,5 Stunden laufen, bis der Fehler auf eine Sekunde angewachsen ist. Das sind aber immer noch 48 Sekunden pro Tag bzw. 1488 Sekunden (=24,8 Minuten) pro Monat. So schlecht sind nicht mal billige mechanische Uhren!

Jetzt könnte man natürlich noch weiter gehen und immer kompliziertere "Schalt-Overflow"-Schemata austüfteln und damit die Genauigkeit näher an 100% bringen. Aber gibt es noch andere Möglichkeiten?

Im ersten Ansatz wurde ein Vorteiler von 1024 eingesetzt. Was passiert bei einem anderen Vorteiler? Nehmen wir mal einen Vorteiler von 64. Das heißt, es müssen ( 4000000 / 64 ) / 256 = 244.140625 Overflows auflaufen, bis 1 Sekunde vergangen ist. Wenn also 244 Overflows gezählt werden, dann beläuft sich der Fehler auf

:<math>F_r = (\frac {244}{244,140625}-1) \cdot 100% = -0,0576%</math>

Nicht schlecht. Nur durch Verändern von 2 Zahlenwerten im Programm (Teilerfaktor und Anzahl der Overflow Interrupts bis zu einer Sekunden) kann die Genauigkeit gegenüber dem ursprünglichen Overflow-Schema beträchtlich gesteigert werden. Aber geht das noch besser? Ja das geht. Allerdings nicht mit dem Overflow Interrupt.

== Der CTC-Modus des Timers ==

Worin liegt denn das eigentliche Problem, mit dem die Uhr zu kämpfen hat? Das Problem liegt darin, dass jedesmal ein kompletter Timerzyklus bis zum Overflow abgewartet werden muss, um darauf zu reagieren. Da aber nur jeweils ganzzahlige Overflowzyklen abgezählt werden können, heißt das auch, dass im ersten Fall nur in Vielfachen von 1024 * 256 = 262144 Takten operiert werden kann, während im letzten Fall immerhin schon eine Granulierung von 64 * 256 = 16384 Takten erreicht wird. Aber offensichtlich ist das nicht genau genug. Bei 4 MHz entsprechen 262144 Takte bereits einem Zeitraum von 65,5ms, während 16384 Takte einem Zeitbedarf von 4,096ms entsprechen. Beide Zahlen teilen aber 1000ms nicht ganzzahlig. Und daraus entsteht der Fehler. Angestrebt wird ein Timer, der seinen Overflow so erreicht, dass sich ein ganzzahliger Teiler von 1 Sekunde einstellt. Dazu müsste man dem Timer aber vorschreiben können, bei welchem Zählerstand der Overflow erfolgen soll. Und genau dies ist im '''CTC'''-Modus, allerdings nur beim Timer 1, möglich. '''CTC''' bedeutet "'''C'''lear '''T'''imer on '''C'''ompare match".

Timer 1, ein 16-Bit-Timer, wird mit einem Vorteiler von 1 betrieben. Dadurch wird erreicht, dass der Timer mit höchster Zeitauflösung arbeiten kann. Bei jedem Ticken des Systemtaktes von 4 MHz wird auch der Timer um 1 erhöht. Zusätzlich wird noch das WGM12-Bit bei der Konfiguration gesetzt. Dadurch wird der Timer in den '''CTC'''-Modus gesetzt. Dabei wird der Inhalt des Timers hardwaremäßig mit dem Inhalt des '''OCR1A'''-Registers verglichen. Stimmen beide überein, so wird der Timer auf 0 zurückgesetzt und im nächsten Taktzyklus ein '''OCIE1A'''-Interrupt ausgelöst. Dadurch ist es möglich, exakt die Anzahl an Taktzyklen festzulegen, die von einem Interrupt zum nächsten vergehen sollen. Das Compare Register '''OCR1A''' wird mit dem Wert 39999 vorbelegt. Dadurch vergehen exakt 40000 Taktzyklen von einem Compare-Interrupt zum nächsten. "Zufällig" ist dieser Wert so gewählt, dass bei einem Systemtakt von 4 MHz von einem Interrupt zum nächsten genau 1/100 Sekunde vergeht, denn 40000 / 4000000 = 0.01. Bei einem möglichen Umbau der Uhr zu einer Stoppuhr könnte sich das als nützlich erweisen. Im Interrupt wird das Hilfsregister SubCount bis 100 hochgezählt und nach 100 Interrupts kommt wieder die Sekundenweiterschaltung wie oben in Gang.

<syntaxhighlight lang="avrasm">
.include "m8def.inc"

.def temp1 = r16
.def temp2 = r17
.def temp3 = r18
.def Flag = r19

.def SubCount = r21
.def Sekunden = r22
.def Minuten = r23
.def Stunden = r24

.org 0x0000
rjmp main ; Reset Handler
.org OC1Aaddr
rjmp timer1_compare ; Timer Compare Handler

.include "lcd-routines.asm"

main:
ldi temp1, HIGH(RAMEND)
out SPH, temp1
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1

ldi temp1, 0xFF ; Port D = Ausgang
out DDRD, temp1

rcall lcd_init
rcall lcd_clear

; Vergleichswert
ldi temp1, high( 40000 - 1 )
out OCR1AH, temp1
ldi temp1, low( 40000 - 1 )
out OCR1AL, temp1
; CTC Modus einschalten
; Vorteiler auf 1
ldi temp1, ( 1 << WGM12 ) | ( 1 << CS10 )
out TCCR1B, temp1

ldi temp1, 1 << OCIE1A ; OCIE1A: Interrupt bei Timer Compare
out TIMSK, temp1

clr Minuten ; Die Uhr auf 0 setzen
clr Sekunden
clr Stunden
clr SubCount
clr Flag ; Flag löschen

sei
loop:
cpi flag,0
breq loop ; Flag im Interrupt gesetzt?
ldi flag,0 ; Flag löschen

rcall lcd_clear ; das LCD löschen
mov temp1, Stunden ; und die Stunden ausgeben
rcall lcd_number
ldi temp1, ':' ; zwischen Stunden und Minuten einen ':'
rcall lcd_data
mov temp1, Minuten ; dann die Minuten ausgeben
rcall lcd_number
ldi temp1, ':' ; und noch ein ':'
rcall lcd_data
mov temp1, Sekunden ; und die Sekunden
rcall lcd_number

rjmp loop

timer1_compare: ; Timer 1 Output Compare Handler

push temp1 ; temp 1 sichern
in temp1,sreg ; SREG sichern

inc SubCount ; Wenn dies nicht der 100. Interrupt
cpi SubCount, 100 ; ist, dann passiert gar nichts
brne end_isr

; Überlauf
clr SubCount ; SubCount rücksetzen
inc Sekunden ; plus 1 Sekunde
cpi Sekunden, 60 ; sind 60 Sekunden vergangen?
brne Ausgabe ; wenn nicht kann die Ausgabe schon
; gemacht werden

; Überlauf
clr Sekunden ; Sekunden wieder auf 0 und dafür
inc Minuten ; plus 1 Minute
cpi Minuten, 60 ; sind 60 Minuten vergangen ?
brne Ausgabe ; wenn nicht, -> Ausgabe

; Überlauf
clr Minuten ; Minuten zurücksetzen und dafür
inc Stunden ; plus 1 Stunde
cpi Stunden, 24 ; nach 24 Stunden, die Stundenanzeige
brne Ausgabe ; wieder zurücksetzen

; Überlauf
clr Stunden ; Stunden rücksetzen

Ausgabe:
ldi flag,1 ; Flag setzen, LCD updaten

end_isr:

out sreg,temp1 ; sreg wieder herstellen
pop temp1
reti ; das wars. Interrupt ist fertig

; Eine Zahl aus dem Register temp1 ausgeben

lcd_number:
push temp2 ; register sichern,
; wird für Zwsichenergebnisse gebraucht
ldi temp2, '0'
lcd_number_10:
subi temp1, 10 ; abzählen wieviele Zehner in
brcs lcd_number_1 ; der Zahl enthalten sind
inc temp2
rjmp lcd_number_10
lcd_number_1:
push temp1 ; den Rest sichern (http://www.mikrocontroller.net/topic/172026)
mov temp1,temp2 ;
rcall lcd_data ; die Zehnerstelle ausgeben
pop temp1 ; den Rest wieder holen
subi temp1, -10 ; 10 wieder dazuzählen, da die
; vorhergehende Schleife 10 zuviel
; abgezogen hat
; das Subtrahieren von -10
; = Addition von +10 ist ein Trick
; da kein addi Befehl existiert
ldi temp2, '0' ; die übrig gebliebenen Einer
add temp1, temp2 ; noch ausgeben
rcall lcd_data

pop temp2 ; Register wieder herstellen
ret
</syntaxhighlight>

In der Interrupt-Routine werden wieder, genauso wie vorher, die Anzahl der Interrupt-Aufrufe gezählt. Beim 100. Aufruf sind daher 40.000 * 100 = 4.000.000 Takte vergangen und da der Quarz mit 4.000.000 Schwingungen in der Sekunde arbeitet, ist daher eine Sekunde vergangen. Sie wird genauso wie vorher registriert und die Uhr entsprechend hochgezählt. Wird jetzt die Uhr mit einer kommerziellen verglichen, dann fällt nach einiger Zeit auf ... Sie geht immer noch falsch! Was ist jetzt die Ursache? Die Ursache liegt in einem Problem, das nicht direkt behebbar ist. Am Quarz! Auch wenn auf dem Quarz drauf steht, dass er eine Frequenz von 4MHz hat, so stimmt das nicht exakt. Auch Quarze haben Fertigungstoleranzen und verändern ihre Frequenz mit der Temperatur. Typisch liegt die Fertigungstoleranz bei +/- 100ppm = 0,01% ('''p'''arts '''p'''er '''m'''illion, Millionstel Teile), die Temperaturdrift zwischen -40 Grad und 85 Grad liegt je nach Typ in der selben Größenordnung. Das bedeutet, dass die Uhr pro Monat um bis zu 268 Sekunden (~4 1/2 Minuten) falsch gehen kann. Diese Einflüsse auf die Quarzfrequenz sind aber messbar und per Hardware oder Software behebbar. In Uhren kommen normalerweise genauer gefertigte Uhrenquarze zum Einsatz, die vom Uhrmacher auch noch auf die exakte Frequenz abgeglichen werden (mittels Kondensatoren und Frequenzzähler). Ein Profi verwendet einen sehr genauen Frequenzzähler, womit er innerhalb weniger Sekunden die Frequenz sehr genau messen kann. Als Hobbybastler kann man die Uhr eine zeitlang (Tage, Wochen) laufen lassen und die Abweichung feststellen (z. B. exakt 20:00 Uhr zum Start der Tagsschau). Aus dieser Abweichung lässt sich dann errechnen, wie schnell der Quarz wirklich schwingt. Und da dank CTC die Messperiode taktgenau eingestellt werden kann, ist es möglich, diesen Frequenzfehler auszugleichen. Der genaue Vorgang ist in dem Wikiartikel [[AVR - Die genaue Sekunde / RTC]] beschrieben.

----

{{Navigation_zurückhochvor|
zurücktext=Timer|
zurücklink=AVR-Tutorial: Timer|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=ADC|
vorlink=AVR-Tutorial: ADC}}

[[Category:AVR-Tutorial|Uhr]]
[[Category:Timer und Uhren]]

AVR-Tutorial: Uhr

2015-03-04T01:53:59Z

2001:A60:13D1:CB01:352D:6309:9D08:7E1F: /* Der CTC-Modus des Timers */

Eine beliebte Übung für jeden Programmierer ist die Implementierung einer Uhr. Die meisten Uhren bestehen aus einem Taktgeber und einer Auswerte- und Anzeigevorrichtung. Wir wollen hier beides mittels eines Programmes in einem Mikrocontroller realisieren. Voraussetzung für diese Fallstudie ist das Verständnis der Kapitel über

* [[AVR-Tutorial: LCD| Ansteuerung eines LC-Displays]]
* [[AVR-Tutorial: Timer| Timer]]

== Aufbau und Funktion ==

Die Aufgabe des Taktgebers, der uns einen möglichst konstanten und genauen Takt liefert, übernimmt ein Timer. Der Timer ermöglicht einen einfachen Zugang zum Takt, den der AVR vom Quarz abgreift. Wie schon im Einführungskapitel über den [[AVR-Tutorial:_Timer|Timer]] beschrieben, wird dazu ein Timer Overflow Interrupt installiert, und in diesem Interrupt wird die eigentliche Uhr hochgezählt. Die Uhr besteht aus vier Registern. Drei davon repräsentieren die Sekunden, Minuten und Stunden unserer Uhr. Nach jeweils einer Sekunde wird das Sekundenregister um eins erhöht. Sind 60 Sekunden vergangen, wird das Sekundenregister wieder auf Null gesetzt und gleichzeitig das Minutenregister um eins erhöht. Dies ist ein Überlauf. Nach 60 Minuten werden die Minuten wieder auf Null gesetzt und für diese vergangenen 60 Minuten eine Stunde aufaddiert. Nach 24 Stunden schliesslich werden die Stunden wieder auf Null gesetzt, ein ganzer Tag ist vergangen.

Aber wozu das vierte Register?

Der Mikrocontroller wird mit 4 MHz betrieben. Bei einem Teiler von 1024 zählt der Timer also mit 4000000 / 1024 = 3906,25 Pulsen pro Sekunde. Der Timer muss einmal bis 256 zählen, bis er einen Überlauf auslöst. Es ereignen sich also 3906,25 / 256 = 15,2587 Überläufe pro Sekunde. Die Aufgabe des vierten Registers ist es nun, diese 15 Überläufe zu zählen. Bei Auftreten des 15. ist eine Sekunde vergangen. Dies stimmt jedoch nicht exakt, denn die Division weist ja auch Nachkommastellen auf, hat einen Rest, der hier im Moment der Einfachheit halber ignoriert wird. In einem späteren Abschnitt wird darauf noch eingegangen werden.

Im Überlauf-Interrupt wird also diese Kette von Zählvorgängen auf den Sekunden, Minuten und Stunden durchgeführt und anschliessend zur Anzeige gebracht. Dazu werden die in einem vorhergehenden Kapitel entwickelten [[AVR-Tutorial:_LCD|LCD Funktionen]] benutzt.

== Das erste Programm ==

<syntaxhighlight lang="avrasm">
.include "m8def.inc"

.def temp1 = r16
.def temp2 = r17
.def temp3 = r18
.def flag = r19

.def SubCount = r21
.def Sekunden = r22
.def Minuten = r23
.def Stunden = r24

.org 0x0000
rjmp main ; Reset Handler
.org OVF0addr
rjmp timer0_overflow ; Timer Overflow Handler

.include "lcd-routines.asm"

main:
ldi temp1, HIGH(RAMEND)
out SPH, temp1
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1

rcall lcd_init
rcall lcd_clear

ldi temp1, (1<<CS02) | (1<<CS00) ; Teiler 1024
out TCCR0, temp1

ldi temp1, 1<<TOIE0 ; TOIE0: Interrupt bei Timer Overflow
out TIMSK, temp1

clr Minuten ; Die Uhr auf 0 setzen
clr Sekunden
clr Stunden
clr SubCount
clr Flag ; Merker löschen

sei

loop:
cpi flag,0
breq loop ; Flag im Interrupt gesetzt?
ldi flag,0 ; flag löschen

rcall lcd_clear ; das LCD löschen
mov temp1, Stunden ; und die Stunden ausgeben
rcall lcd_number
ldi temp1, ':' ; zwischen Stunden und Minuten einen ':'
rcall lcd_data
mov temp1, Minuten ; dann die Minuten ausgeben
rcall lcd_number
ldi temp1, ':' ; und noch ein ':'
rcall lcd_data
mov temp1, Sekunden ; und die Sekunden
rcall lcd_number

rjmp loop

timer0_overflow: ; Timer 0 Overflow Handler

push temp1 ; temp 1 sichern
in temp1,sreg ; SREG sichern
push temp1

inc SubCount ; Wenn dies nicht der 15. Interrupt
cpi SubCount, 15 ; ist, dann passiert gar nichts
brne end_isr

; Überlauf
clr SubCount ; SubCount rücksetzen
inc Sekunden ; plus 1 Sekunde
cpi Sekunden, 60 ; sind 60 Sekunden vergangen?
brne Ausgabe ; wenn nicht kann die Ausgabe schon
; gemacht werden

; Überlauf
clr Sekunden ; Sekunden wieder auf 0 und dafür
inc Minuten ; plus 1 Minute
cpi Minuten, 60 ; sind 60 Minuten vergangen ?
brne Ausgabe ; wenn nicht, -> Ausgabe

; Überlauf
clr Minuten ; Minuten zurücksetzen und dafür
inc Stunden ; plus 1 Stunde
cpi Stunden, 24 ; nach 24 Stunden, die Stundenanzeige
brne Ausgabe ; wieder zurücksetzen

; Überlauf
clr Stunden ; Stunden rücksetzen

Ausgabe:
ldi flag,1 ; Flag setzen, LCD updaten

end_isr:

pop temp1
out sreg,temp1 ; sreg wieder herstellen
pop temp1
reti ; das wars. Interrupt ist fertig

; Eine Zahl aus dem Register temp1 ausgeben

lcd_number:
push temp2 ; register sichern,
; wird für Zwsichenergebnisse gebraucht
ldi temp2, '0'
lcd_number_10:
subi temp1, 10 ; abzählen wieviele Zehner in
brcs lcd_number_1 ; der Zahl enthalten sind
inc temp2
rjmp lcd_number_10
lcd_number_1:
push temp1 ; den Rest sichern (http://www.mikrocontroller.net/topic/172026)
mov temp1,temp2 ;
rcall lcd_data ; die Zehnerstelle ausgeben
pop temp1 ; den Rest wiederherstellen
subi temp1, -10 ; 10 wieder dazuzählen, da die
; vorhergehende Schleife 10 zuviel
; abgezogen hat
; das Subtrahieren von -10
; = Addition von +10 ist ein Trick
; da kein addi Befehl existiert
ldi temp2, '0' ; die übrig gebliebenen Einer
add temp1, temp2 ; noch ausgeben
rcall lcd_data

pop temp2 ; Register wieder herstellen
ret
</syntaxhighlight>

In der ISR wird nur die Zeit in den Registern neu berechnet, die Ausgabe auf das LCD erfolgt in der Hauptschleife. Das ist notwendig, da die LCD-Ausgabe bisweilen sehr lange dauern kann. Wenn sie länger als ~2/15 Sekunden dauert werden Timerinterrupts "verschluckt" und unsere Uhr geht noch mehr falsch. Dadurch, dass aber die Ausgabe in der Hauptschleife durchgeführt wird, welche jederzeit durch einen Timerinterrupt unterbrochen werden kann, werden keine Timerinterrupts verschluckt. Das ist vor allem wichtig, wenn mit höheren Interruptfrequenzen gearbeitet wird, z. B. 1/100s im Beispiel weiter unten. Auch wenn in diesem einfachen Beispiel die Ausgabe bei weitem nicht 2/15 Sekunden dauert, sollte man sich diesen Programmierstil allgemein angewöhnen. Siehe auch [[Interrupt]].

Eine weitere Besonderheit ist das Register '''flag''' (=r19). Dieses Register fungiert als Anzeiger, wie eine Flagge, daher auch der Name. In der ISR wird dieses Register auf 1 gesetzt. Die Hauptschleife, also alles zwischen ''loop'' und ''rjmp loop'', prüft dieses Flag und nur dann, wenn das Flag auf 1 steht, wird die LCD Ausgabe gemacht und das Flag wieder auf 0 zurückgesetzt. Auf diese Art wird nur dann Rechenzeit für die LCD Ausgabe verbraucht, wenn dies tatsächlich notwendig ist. Die ISR teilt mit dem Flag der Hauptschleife mit, dass eine bestimmte Aufgabe, nämlich der Update der Anzeige gemacht werden muss und die Hauptschleife reagiert darauf bei nächster Gelegenheit, indem sie diese Aufgabe ausführt und setzt das Flag zurück. Solche Flags werden daher auch '''Job-Flags''' genannt, weil durch ihr setzten das Abarbeiten eines Jobs (einer Aufgabe) angestoßen wird. Auch hier gilt wieder: Im Grunde würde man in diesem speziellen Beispiel kein Job-Flag benötigen, weil es in der Hauptschleife nur einen einzigen möglichen Job, die Neuausgabe der Uhrzeit, gibt. Sobald aber Programme komplizierter werden und mehrere Jobs möglich sind, sind Job-Flags eine gute Möglichkeit, ein Programm so zu organsieren, dass bestimmte Dinge nur dann gemacht werden, wenn sie notwendig sind.

Im Moment gibt es keine Möglichkeit, die Uhr auf eine bestimmte Uhrzeit einzustellen. Um dies tun zu können, müssten noch zusätzlich Taster an den Mikrocontroller angeschlossen werden, mit deren Hilfe die Sekunden, Minuten und Stunden händisch vergrößert bzw. verkleinert werden können. Studieren Sie mal die Bedienungsanleitung einer käuflichen Digitaluhr und versuchen sie zu beschreiben, wie dieser Stellvorgang bei dieser Uhr vor sich geht. Sicherlich werden Sie daraus eine Idee entwickeln können, wie ein derartiges Stellen mit der hier vorgestellten Digitaluhr funktionieren könnte. Als Zwischenlösung kann man im Programm die Uhr beim Start anstelle von 00:00:00 z. B. auch auf 20:00:00 stellen und exakt mit dem Start der Tagesschau starten. Wobei der Start der Tagesschau verzögert bei uns ankommt, je nach Übertragung können das mehrere Sekunden sein.

== Ganggenauigkeit ==

Wird die Uhr mit einer gekauften Uhr verglichen, so stellt man schnell fest, dass sie ganz schön ungenau geht. Sie geht vor! Woran liegt das? Die Berechnung sieht so aus:
* Frequenz des Quarzes: 4.0 MHz
* Vorteiler des Timers: 1024
* Überlauf alle 256 Timertakte

Daraus errechnet sich, dass in einer Sekunde 4000000 / 1024 / 256 = 15.258789 Overflow Interrupts auftreten. Im Programm wird aber bereits nach 15 Overflows eine Sekunde weitergeschaltet, daher geht die Uhr vor. Rechnen wir etwas:

:<math>F_r = (\frac {15}{15,258789}-1) \cdot 100% = -1,69%</math>

So wie bisher läuft die Uhr also rund 1.7 % zu schnell. In einer Minute ist das immerhin etwas mehr als eine Sekunde. Im Grunde ist das ein ähnliches Problem wie mit unserer Jahreslänge. Ein Jahr dauert nicht exakt 365 Tage, sondern in etwa einen viertel Tag länger. Die Lösung, die im Kalender dafür gemacht wurde - der Schalttag -, könnte man fast direkt übernehmen. Nach 3 Stück 15er Overflow Sekunden folgt eine Sekunde für die 16 Overflows ablaufen müssen. Wie sieht die Rechnung bei einem 15, 15, 15, 16 Schema aus? Für 4 Sekunden werden exakt 15.258789 * 4 = 61,035156 Overflow Interrupts benötigt. Mit einem 15, 15, 15, 16 Schema werden in 4 Sekunden genau 61 Overflow Interrupts durchgeführt. Der relative Fehler beträgt dann

:<math>F_r = (\frac {61}{61,035156}-1) \cdot 100% = -0,0575%</math>

Mit diesem Schema ist der Fehler beträchtlich gesunken. Nur noch 0.06%. Bei dieser Rate muss die Uhr immerhin etwas länger als 0,5 Stunden laufen, bis der Fehler auf eine Sekunde angewachsen ist. Das sind aber immer noch 48 Sekunden pro Tag bzw. 1488 Sekunden (=24,8 Minuten) pro Monat. So schlecht sind nicht mal billige mechanische Uhren!

Jetzt könnte man natürlich noch weiter gehen und immer kompliziertere "Schalt-Overflow"-Schemata austüfteln und damit die Genauigkeit näher an 100% bringen. Aber gibt es noch andere Möglichkeiten?

Im ersten Ansatz wurde ein Vorteiler von 1024 eingesetzt. Was passiert bei einem anderen Vorteiler? Nehmen wir mal einen Vorteiler von 64. Das heißt, es müssen ( 4000000 / 64 ) / 256 = 244.140625 Overflows auflaufen, bis 1 Sekunde vergangen ist. Wenn also 244 Overflows gezählt werden, dann beläuft sich der Fehler auf

:<math>F_r = (\frac {244}{244,140625}-1) \cdot 100% = -0,0576%</math>

Nicht schlecht. Nur durch Verändern von 2 Zahlenwerten im Programm (Teilerfaktor und Anzahl der Overflow Interrupts bis zu einer Sekunden) kann die Genauigkeit gegenüber dem ursprünglichen Overflow-Schema beträchtlich gesteigert werden. Aber geht das noch besser? Ja das geht. Allerdings nicht mit dem Overflow Interrupt.

== Der CTC-Modus des Timers ==

Worin liegt denn das eigentliche Problem, mit dem die Uhr zu kämpfen hat? Das Problem liegt darin, dass jedesmal ein kompletter Timerzyklus bis zum Overflow abgewartet werden muss, um darauf zu reagieren. Da aber nur jeweils ganzzahlige Overflowzyklen abgezählt werden können, heißt das auch, dass im ersten Fall nur in Vielfachen von 1024 * 256 = 262144 Takten operiert werden kann, während im letzten Fall immerhin schon eine Granulierung von 64 * 256 = 16384 Takten erreicht wird. Aber offensichtlich ist das nicht genau genug. Bei 4 MHz entsprechen 262144 Takte bereits einem Zeitraum von 65,5ms, während 16384 Takte einem Zeitbedarf von 4,096ms entsprechen. Beide Zahlen teilen aber 1000ms nicht ganzzahlig. Und daraus entsteht der Fehler. Angestrebt wird ein Timer, der seinen Overflow so erreicht, dass sich ein ganzzahliger Teiler von 1 Sekunde einstellt. Dazu müsste man dem Timer aber vorschreiben können, bei welchem Zählerstand der Overflow erfolgen soll. Und genau dies ist im '''CTC'''-Modus, allerdings nur beim Timer 1, möglich. '''CTC''' bedeutet "'''C'''lear '''T'''imer on '''C'''ompare match".

Timer 1, ein 16-Bit-Timer, wird mit einem Vorteiler von 1 betrieben. Dadurch wird erreicht, dass der Timer mit höchster Zeitauflösung arbeiten kann. Bei jedem Ticken des Systemtaktes von 4 MHz wird auch der Timer um 1 erhöht. Zusätzlich wird noch das WGM12-Bit bei der Konfiguration gesetzt. Dadurch wird der Timer in den '''CTC'''-Modus gesetzt. Dabei wird der Inhalt des Timers hardwaremäßig mit dem Inhalt des '''OCR1A'''-Registers verglichen. Stimmen beide überein, so wird der Timer auf 0 zurückgesetzt und im nächsten Taktzyklus ein '''OCIE1A'''-Interrupt ausgelöst. Dadurch ist es möglich, exakt die Anzahl an Taktzyklen festzulegen, die von einem Interrupt zum nächsten vergehen sollen. Das Compare Register '''OCR1A''' wird mit dem Wert 39999 vorbelegt. Dadurch vergehen exakt 40000 Taktzyklen von einem Compare-Interrupt zum nächsten. "Zufällig" ist dieser Wert so gewählt, dass bei einem Systemtakt von 4 MHz von einem Interrupt zum nächsten genau 1/100 Sekunde vergeht, denn 40000 / 4000000 = 0.01. Bei einem möglichen Umbau der Uhr zu einer Stoppuhr könnte sich das als nützlich erweisen. Im Interrupt wird das Hilfsregister SubCount bis 100 hochgezählt und nach 100 Interrupts kommt wieder die Sekundenweiterschaltung wie oben in Gang.

<syntaxhighlight lang="avrasm">
.include "m8def.inc"

.def temp1 = r16
.def temp2 = r17
.def temp3 = r18
.def Flag = r19

.def SubCount = r21
.def Sekunden = r22
.def Minuten = r23
.def Stunden = r24

.org 0x0000
rjmp main ; Reset Handler
.org OC1Aaddr
rjmp timer1_compare ; Timer Compare Handler

.include "lcd-routines.asm"

main:
ldi temp1, HIGH(RAMEND)
out SPH, temp1
ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1

ldi temp1, 0xFF ; Port D = Ausgang
out DDRD, temp1

rcall lcd_init
rcall lcd_clear

; Vergleichswert
ldi temp1, high( 40000 - 1 )
out OCR1AH, temp1
ldi temp1, low( 40000 - 1 )
out OCR1AL, temp1
; CTC Modus einschalten
; Vorteiler auf 1
ldi temp1, ( 1 << WGM12 ) | ( 1 << CS10 )
out TCCR1B, temp1

ldi temp1, 1 << OCIE1A ; OCIE1A: Interrupt bei Timer Compare
out TIMSK, temp1

clr Minuten ; Die Uhr auf 0 setzen
clr Sekunden
clr Stunden
clr SubCount
clr Flag ; Flag löschen

sei
loop:
cpi flag,0
breq loop ; Flag im Interrupt gesetzt?
ldi flag,0 ; Flag löschen

rcall lcd_clear ; das LCD löschen
mov temp1, Stunden ; und die Stunden ausgeben
rcall lcd_number
ldi temp1, ':' ; zwischen Stunden und Minuten einen ':'
rcall lcd_data
mov temp1, Minuten ; dann die Minuten ausgeben
rcall lcd_number
ldi temp1, ':' ; und noch ein ':'
rcall lcd_data
mov temp1, Sekunden ; und die Sekunden
rcall lcd_number

rjmp loop

timer1_compare: ; Timer 1 Output Compare Handler

push temp1 ; temp 1 sichern
in temp1,sreg ; SREG sichern

inc SubCount ; Wenn dies nicht der 100. Interrupt
cpi SubCount, 100 ; ist, dann passiert gar nichts
brne end_isr

; Überlauf
clr SubCount ; SubCount rücksetzen
inc Sekunden ; plus 1 Sekunde
cpi Sekunden, 60 ; sind 60 Sekunden vergangen?
brne Ausgabe ; wenn nicht kann die Ausgabe schon
; gemacht werden

; Überlauf
clr Sekunden ; Sekunden wieder auf 0 und dafür
inc Minuten ; plus 1 Minute
cpi Minuten, 60 ; sind 60 Minuten vergangen ?
brne Ausgabe ; wenn nicht, -> Ausgabe

; Überlauf
clr Minuten ; Minuten zurücksetzen und dafür
inc Stunden ; plus 1 Stunde
cpi Stunden, 24 ; nach 24 Stunden, die Stundenanzeige
brne Ausgabe ; wieder zurücksetzen

; Überlauf
clr Stunden ; Stunden rücksetzen

Ausgabe:
ldi flag,1 ; Flag setzen, LCD updaten

end_isr:

out sreg,temp1 ; sreg wieder herstellen
pop temp1
reti ; das wars. Interrupt ist fertig

; Eine Zahl aus dem Register temp1 ausgeben

lcd_number:
push temp2 ; register sichern,
; wird für Zwsichenergebnisse gebraucht
ldi temp2, '0'
lcd_number_10:
subi temp1, 10 ; abzählen wieviele Zehner in
brcs lcd_number_1 ; der Zahl enthalten sind
inc temp2
rjmp lcd_number_10
lcd_number_1:
push temp1 ; den Rest sichern (http://www.mikrocontroller.net/topic/172026)
mov temp1,temp2 ;
rcall lcd_data ; die Zehnerstelle ausgeben
pop temp1 ; den Rest wieder holen
subi temp1, -10 ; 10 wieder dazuzählen, da die
; vorhergehende Schleife 10 zuviel
; abgezogen hat
; das Subtrahieren von -10
; = Addition von +10 ist ein Trick
; da kein addi Befehl existiert
ldi temp2, '0' ; die übrig gebliebenen Einer
add temp1, temp2 ; noch ausgeben
rcall lcd_data

pop temp2 ; Register wieder herstellen
ret
</syntaxhighlight>

In der Interrupt-Routine werden wieder, genauso wie vorher, die Anzahl der Interrupt-Aufrufe gezählt. Beim 100. Aufruf sind daher 40.000 * 100 = 4.000.000 Takte vergangen und da der Quarz mit 4.000.000 Schwingungen in der Sekunde arbeitet, ist daher eine Sekunde vergangen. Sie wird genauso wie vorher registriert und die Uhr entsprechend hochgezählt. Wird jetzt die Uhr mit einer kommerziellen verglichen, dann fällt nach einiger Zeit auf ... Sie geht immer noch falsch! Was ist jetzt die Ursache? Die Ursache liegt in einem Problem, das nicht direkt behebbar ist. Am Quarz! Auch wenn auf dem Quarz drauf steht, dass er eine Frequenz von 4MHz hat, so stimmt das nicht exakt. Auch Quarze haben Fertigungstoleranzen und verändern ihre Frequenz mit der Temperatur. Typisch liegt die Fertigungstoleranz bei +/- 100ppm = 0,01% ('''p'''arts '''p'''er '''m'''illion, Millionstel Teile), die Temperaturdrift zwischen -40 Grad und 85 Grad liegt je nach Typ in der selben Größenordnung. Das bedeutet, dass die Uhr pro Monat um bis zu 268 Sekunden (~4 1/2 Minuten) falsch gehen kann. Diese Einflüsse auf die Quarzfrequenz sind aber messbar und per Hardware oder Software behebbar. In Uhren kommen normalerweise genauer gefertigte Uhrenquarze zum Einsatz, die vom Uhrmacher auch noch auf die exakte Frequenz abgeglichen werden (mittels Kondensatoren und Frequenzzähler). Ein Profi verwendet einen sehr genauen Frequenzzähler, womit er innerhalb weniger Sekunden die Frequenz sehr genau messen kann. Als Hobbybastler kann man die Uhr eine zeitlang (Tage, Wochen) laufen lassen und die Abweichung feststellen (z. B. exakt 20:00 Uhr zum Start der Tagsschau). Aus dieser Abweichung lässt sich dann errechnen, wie schnell der Quarz wirklich schwingt. Und da dank CTC die Messperiode taktgenau eingestellt werden kann, ist es möglich, diesen Frequenzfehler auszugleichen. Der genaue Vorgang ist in dem Wikiartikel [[AVR - Die genaue Sekunde / RTC]] beschrieben.

----

{{Navigation_zurückhochvor|
zurücktext=Timer|
zurücklink=AVR-Tutorial: Timer|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=ADC|
vorlink=AVR-Tutorial: ADC}}

[[Category:AVR-Tutorial|Uhr]]
[[Category:Timer und Uhren]]

PLL

2015-03-04T00:37:46Z

2001:A60:13D1:CB01:352D:6309:9D08:7E1F: /* Hardware */

Eine '''PLL''' (engl.: phase locked loop) ist ein Regelkreis in Hardware oder Software, der sich auf einen Eingangstakt synchronisieren kann.

== Hardware ==
PLLs sind als analoge Schaltkreise aufgebaut, die einen Eingangstakt hoch multiplizieren und wieder herunter dividieren und somit als nichtganzzahliger [[Taktteiler]] fungieren. Ferner wird in der Regel die Phase verschoben, dass ein gewünschtes Verhältnis eingestellt wird. Durch einen sog. feedback loop wird erreicht, dass sich die Phase auf dem hohen Frequenzniveau stabil verhält und dem [[Jitter]] des Eingangstaktes nur langsam folgt. Zur Stabilisierung des hochfrequenten Zwischentaktes werden rückgekoppelte Filter benutzt, die genau in dem Frequenzbereich stabil sind. Bei FPGAs sind diese Filter oft parametier- und umschaltbar.

Die Einstellung erfolgt voll analog, also nicht zeitdiskret.

== Software ==
Solche Regelkreise lassen sich in SW nachbilden, wenn sich ein [[Mikrocontroller]] auf einen eingehenden seriellen Takt einstellt bzw ein [[FPGA]] einen Eingangstakt ausmisst und sich in die Mitte stellt, um parallele Daten zu verarbeiten. (siehe [[SERDES]], [[GTP]]).

Die Verarbeitung erfolgt dann voll digital, also diskret mit dem Systemtakt des FPGAs / des Controllers.

== Siehe auch ==
In dieser Tabelle werden die durch ganzzahlige Teiler und Multiplizierer erreichbaren Frequenzverhältnisse aufgelistet:
[[Settings for Multiplier and Divider]]

[[Category:Timer und Uhren]]
[[Category:Grundlagen]]

AVR-Tutorial: Timer

2015-03-04T00:31:17Z

2001:A60:13D1:CB01:352D:6309:9D08:7E1F: /* TIMS - Timer/Counter Interrupt Mask Register */

Timer sind eines der Hauptarbeitspferde in unserem Mikrocontroller. Mit ihrer Hilfe ist es möglich, in regelmäßigen Zeitabständen Aktionen zu veranlassen. Aber Timer können noch mehr!
* Timer können mit einem externen Pin hochgezählt werden
* Es gibt Möglichkeiten, bei bestimmten Zählerständen einen Interrupt auslösen zu lassen
* Timer können aber auch völlig selbstständig Signale an einem Ausgabepin erzeugen
* ...

Aber der Reihe nach und kurz zur Erinnerung: Die Beispiele passen zu einem ATmega8 und ggf. einer Reihe anderer AVR, können bei einigen Typen aber abweichen.

==Was ist ein Timer?==

Ein Timer ist im Grunde nichts anderes als ein bestimmtes Register im Mikrocontroller, das hardwaregesteuert fortlaufend um 1 erhöht (oder verringert) wird (statt um 1 erhöhen sagt man auch '''inkrementieren''', und das Gegenstück, '''dekrementieren''', bedeutet um 1 verringern). Anstatt also Befehle im Programm vorzusehen, die regelmäßig ausgeführt werden und ein Register inkrementieren, erledigt dies der Mikrocontroller ganz von alleine. Dazu ist es möglich, den Timer mit dem Systemtakt zu verbinden und so die Genauigkeit des Quarzes auszunutzen, um ein Register regelmäßig und vor allen Dingen unabhängig vom restlichen Programmfluss (!) hochzählen zu lassen.

Davon alleine hätte man aber noch keinen großen Gewinn. Nützlich wird das Ganze erst dann, wenn man bei bestimmten Zählerständen eine Aktion ausführen lassen kann. Einer der 'bestimmten Zählerstände' ist zum Beispiel der '''Overflow'''. Das Zählregister eines Timers kann natürlich nicht beliebig lange inkrementiert werden – z. B. ist der höchste Zählerstand, den ein 8-Bit-Timer erreichen kann, 28 – 1 = 255. Beim nächsten Inkrementierschritt tritt ein Überlauf (engl. Overflow) auf, der den Timerstand wieder zu 0 werden lässt. Und hier liegt der springende Punkt. Wir können uns nämlich an diesen Overflow "anhängen" und den Controller so konfigurieren, dass beim Auftreten des Timer-Overflows ein Interrupt ausgelöst wird.

Die kann auch alles nochmal im Datenblatt von Atmel zu einigen ATMega Datenblättern nachgelesen werden: http://www.atmel.com/Images/doc8161.pdf

==Der Vorteiler (Prescaler)==

Wenn also der Quarzoszillator mit 4 MHz schwingt, dann würde auch der Timer 4 Millionen mal in der Sekunde erhöht werden. Da der Timer jedes Mal von 0 bis 255 zählt, bevor ein Overflow auftritt, heißt das auch, dass in einer Sekunde 4000000 / 256 = 15625 Overflows vorkommen. Ganz schön schnell! Nur: Oft ist das nicht sinnvoll. Um diese Raten zu verzögern, gibt es den Vorteiler, oder auf Englisch, Prescaler. Er kann z.B. auf die Werte 1, 8, 64, 256 oder 1024 eingestellt werden, je nach Timer (Bitte Datenblatt konsultieren!). Seine Aufgabe ist es, den Systemtakt um den angegebenen Faktor zu teilen. Steht der Vorteiler also auf 1024, so wird nur bei jedem 1024-ten Impuls vom Systemtakt das Timerregister um 1 erhöht. Entsprechend weniger häufig kommen dann natürlich die Overflows. Der Systemtakt sei wieder 4000000. Dann wird der Timer in 1 Sekunde 4000000 / 1024 = 3906.25 mal erhöht. Da der Timer wieder jedesmal bis 255 zählen muss bis ein Overflow auftritt, bedeutet dies, dass in 1 Sekunde 3906.25 / 256 = 15.25 Overflows auftreten.

Systemtakt: 4Mhz

Vorteiler Overflows/Sekunde Zeit zwischen
2 Overflows [s]

1 15625 0.000064
8 1953.125 0.000512
64 244.1406 0.004096
256 61.0351 0.016384
1024 15.2587 0.065536

Die Zeit (in Sekunden) zwischen 2 Overflows lässt sich sehr leicht berechnen:
<math>t=\frac{2^\text{Bit des Timers} \cdot \text{Vorteiler}}{\text{Systemtakt in Hz}}</math> .

==Erste Tests==

Ein Programm, das einen Timer Overflow in Aktion zeigt, könnte z. B. so aussehen:

<syntaxhighlight lang="avrasm">
.include "m8def.inc"

.def temp = r16
.def leds = r17

.org 0x0000
rjmp main ; Reset Handler
.org OVF0addr
rjmp timer0_overflow ; Timer Overflow Handler

main:
; Stackpointer initialisieren
ldi temp, HIGH(RAMEND)
out SPH, temp
ldi temp, LOW(RAMEND)
out SPL, temp

ldi temp, 0xFF ; Port B auf Ausgang
out DDRB, temp

ldi leds, 0xFF

ldi temp, (1<<CS00) ; CS00 setzen: Teiler 1
out TCCR0, temp

ldi temp, (1<<TOIE0) ; TOIE0: Interrupt bei Timer Overflow
out TIMSK, temp

sei

loop: rjmp loop

timer0_overflow: ; Timer 0 Overflow Handler
out PORTB, leds
com leds
reti
</syntaxhighlight>

Das Programm beginnt mit der [[AVR-Tutorial:_Interrupts|Interrupt-Vektoren-Tabelle]]. Dort ist an der Adresse OVF0Addr ein Sprung zur Marke timer0_overflow eingetragen. Wenn also ein Overflow Interrupt vom Timer 0 auftritt, so wird dieser Interrupt durch den '''rjmp''' weitergeleitet an die Stelle timer0_overflow.

Das Hauptprogramm beginnt ganz normal mit der Belegung des Stackpointers. Danach wird der Port B auf Ausgang geschaltet, wir wollen hier wieder die LED anschliessen.

Durch Beschreiben von TCCR0 mit dem Bitmuster 0b00000001, hier ausgedrückt durch (1<<CS00), wird der Vorteiler auf 1 gesetzt. Für die ersten Versuche empfiehlt es sich, das Programm mit dem AVR-Studio zunächst zu simulieren. Würden wir einen größeren Vorteiler benutzen, so müsste man ziemlich oft mittels F11 einen simulierten Schritt ausführen, um eine Änderung im Timerregister zu erreichen.

Die nächsten Anweisungen setzen im TIMSK Register das TOIE0 Bit. Sinn der Sache ist es, dem Timer zu erlauben, bei Erreichen eines Overflow einen Interrupt auszulösen.

Zum Schluss noch die Interrupts generell mittels '''sei''' freigeben. Dieser Schritt ist obligatorisch. Im Mikrocontroller können viele Quellen einen Interrupt auslösen. Daraus folgt: Für jede mögliche Quelle muss festgelegt werden, ob sie einen Interrupt erzeugen darf oder nicht. Die Oberhoheit hat aber das globale Interrupt Flag. Mit ihm können alle Interrupts, egal von welcher Quelle sie kommen, unterdrückt werden.

Damit ist die Initialisierung beendet und das Hauptprogramm kann sich schlafen legen. Die '''loop: rjmp loop''' Schleife macht genau dieses.

Tritt nun ein Overflow am Timer auf, so wird über den Umweg über die Interrupt Vektor Tabelle der Programmteil timer0_overflow angesprungen. Dieser gibt einfach nur den Inhalt des Registers leds am Port B aus. Danach wird das leds Register mit einer '''com''' Operation negiert, so dass aus allen 0 Bits eine 1 wird und umgekehrt. Die Overflow Behandlung ist damit beendet und mittels '''reti''' wird der Interrupt Handler wieder verlassen.

==Simulation im AVR-Studio==

Es lohnt sich, den ganzen Vorgang im AVR-Studio simulieren zu lassen. Dazu am besten in der linken I/O View Ansicht die Einträge für PORTB und TIMER_COUNTER_0 öffnen. Wird mittels F11 durch das Programm gegangen, so sieht man, dass ab dem Moment, ab dem der Vorteiler auf 1 gesetzt wird, der Timer 0 im TCNT0 Register zu zählen anfängt. Mit jedem Druck auf F11 erhöht sich der Zählerstand. Irgendwann ist dann die Endlosschleife loop erreicht. Drücken Sie weiterhin F11 und beobachten sie, wie TCNT0 immer höher zählt, bis der Overflow erreicht wird. In dem Moment, in dem der Overflow erreicht wird, wird der Interrupt ausgelöst (hierfür muss für das Debuggen im AVR-Studio "Mask interrupts while stepping" deaktiviert sein, zu finden in Tools -> Options). Mit dem nächsten F11 landen sie in der Interrupt Vektor Tabelle und von dort geht es weiter zu timer_0_overflow. Weitere Tastendrücke von F11 erledigen dann die Ausgabe auf den Port B, das Invertieren des Registers r17 und der Interrupt ist damit behandelt. Nach dem '''reti''' macht der Microcontroller genau an der Stelle weiter, an der er vom Interrupt unterbrochen wurde. Und der Timer 0 hat in der Zwischenzeit weitergezählt! Nach exakt weiteren 256 Schritten, vom Auftreten des ersten Overflows an gerechnet, wird der nächste Overflow ausgelöst.

==Wie schnell schaltet denn jetzt der Port?==

Eine berechtigte Frage. Dazu müssen wir etwas rechnen. Keine Angst, es ist nicht schwer, und wer das Prinzip bisher verstanden hat, der sollte keine Schwierigkeiten haben, die Berechnung nachzuvollziehen.

Der Quarzoszillator schwingt mit 4 MHz. Das heißt, in 1 Sekunde werden 4000000 Taktzyklen generiert. Durch die Wahl des Vorteilers von 1 bedeutet das auch, dass der Timer 4000000 mal in der Sekunde erhöht wird. Von einem Overflow zum nächsten muss der Timer 256 Zählvorgänge ausführen. Also werden in 1 Sekunde 4000000 / 256 = 15625 Overflows generiert. Bei jedem Overflow schalten wir die LEDs jeweils in den anderen Zustand. D.h die LEDs blinken mit einer Frequenz von 7812.5 Hz. Das ist zuviel als dass wir es noch sehen könnten.

Was können wir also tun, um diese Blinkfrequenz zu verringern? Im Moment ist unsere einzige Einflussgröße der Vorteiler. Wie sieht die Rechnung aus, wenn wir einen Vorteiler von 1024 wählen?

Wiederrum: Der Systemtakt sei 4 Mhz. Durch den Vorteiler von 1024 werden daraus 4000000 / 1024 = 3906.25 Pulse pro Sekunde für den Timer. Der zählt wiederum 256 Zustände von einem Overflow zum nächsten. 3906.25 / 256 = 15.2587. Und wiederum: Im Overflow werden die LEDs ja abwechselnd ein und ausgeschaltet, also dividieren wir noch durch 2: 15.2587 / 2 = 7.629. Also knapp 7 Hz. Diese Frequenz müsste man schon mit freiem Auge sehen. Die LEDs werden ziemlich schnell vor sich hin blinken.

Reicht diese Verzögerung noch immer nicht, dann haben wir 2 Möglichkeiten:
* Entweder wir benutzen einen anderen Timer. Timer 1 beispielsweise ist ein 16 Bit Timer. Der Timer zählt also nicht von 0 bis 255 sondern von 0 bis 65535. Bei entsprechender Umarbeitung des Programms und einem Vorteiler von 1024 bedeutet das, dass die LEDs einen Ein/Aus Zyklus in 33 Sekunden absolvieren.
* Oder wir schalten die LEDs nicht bei jedem Timer Overflow um. Man könnte zum Beispiel in einem Register bis 7 zählen und nur dann, wenn dieses Register 7 erreicht hat, wird
** das Register wieder auf 0 gesetzt und
** die LEDs umgeschaltet.

==Timer 0==

Timer 0 ist ein 8 Bit Timer.

* Overflow Interrupt

===TCCR0===
====TCCR - Timer/Counter Control Register====
{{Byte |TCCR0 | | | | | | CS02 | CS01 | CS00 }}

====CS02/CS00 - Clock Select====

{| {{Tabelle}}
|- style="background-color:#ffddcc"
! CS02 || CS01 || CS00 || Bedeutung
|-
|align="center"|0
|align="center"|0
|align="center"|0
||keine (Der Timer ist angehalten)
|-
|align="center"|0
|align="center"|0
|align="center"|1
||Vorteiler: 1
|-
|align="center"|0
|align="center"|1
|align="center"|0
||Vorteiler: 8
|-
|align="center"|0
|align="center"|1
|align="center"|1
||Vorteiler: 64
|-
|align="center"|1
|align="center"|0
|align="center"|0
||Vorteiler: 256
|-
|align="center"|1
|align="center"|0
|align="center"|1
||Vorteiler: 1024
|-
|align="center"|1
|align="center"|1
|align="center"|0
||Vorteiler: Externer Takt vom Pin T0, fallende Flanke
|-
|align="center"|1
|align="center"|1
|align="center"|1
||Vorteiler: Externer Takt vom Pin T0, steigende Flanke
|}

===TIMSK===
====TIMSK - Timer/Counter Interrupt Mask Register====

{{Byte|TIMSK| | | | | | | OCIE0 | TOIE0 }}

====TOIE0 - Timer 0 Overflow Interrupt Enable====
Ist dieses Bit gesetzt, so wird beim Auftreten eines Overflows am Timer ein Interrupt ausgelöst.

Anstatt der Schreibweise
<syntaxhighlight lang="avrasm">
ldi temp, 0b00000001 ; TOIE0: Interrupt bei Timer Overflow
out TIMSK, temp
</syntaxhighlight>
ist es besser, die Schreibweise
<syntaxhighlight lang="avrasm">
ldi temp, 1 << TOIE0
out TIMSK, temp
</syntaxhighlight>
zu wählen, da hier unmittelbar aus dem Ladekommando hervorgeht, welche Bedeutung das gesetzte Bit hat. Die vorher inkludierte m8def.inc definiert dazu alles Notwendige.

==Timer 1==

Timer 1 ist ein 16 Bit Timer

* Overflow Interrupt
* Clear Timer on Compare Match
* Input Capture
* 2 Compare Einheiten
* div. PWM Modi

===TCCR1B===

{{Byte|TCCR1B| ICNC1| ICES1| | WGM13| WGM12| CS12 | CS11 | CS10 }}

====CS12/CS10 - Clock Select====

{| {{Tabelle}}
|- style="background-color:#ffddcc"
! CS12 || CS11 || CS10 || Bedeutung
|-
|align="center"|0
|align="center"|0
|align="center"|0
||keine (Der Timer ist angehalten)
|-
|align="center"|0
|align="center"|0
|align="center"|1
||Vorteiler: 1
|-
|align="center"|0
|align="center"|1
|align="center"|0
||Vorteiler: 8
|-
|align="center"|0
|align="center"|1
|align="center"|1
||Vorteiler: 64
|-
|align="center"|1
|align="center"|0
|align="center"|0
||Vorteiler: 256
|-
|align="center"|1
|align="center"|0
|align="center"|1
||Vorteiler: 1024
|-
|align="center"|1
|align="center"|1
|align="center"|0
||Vorteiler: Externer Takt vom Pin T1, fallende Flanke
|-
|align="center"|1
|align="center"|1
|align="center"|1
||Vorteiler: Externer Takt vom Pin T1, steigende Flanke
|}

====ICES1 - Input Capture Edge Select====
ICES1 = 0 , falling edge
ICES1 = 1 , rising edge

====ICNC1 - Input Capture Noise Canceler====

===TCCR1A===

{{Byte|TCCR1A|COM1A1|COM1A0|COM1B1|COM1B0|FOC1A |FOC1B |WGM11 |WGM10 }}

===OCR1A===

{{Byte|| |||||||}}

{{Byte|| |||||||}}

===OCR1B===
{{Byte|| |||||||}}

{{Byte|| |||||||}}

===ICR1===
{{Byte|| |||||||}}

{{Byte|| |||||||}}

===TIMSK1===
{{Byte|TIMSK| | |TICIE1|OCIE1A|OCIE1B|TOIE1 | |}}

====TICIE1 - Timer 1 Input Capture Interrupt Enable====

====OCIE1A - Timer 1 Output Compare A Match Interrupt Enable====

====OCIE1B - Timer 1 Output Compare B Match Interrupt Enable====

====TOIE1 - Timer 1 Overflow Interrupt Enable====

==Timer 2==
Timer 2 ist ein 8 Bit Timer.

* Overflow Interrupt
* Compare Match Interrupt
* Clear Timer on Compare Match
* Phasen korrekte PWM

===TCCR2===

{{Byte|TCCR2| FOC2 | WGM20| COM21| COM20| WGM21| CS22 | CS21 | CS20 }}

====WGM21 - Waveform Generator Mode====

Ist diese Option Aktiviert dann wird das Zählregister des Timers (TCNT2) wieder auf 0 gesetzt,
sobal das Register as Output Compare Register (OCR2) und TCNT2 übereinstimmen.
Zu beachten ist dabei das wenn das Register kleiner als 255 gestellt ist, wird
der Timer nicht mehr überschritten und der Interrupt für den Overflow (TIMER2_OVF_vect) nicht mehr ausgelöst.
Stattdessen gibt es den Interrupt für Compare Match (TIMER2_COMP_vect)
Die Frequenz für die Interruptauslösung lässt sich dann wie folgt berechnen:
ISR_Freq = F_CPU : ( Prescaler * ORC2 )

====CS22/CS20 - Clock Select====

{| {{Tabelle}}
|- style="background-color:#ffddcc"
! CS22 || CS21 || CS20 || Bedeutung
|-
|align="center"|0
|align="center"|0
|align="center"|0
||keine (Der Timer ist angehalten)
|-
|align="center"|0
|align="center"|0
|align="center"|1
||Vorteiler: 1
|-
|align="center"|0
|align="center"|1
|align="center"|0
||Vorteiler: 8
|-
|align="center"|0
|align="center"|1
|align="center"|1
||Vorteiler: 32
|-
|align="center"|1
|align="center"|0
|align="center"|0
||Vorteiler: 64
|-
|align="center"|1
|align="center"|0
|align="center"|1
||Vorteiler: 128
|-
|align="center"|1
|align="center"|1
|align="center"|0
||Vorteiler: 256
|-
|align="center"|1
|align="center"|1
|align="center"|1
||Vorteiler: 1024
|}

===OCR2===

{{Byte|| |||||||}}

===TIMSK2===
{{Byte|TIMSK| OCIE2| TOIE2| | | | | | }}

====OCIE2 - Timer 2 Output Compare Interrupt Enable====
====TOIE2 Timer 2 Overflow Interrupt Enable====

==Was geht noch mit einem Timer?==

Timer sind sehr universelle Microcontroller Bestandteile. Für weitergehende Studien ist es daher unerlässlich, das entsprechende Datenblatt des Microcontrollers zu studieren. Oft ist es z. B. möglich, dass der Timer bei erreichen von bestimmten Zählerständen einen Ausgabepin von sich aus ein-/aus-/umschaltet. Er erledigt dann das, was wir oben noch mit einem Interrupt gemacht haben, eigenständig komplett in Hardware. Bei einigen Timern ist es möglich, damit eine [[PWM]] (Pulsweiten-Modulation) aufzubauen.

Ein paar der Timermodule lassen sich auch als Counter verwenden. Damit kann man z. B. die Anzahl externer Ereignisse wie Schaltvorgänge eines Inkrementalgebers bestimmen.

Andere bieten die Möglichkeit, über einen externen Uhrenquarz getaktet zu werden (Anwendung z. B. eine "Echtzeituhr" oder als "Weckfunktion" aus einem Standby/Powerdownmodus).

Durch geschickte Umprogrammierung in Echtzeit, lässt sich mit einem Timer eine [[PLL]] aufbauen, die sich fortwährend auf einen Eingangstakt synchronisiert. Damit wird vermieden, dass der Controller ein Signal ständig abpollen muss, sondern das Signale wird per Timer-Interrupt verarbeitet. Massgeblich ist die Messung der aktuellen- und Schätzung der kommenden Flanke mithilfe eines einstellbaren [[Taktteiler]]-verhältnisses.

== Weblinks ==
* [http://www.uni-koblenz.de/~physik/informatik/MCU/Timer.pdf Timer/Counter und PWM beim ATMega16 Mikrocontroller] Proseminar von Marcel Jakobs, September 2006 (PDF)
* [http://frank.circleofcurrent.com/cache/avrtimercalc.htm AVR Timer Calculator]

----

{{Navigation_zurückhochvor|
zurücktext=Speicher|
zurücklink=AVR-Tutorial: Speicher|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Uhr|
vorlink=AVR-Tutorial: Uhr}}

[[Category:AVR-Tutorial|Timer]]
[[Category:Timer und Uhren]]

AVR-Tutorial: Timer

2015-03-04T00:30:43Z

2001:A60:13D1:CB01:352D:6309:9D08:7E1F: /* TIMSK - Timer/Counter Interrupt Mask Register */

Timer sind eines der Hauptarbeitspferde in unserem Mikrocontroller. Mit ihrer Hilfe ist es möglich, in regelmäßigen Zeitabständen Aktionen zu veranlassen. Aber Timer können noch mehr!
* Timer können mit einem externen Pin hochgezählt werden
* Es gibt Möglichkeiten, bei bestimmten Zählerständen einen Interrupt auslösen zu lassen
* Timer können aber auch völlig selbstständig Signale an einem Ausgabepin erzeugen
* ...

Aber der Reihe nach und kurz zur Erinnerung: Die Beispiele passen zu einem ATmega8 und ggf. einer Reihe anderer AVR, können bei einigen Typen aber abweichen.

==Was ist ein Timer?==

Ein Timer ist im Grunde nichts anderes als ein bestimmtes Register im Mikrocontroller, das hardwaregesteuert fortlaufend um 1 erhöht (oder verringert) wird (statt um 1 erhöhen sagt man auch '''inkrementieren''', und das Gegenstück, '''dekrementieren''', bedeutet um 1 verringern). Anstatt also Befehle im Programm vorzusehen, die regelmäßig ausgeführt werden und ein Register inkrementieren, erledigt dies der Mikrocontroller ganz von alleine. Dazu ist es möglich, den Timer mit dem Systemtakt zu verbinden und so die Genauigkeit des Quarzes auszunutzen, um ein Register regelmäßig und vor allen Dingen unabhängig vom restlichen Programmfluss (!) hochzählen zu lassen.

Davon alleine hätte man aber noch keinen großen Gewinn. Nützlich wird das Ganze erst dann, wenn man bei bestimmten Zählerständen eine Aktion ausführen lassen kann. Einer der 'bestimmten Zählerstände' ist zum Beispiel der '''Overflow'''. Das Zählregister eines Timers kann natürlich nicht beliebig lange inkrementiert werden – z. B. ist der höchste Zählerstand, den ein 8-Bit-Timer erreichen kann, 28 – 1 = 255. Beim nächsten Inkrementierschritt tritt ein Überlauf (engl. Overflow) auf, der den Timerstand wieder zu 0 werden lässt. Und hier liegt der springende Punkt. Wir können uns nämlich an diesen Overflow "anhängen" und den Controller so konfigurieren, dass beim Auftreten des Timer-Overflows ein Interrupt ausgelöst wird.

Die kann auch alles nochmal im Datenblatt von Atmel zu einigen ATMega Datenblättern nachgelesen werden: http://www.atmel.com/Images/doc8161.pdf

==Der Vorteiler (Prescaler)==

Wenn also der Quarzoszillator mit 4 MHz schwingt, dann würde auch der Timer 4 Millionen mal in der Sekunde erhöht werden. Da der Timer jedes Mal von 0 bis 255 zählt, bevor ein Overflow auftritt, heißt das auch, dass in einer Sekunde 4000000 / 256 = 15625 Overflows vorkommen. Ganz schön schnell! Nur: Oft ist das nicht sinnvoll. Um diese Raten zu verzögern, gibt es den Vorteiler, oder auf Englisch, Prescaler. Er kann z.B. auf die Werte 1, 8, 64, 256 oder 1024 eingestellt werden, je nach Timer (Bitte Datenblatt konsultieren!). Seine Aufgabe ist es, den Systemtakt um den angegebenen Faktor zu teilen. Steht der Vorteiler also auf 1024, so wird nur bei jedem 1024-ten Impuls vom Systemtakt das Timerregister um 1 erhöht. Entsprechend weniger häufig kommen dann natürlich die Overflows. Der Systemtakt sei wieder 4000000. Dann wird der Timer in 1 Sekunde 4000000 / 1024 = 3906.25 mal erhöht. Da der Timer wieder jedesmal bis 255 zählen muss bis ein Overflow auftritt, bedeutet dies, dass in 1 Sekunde 3906.25 / 256 = 15.25 Overflows auftreten.

Systemtakt: 4Mhz

Vorteiler Overflows/Sekunde Zeit zwischen
2 Overflows [s]

1 15625 0.000064
8 1953.125 0.000512
64 244.1406 0.004096
256 61.0351 0.016384
1024 15.2587 0.065536

Die Zeit (in Sekunden) zwischen 2 Overflows lässt sich sehr leicht berechnen:
<math>t=\frac{2^\text{Bit des Timers} \cdot \text{Vorteiler}}{\text{Systemtakt in Hz}}</math> .

==Erste Tests==

Ein Programm, das einen Timer Overflow in Aktion zeigt, könnte z. B. so aussehen:

<syntaxhighlight lang="avrasm">
.include "m8def.inc"

.def temp = r16
.def leds = r17

.org 0x0000
rjmp main ; Reset Handler
.org OVF0addr
rjmp timer0_overflow ; Timer Overflow Handler

main:
; Stackpointer initialisieren
ldi temp, HIGH(RAMEND)
out SPH, temp
ldi temp, LOW(RAMEND)
out SPL, temp

ldi temp, 0xFF ; Port B auf Ausgang
out DDRB, temp

ldi leds, 0xFF

ldi temp, (1<<CS00) ; CS00 setzen: Teiler 1
out TCCR0, temp

ldi temp, (1<<TOIE0) ; TOIE0: Interrupt bei Timer Overflow
out TIMSK, temp

sei

loop: rjmp loop

timer0_overflow: ; Timer 0 Overflow Handler
out PORTB, leds
com leds
reti
</syntaxhighlight>

Das Programm beginnt mit der [[AVR-Tutorial:_Interrupts|Interrupt-Vektoren-Tabelle]]. Dort ist an der Adresse OVF0Addr ein Sprung zur Marke timer0_overflow eingetragen. Wenn also ein Overflow Interrupt vom Timer 0 auftritt, so wird dieser Interrupt durch den '''rjmp''' weitergeleitet an die Stelle timer0_overflow.

Das Hauptprogramm beginnt ganz normal mit der Belegung des Stackpointers. Danach wird der Port B auf Ausgang geschaltet, wir wollen hier wieder die LED anschliessen.

Durch Beschreiben von TCCR0 mit dem Bitmuster 0b00000001, hier ausgedrückt durch (1<<CS00), wird der Vorteiler auf 1 gesetzt. Für die ersten Versuche empfiehlt es sich, das Programm mit dem AVR-Studio zunächst zu simulieren. Würden wir einen größeren Vorteiler benutzen, so müsste man ziemlich oft mittels F11 einen simulierten Schritt ausführen, um eine Änderung im Timerregister zu erreichen.

Die nächsten Anweisungen setzen im TIMSK Register das TOIE0 Bit. Sinn der Sache ist es, dem Timer zu erlauben, bei Erreichen eines Overflow einen Interrupt auszulösen.

Zum Schluss noch die Interrupts generell mittels '''sei''' freigeben. Dieser Schritt ist obligatorisch. Im Mikrocontroller können viele Quellen einen Interrupt auslösen. Daraus folgt: Für jede mögliche Quelle muss festgelegt werden, ob sie einen Interrupt erzeugen darf oder nicht. Die Oberhoheit hat aber das globale Interrupt Flag. Mit ihm können alle Interrupts, egal von welcher Quelle sie kommen, unterdrückt werden.

Damit ist die Initialisierung beendet und das Hauptprogramm kann sich schlafen legen. Die '''loop: rjmp loop''' Schleife macht genau dieses.

Tritt nun ein Overflow am Timer auf, so wird über den Umweg über die Interrupt Vektor Tabelle der Programmteil timer0_overflow angesprungen. Dieser gibt einfach nur den Inhalt des Registers leds am Port B aus. Danach wird das leds Register mit einer '''com''' Operation negiert, so dass aus allen 0 Bits eine 1 wird und umgekehrt. Die Overflow Behandlung ist damit beendet und mittels '''reti''' wird der Interrupt Handler wieder verlassen.

==Simulation im AVR-Studio==

Es lohnt sich, den ganzen Vorgang im AVR-Studio simulieren zu lassen. Dazu am besten in der linken I/O View Ansicht die Einträge für PORTB und TIMER_COUNTER_0 öffnen. Wird mittels F11 durch das Programm gegangen, so sieht man, dass ab dem Moment, ab dem der Vorteiler auf 1 gesetzt wird, der Timer 0 im TCNT0 Register zu zählen anfängt. Mit jedem Druck auf F11 erhöht sich der Zählerstand. Irgendwann ist dann die Endlosschleife loop erreicht. Drücken Sie weiterhin F11 und beobachten sie, wie TCNT0 immer höher zählt, bis der Overflow erreicht wird. In dem Moment, in dem der Overflow erreicht wird, wird der Interrupt ausgelöst (hierfür muss für das Debuggen im AVR-Studio "Mask interrupts while stepping" deaktiviert sein, zu finden in Tools -> Options). Mit dem nächsten F11 landen sie in der Interrupt Vektor Tabelle und von dort geht es weiter zu timer_0_overflow. Weitere Tastendrücke von F11 erledigen dann die Ausgabe auf den Port B, das Invertieren des Registers r17 und der Interrupt ist damit behandelt. Nach dem '''reti''' macht der Microcontroller genau an der Stelle weiter, an der er vom Interrupt unterbrochen wurde. Und der Timer 0 hat in der Zwischenzeit weitergezählt! Nach exakt weiteren 256 Schritten, vom Auftreten des ersten Overflows an gerechnet, wird der nächste Overflow ausgelöst.

==Wie schnell schaltet denn jetzt der Port?==

Eine berechtigte Frage. Dazu müssen wir etwas rechnen. Keine Angst, es ist nicht schwer, und wer das Prinzip bisher verstanden hat, der sollte keine Schwierigkeiten haben, die Berechnung nachzuvollziehen.

Der Quarzoszillator schwingt mit 4 MHz. Das heißt, in 1 Sekunde werden 4000000 Taktzyklen generiert. Durch die Wahl des Vorteilers von 1 bedeutet das auch, dass der Timer 4000000 mal in der Sekunde erhöht wird. Von einem Overflow zum nächsten muss der Timer 256 Zählvorgänge ausführen. Also werden in 1 Sekunde 4000000 / 256 = 15625 Overflows generiert. Bei jedem Overflow schalten wir die LEDs jeweils in den anderen Zustand. D.h die LEDs blinken mit einer Frequenz von 7812.5 Hz. Das ist zuviel als dass wir es noch sehen könnten.

Was können wir also tun, um diese Blinkfrequenz zu verringern? Im Moment ist unsere einzige Einflussgröße der Vorteiler. Wie sieht die Rechnung aus, wenn wir einen Vorteiler von 1024 wählen?

Wiederrum: Der Systemtakt sei 4 Mhz. Durch den Vorteiler von 1024 werden daraus 4000000 / 1024 = 3906.25 Pulse pro Sekunde für den Timer. Der zählt wiederum 256 Zustände von einem Overflow zum nächsten. 3906.25 / 256 = 15.2587. Und wiederum: Im Overflow werden die LEDs ja abwechselnd ein und ausgeschaltet, also dividieren wir noch durch 2: 15.2587 / 2 = 7.629. Also knapp 7 Hz. Diese Frequenz müsste man schon mit freiem Auge sehen. Die LEDs werden ziemlich schnell vor sich hin blinken.

Reicht diese Verzögerung noch immer nicht, dann haben wir 2 Möglichkeiten:
* Entweder wir benutzen einen anderen Timer. Timer 1 beispielsweise ist ein 16 Bit Timer. Der Timer zählt also nicht von 0 bis 255 sondern von 0 bis 65535. Bei entsprechender Umarbeitung des Programms und einem Vorteiler von 1024 bedeutet das, dass die LEDs einen Ein/Aus Zyklus in 33 Sekunden absolvieren.
* Oder wir schalten die LEDs nicht bei jedem Timer Overflow um. Man könnte zum Beispiel in einem Register bis 7 zählen und nur dann, wenn dieses Register 7 erreicht hat, wird
** das Register wieder auf 0 gesetzt und
** die LEDs umgeschaltet.

==Timer 0==

Timer 0 ist ein 8 Bit Timer.

* Overflow Interrupt

===TCCR0===
====TCCR - Timer/Counter Control Register====
{{Byte |TCCR0 | | | | | | CS02 | CS01 | CS00 }}

====CS02/CS00 - Clock Select====

{| {{Tabelle}}
|- style="background-color:#ffddcc"
! CS02 || CS01 || CS00 || Bedeutung
|-
|align="center"|0
|align="center"|0
|align="center"|0
||keine (Der Timer ist angehalten)
|-
|align="center"|0
|align="center"|0
|align="center"|1
||Vorteiler: 1
|-
|align="center"|0
|align="center"|1
|align="center"|0
||Vorteiler: 8
|-
|align="center"|0
|align="center"|1
|align="center"|1
||Vorteiler: 64
|-
|align="center"|1
|align="center"|0
|align="center"|0
||Vorteiler: 256
|-
|align="center"|1
|align="center"|0
|align="center"|1
||Vorteiler: 1024
|-
|align="center"|1
|align="center"|1
|align="center"|0
||Vorteiler: Externer Takt vom Pin T0, fallende Flanke
|-
|align="center"|1
|align="center"|1
|align="center"|1
||Vorteiler: Externer Takt vom Pin T0, steigende Flanke
|}

===TIMSK===
====TIMS - Timer/Counter Interrupt Mask Register====

{{Byte|TIMSK| | | | | | | OCIE0 | TOIE0 }}

====TOIE0 - Timer 0 Overflow Interrupt Enable====
Ist dieses Bit gesetzt, so wird beim Auftreten eines Overflows am Timer ein Interrupt ausgelöst.

Anstatt der Schreibweise
<syntaxhighlight lang="avrasm">
ldi temp, 0b00000001 ; TOIE0: Interrupt bei Timer Overflow
out TIMSK, temp
</syntaxhighlight>
ist es besser, die Schreibweise
<syntaxhighlight lang="avrasm">
ldi temp, 1 << TOIE0
out TIMSK, temp
</syntaxhighlight>
zu wählen, da hier unmittelbar aus dem Ladekommando hervorgeht, welche Bedeutung das gesetzte Bit hat. Die vorher inkludierte m8def.inc definiert dazu alles Notwendige.

==Timer 1==

Timer 1 ist ein 16 Bit Timer

* Overflow Interrupt
* Clear Timer on Compare Match
* Input Capture
* 2 Compare Einheiten
* div. PWM Modi

===TCCR1B===

{{Byte|TCCR1B| ICNC1| ICES1| | WGM13| WGM12| CS12 | CS11 | CS10 }}

====CS12/CS10 - Clock Select====

{| {{Tabelle}}
|- style="background-color:#ffddcc"
! CS12 || CS11 || CS10 || Bedeutung
|-
|align="center"|0
|align="center"|0
|align="center"|0
||keine (Der Timer ist angehalten)
|-
|align="center"|0
|align="center"|0
|align="center"|1
||Vorteiler: 1
|-
|align="center"|0
|align="center"|1
|align="center"|0
||Vorteiler: 8
|-
|align="center"|0
|align="center"|1
|align="center"|1
||Vorteiler: 64
|-
|align="center"|1
|align="center"|0
|align="center"|0
||Vorteiler: 256
|-
|align="center"|1
|align="center"|0
|align="center"|1
||Vorteiler: 1024
|-
|align="center"|1
|align="center"|1
|align="center"|0
||Vorteiler: Externer Takt vom Pin T1, fallende Flanke
|-
|align="center"|1
|align="center"|1
|align="center"|1
||Vorteiler: Externer Takt vom Pin T1, steigende Flanke
|}

====ICES1 - Input Capture Edge Select====
ICES1 = 0 , falling edge
ICES1 = 1 , rising edge

====ICNC1 - Input Capture Noise Canceler====

===TCCR1A===

{{Byte|TCCR1A|COM1A1|COM1A0|COM1B1|COM1B0|FOC1A |FOC1B |WGM11 |WGM10 }}

===OCR1A===

{{Byte|| |||||||}}

{{Byte|| |||||||}}

===OCR1B===
{{Byte|| |||||||}}

{{Byte|| |||||||}}

===ICR1===
{{Byte|| |||||||}}

{{Byte|| |||||||}}

===TIMSK1===
{{Byte|TIMSK| | |TICIE1|OCIE1A|OCIE1B|TOIE1 | |}}

====TICIE1 - Timer 1 Input Capture Interrupt Enable====

====OCIE1A - Timer 1 Output Compare A Match Interrupt Enable====

====OCIE1B - Timer 1 Output Compare B Match Interrupt Enable====

====TOIE1 - Timer 1 Overflow Interrupt Enable====

==Timer 2==
Timer 2 ist ein 8 Bit Timer.

* Overflow Interrupt
* Compare Match Interrupt
* Clear Timer on Compare Match
* Phasen korrekte PWM

===TCCR2===

{{Byte|TCCR2| FOC2 | WGM20| COM21| COM20| WGM21| CS22 | CS21 | CS20 }}

====WGM21 - Waveform Generator Mode====

Ist diese Option Aktiviert dann wird das Zählregister des Timers (TCNT2) wieder auf 0 gesetzt,
sobal das Register as Output Compare Register (OCR2) und TCNT2 übereinstimmen.
Zu beachten ist dabei das wenn das Register kleiner als 255 gestellt ist, wird
der Timer nicht mehr überschritten und der Interrupt für den Overflow (TIMER2_OVF_vect) nicht mehr ausgelöst.
Stattdessen gibt es den Interrupt für Compare Match (TIMER2_COMP_vect)
Die Frequenz für die Interruptauslösung lässt sich dann wie folgt berechnen:
ISR_Freq = F_CPU : ( Prescaler * ORC2 )

====CS22/CS20 - Clock Select====

{| {{Tabelle}}
|- style="background-color:#ffddcc"
! CS22 || CS21 || CS20 || Bedeutung
|-
|align="center"|0
|align="center"|0
|align="center"|0
||keine (Der Timer ist angehalten)
|-
|align="center"|0
|align="center"|0
|align="center"|1
||Vorteiler: 1
|-
|align="center"|0
|align="center"|1
|align="center"|0
||Vorteiler: 8
|-
|align="center"|0
|align="center"|1
|align="center"|1
||Vorteiler: 32
|-
|align="center"|1
|align="center"|0
|align="center"|0
||Vorteiler: 64
|-
|align="center"|1
|align="center"|0
|align="center"|1
||Vorteiler: 128
|-
|align="center"|1
|align="center"|1
|align="center"|0
||Vorteiler: 256
|-
|align="center"|1
|align="center"|1
|align="center"|1
||Vorteiler: 1024
|}

===OCR2===

{{Byte|| |||||||}}

===TIMSK2===
{{Byte|TIMSK| OCIE2| TOIE2| | | | | | }}

====OCIE2 - Timer 2 Output Compare Interrupt Enable====
====TOIE2 Timer 2 Overflow Interrupt Enable====

==Was geht noch mit einem Timer?==

Timer sind sehr universelle Microcontroller Bestandteile. Für weitergehende Studien ist es daher unerlässlich, das entsprechende Datenblatt des Microcontrollers zu studieren. Oft ist es z. B. möglich, dass der Timer bei erreichen von bestimmten Zählerständen einen Ausgabepin von sich aus ein-/aus-/umschaltet. Er erledigt dann das, was wir oben noch mit einem Interrupt gemacht haben, eigenständig komplett in Hardware. Bei einigen Timern ist es möglich, damit eine [[PWM]] (Pulsweiten-Modulation) aufzubauen.

Ein paar der Timermodule lassen sich auch als Counter verwenden. Damit kann man z. B. die Anzahl externer Ereignisse wie Schaltvorgänge eines Inkrementalgebers bestimmen.

Andere bieten die Möglichkeit, über einen externen Uhrenquarz getaktet zu werden (Anwendung z. B. eine "Echtzeituhr" oder als "Weckfunktion" aus einem Standby/Powerdownmodus).

Durch geschickte Umprogrammierung in Echtzeit, lässt sich mit einem Timer eine [[PLL]] aufbauen, die sich fortwährend auf einen Eingangstakt synchronisiert. Damit wird vermieden, dass der Controller ein Signal ständig abpollen muss, sondern das Signale wird per Timer-Interrupt verarbeitet. Massgeblich ist die Messung der aktuellen- und Schätzung der kommenden Flanke mithilfe eines einstellbaren [[Taktteiler]]-verhältnisses.

== Weblinks ==
* [http://www.uni-koblenz.de/~physik/informatik/MCU/Timer.pdf Timer/Counter und PWM beim ATMega16 Mikrocontroller] Proseminar von Marcel Jakobs, September 2006 (PDF)
* [http://frank.circleofcurrent.com/cache/avrtimercalc.htm AVR Timer Calculator]

----

{{Navigation_zurückhochvor|
zurücktext=Speicher|
zurücklink=AVR-Tutorial: Speicher|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Uhr|
vorlink=AVR-Tutorial: Uhr}}

[[Category:AVR-Tutorial|Timer]]
[[Category:Timer und Uhren]]

AVR-Tutorial: Timer

2015-03-04T00:29:22Z

2001:A60:13D1:CB01:352D:6309:9D08:7E1F: /* CS02/CS00 - Clock Select */

Timer sind eines der Hauptarbeitspferde in unserem Mikrocontroller. Mit ihrer Hilfe ist es möglich, in regelmäßigen Zeitabständen Aktionen zu veranlassen. Aber Timer können noch mehr!
* Timer können mit einem externen Pin hochgezählt werden
* Es gibt Möglichkeiten, bei bestimmten Zählerständen einen Interrupt auslösen zu lassen
* Timer können aber auch völlig selbstständig Signale an einem Ausgabepin erzeugen
* ...

Aber der Reihe nach und kurz zur Erinnerung: Die Beispiele passen zu einem ATmega8 und ggf. einer Reihe anderer AVR, können bei einigen Typen aber abweichen.

==Was ist ein Timer?==

Ein Timer ist im Grunde nichts anderes als ein bestimmtes Register im Mikrocontroller, das hardwaregesteuert fortlaufend um 1 erhöht (oder verringert) wird (statt um 1 erhöhen sagt man auch '''inkrementieren''', und das Gegenstück, '''dekrementieren''', bedeutet um 1 verringern). Anstatt also Befehle im Programm vorzusehen, die regelmäßig ausgeführt werden und ein Register inkrementieren, erledigt dies der Mikrocontroller ganz von alleine. Dazu ist es möglich, den Timer mit dem Systemtakt zu verbinden und so die Genauigkeit des Quarzes auszunutzen, um ein Register regelmäßig und vor allen Dingen unabhängig vom restlichen Programmfluss (!) hochzählen zu lassen.

Davon alleine hätte man aber noch keinen großen Gewinn. Nützlich wird das Ganze erst dann, wenn man bei bestimmten Zählerständen eine Aktion ausführen lassen kann. Einer der 'bestimmten Zählerstände' ist zum Beispiel der '''Overflow'''. Das Zählregister eines Timers kann natürlich nicht beliebig lange inkrementiert werden – z. B. ist der höchste Zählerstand, den ein 8-Bit-Timer erreichen kann, 28 – 1 = 255. Beim nächsten Inkrementierschritt tritt ein Überlauf (engl. Overflow) auf, der den Timerstand wieder zu 0 werden lässt. Und hier liegt der springende Punkt. Wir können uns nämlich an diesen Overflow "anhängen" und den Controller so konfigurieren, dass beim Auftreten des Timer-Overflows ein Interrupt ausgelöst wird.

Die kann auch alles nochmal im Datenblatt von Atmel zu einigen ATMega Datenblättern nachgelesen werden: http://www.atmel.com/Images/doc8161.pdf

==Der Vorteiler (Prescaler)==

Wenn also der Quarzoszillator mit 4 MHz schwingt, dann würde auch der Timer 4 Millionen mal in der Sekunde erhöht werden. Da der Timer jedes Mal von 0 bis 255 zählt, bevor ein Overflow auftritt, heißt das auch, dass in einer Sekunde 4000000 / 256 = 15625 Overflows vorkommen. Ganz schön schnell! Nur: Oft ist das nicht sinnvoll. Um diese Raten zu verzögern, gibt es den Vorteiler, oder auf Englisch, Prescaler. Er kann z.B. auf die Werte 1, 8, 64, 256 oder 1024 eingestellt werden, je nach Timer (Bitte Datenblatt konsultieren!). Seine Aufgabe ist es, den Systemtakt um den angegebenen Faktor zu teilen. Steht der Vorteiler also auf 1024, so wird nur bei jedem 1024-ten Impuls vom Systemtakt das Timerregister um 1 erhöht. Entsprechend weniger häufig kommen dann natürlich die Overflows. Der Systemtakt sei wieder 4000000. Dann wird der Timer in 1 Sekunde 4000000 / 1024 = 3906.25 mal erhöht. Da der Timer wieder jedesmal bis 255 zählen muss bis ein Overflow auftritt, bedeutet dies, dass in 1 Sekunde 3906.25 / 256 = 15.25 Overflows auftreten.

Systemtakt: 4Mhz

Vorteiler Overflows/Sekunde Zeit zwischen
2 Overflows [s]

1 15625 0.000064
8 1953.125 0.000512
64 244.1406 0.004096
256 61.0351 0.016384
1024 15.2587 0.065536

Die Zeit (in Sekunden) zwischen 2 Overflows lässt sich sehr leicht berechnen:
<math>t=\frac{2^\text{Bit des Timers} \cdot \text{Vorteiler}}{\text{Systemtakt in Hz}}</math> .

==Erste Tests==

Ein Programm, das einen Timer Overflow in Aktion zeigt, könnte z. B. so aussehen:

<syntaxhighlight lang="avrasm">
.include "m8def.inc"

.def temp = r16
.def leds = r17

.org 0x0000
rjmp main ; Reset Handler
.org OVF0addr
rjmp timer0_overflow ; Timer Overflow Handler

main:
; Stackpointer initialisieren
ldi temp, HIGH(RAMEND)
out SPH, temp
ldi temp, LOW(RAMEND)
out SPL, temp

ldi temp, 0xFF ; Port B auf Ausgang
out DDRB, temp

ldi leds, 0xFF

ldi temp, (1<<CS00) ; CS00 setzen: Teiler 1
out TCCR0, temp

ldi temp, (1<<TOIE0) ; TOIE0: Interrupt bei Timer Overflow
out TIMSK, temp

sei

loop: rjmp loop

timer0_overflow: ; Timer 0 Overflow Handler
out PORTB, leds
com leds
reti
</syntaxhighlight>

Das Programm beginnt mit der [[AVR-Tutorial:_Interrupts|Interrupt-Vektoren-Tabelle]]. Dort ist an der Adresse OVF0Addr ein Sprung zur Marke timer0_overflow eingetragen. Wenn also ein Overflow Interrupt vom Timer 0 auftritt, so wird dieser Interrupt durch den '''rjmp''' weitergeleitet an die Stelle timer0_overflow.

Das Hauptprogramm beginnt ganz normal mit der Belegung des Stackpointers. Danach wird der Port B auf Ausgang geschaltet, wir wollen hier wieder die LED anschliessen.

Durch Beschreiben von TCCR0 mit dem Bitmuster 0b00000001, hier ausgedrückt durch (1<<CS00), wird der Vorteiler auf 1 gesetzt. Für die ersten Versuche empfiehlt es sich, das Programm mit dem AVR-Studio zunächst zu simulieren. Würden wir einen größeren Vorteiler benutzen, so müsste man ziemlich oft mittels F11 einen simulierten Schritt ausführen, um eine Änderung im Timerregister zu erreichen.

Die nächsten Anweisungen setzen im TIMSK Register das TOIE0 Bit. Sinn der Sache ist es, dem Timer zu erlauben, bei Erreichen eines Overflow einen Interrupt auszulösen.

Zum Schluss noch die Interrupts generell mittels '''sei''' freigeben. Dieser Schritt ist obligatorisch. Im Mikrocontroller können viele Quellen einen Interrupt auslösen. Daraus folgt: Für jede mögliche Quelle muss festgelegt werden, ob sie einen Interrupt erzeugen darf oder nicht. Die Oberhoheit hat aber das globale Interrupt Flag. Mit ihm können alle Interrupts, egal von welcher Quelle sie kommen, unterdrückt werden.

Damit ist die Initialisierung beendet und das Hauptprogramm kann sich schlafen legen. Die '''loop: rjmp loop''' Schleife macht genau dieses.

Tritt nun ein Overflow am Timer auf, so wird über den Umweg über die Interrupt Vektor Tabelle der Programmteil timer0_overflow angesprungen. Dieser gibt einfach nur den Inhalt des Registers leds am Port B aus. Danach wird das leds Register mit einer '''com''' Operation negiert, so dass aus allen 0 Bits eine 1 wird und umgekehrt. Die Overflow Behandlung ist damit beendet und mittels '''reti''' wird der Interrupt Handler wieder verlassen.

==Simulation im AVR-Studio==

Es lohnt sich, den ganzen Vorgang im AVR-Studio simulieren zu lassen. Dazu am besten in der linken I/O View Ansicht die Einträge für PORTB und TIMER_COUNTER_0 öffnen. Wird mittels F11 durch das Programm gegangen, so sieht man, dass ab dem Moment, ab dem der Vorteiler auf 1 gesetzt wird, der Timer 0 im TCNT0 Register zu zählen anfängt. Mit jedem Druck auf F11 erhöht sich der Zählerstand. Irgendwann ist dann die Endlosschleife loop erreicht. Drücken Sie weiterhin F11 und beobachten sie, wie TCNT0 immer höher zählt, bis der Overflow erreicht wird. In dem Moment, in dem der Overflow erreicht wird, wird der Interrupt ausgelöst (hierfür muss für das Debuggen im AVR-Studio "Mask interrupts while stepping" deaktiviert sein, zu finden in Tools -> Options). Mit dem nächsten F11 landen sie in der Interrupt Vektor Tabelle und von dort geht es weiter zu timer_0_overflow. Weitere Tastendrücke von F11 erledigen dann die Ausgabe auf den Port B, das Invertieren des Registers r17 und der Interrupt ist damit behandelt. Nach dem '''reti''' macht der Microcontroller genau an der Stelle weiter, an der er vom Interrupt unterbrochen wurde. Und der Timer 0 hat in der Zwischenzeit weitergezählt! Nach exakt weiteren 256 Schritten, vom Auftreten des ersten Overflows an gerechnet, wird der nächste Overflow ausgelöst.

==Wie schnell schaltet denn jetzt der Port?==

Eine berechtigte Frage. Dazu müssen wir etwas rechnen. Keine Angst, es ist nicht schwer, und wer das Prinzip bisher verstanden hat, der sollte keine Schwierigkeiten haben, die Berechnung nachzuvollziehen.

Der Quarzoszillator schwingt mit 4 MHz. Das heißt, in 1 Sekunde werden 4000000 Taktzyklen generiert. Durch die Wahl des Vorteilers von 1 bedeutet das auch, dass der Timer 4000000 mal in der Sekunde erhöht wird. Von einem Overflow zum nächsten muss der Timer 256 Zählvorgänge ausführen. Also werden in 1 Sekunde 4000000 / 256 = 15625 Overflows generiert. Bei jedem Overflow schalten wir die LEDs jeweils in den anderen Zustand. D.h die LEDs blinken mit einer Frequenz von 7812.5 Hz. Das ist zuviel als dass wir es noch sehen könnten.

Was können wir also tun, um diese Blinkfrequenz zu verringern? Im Moment ist unsere einzige Einflussgröße der Vorteiler. Wie sieht die Rechnung aus, wenn wir einen Vorteiler von 1024 wählen?

Wiederrum: Der Systemtakt sei 4 Mhz. Durch den Vorteiler von 1024 werden daraus 4000000 / 1024 = 3906.25 Pulse pro Sekunde für den Timer. Der zählt wiederum 256 Zustände von einem Overflow zum nächsten. 3906.25 / 256 = 15.2587. Und wiederum: Im Overflow werden die LEDs ja abwechselnd ein und ausgeschaltet, also dividieren wir noch durch 2: 15.2587 / 2 = 7.629. Also knapp 7 Hz. Diese Frequenz müsste man schon mit freiem Auge sehen. Die LEDs werden ziemlich schnell vor sich hin blinken.

Reicht diese Verzögerung noch immer nicht, dann haben wir 2 Möglichkeiten:
* Entweder wir benutzen einen anderen Timer. Timer 1 beispielsweise ist ein 16 Bit Timer. Der Timer zählt also nicht von 0 bis 255 sondern von 0 bis 65535. Bei entsprechender Umarbeitung des Programms und einem Vorteiler von 1024 bedeutet das, dass die LEDs einen Ein/Aus Zyklus in 33 Sekunden absolvieren.
* Oder wir schalten die LEDs nicht bei jedem Timer Overflow um. Man könnte zum Beispiel in einem Register bis 7 zählen und nur dann, wenn dieses Register 7 erreicht hat, wird
** das Register wieder auf 0 gesetzt und
** die LEDs umgeschaltet.

==Timer 0==

Timer 0 ist ein 8 Bit Timer.

* Overflow Interrupt

===TCCR0===
====TCCR - Timer/Counter Control Register====
{{Byte |TCCR0 | | | | | | CS02 | CS01 | CS00 }}

====CS02/CS00 - Clock Select====

{| {{Tabelle}}
|- style="background-color:#ffddcc"
! CS02 || CS01 || CS00 || Bedeutung
|-
|align="center"|0
|align="center"|0
|align="center"|0
||keine (Der Timer ist angehalten)
|-
|align="center"|0
|align="center"|0
|align="center"|1
||Vorteiler: 1
|-
|align="center"|0
|align="center"|1
|align="center"|0
||Vorteiler: 8
|-
|align="center"|0
|align="center"|1
|align="center"|1
||Vorteiler: 64
|-
|align="center"|1
|align="center"|0
|align="center"|0
||Vorteiler: 256
|-
|align="center"|1
|align="center"|0
|align="center"|1
||Vorteiler: 1024
|-
|align="center"|1
|align="center"|1
|align="center"|0
||Vorteiler: Externer Takt vom Pin T0, fallende Flanke
|-
|align="center"|1
|align="center"|1
|align="center"|1
||Vorteiler: Externer Takt vom Pin T0, steigende Flanke
|}

===TIMSK - Timer/Counter Interrupt Mask Register===

{{Byte|TIMSK| | | | | | | OCIE0 | TOIE0 }}

====TOIE0 - Timer 0 Overflow Interrupt Enable====
Ist dieses Bit gesetzt, so wird beim Auftreten eines Overflows am Timer ein Interrupt ausgelöst.

Anstatt der Schreibweise
<syntaxhighlight lang="avrasm">
ldi temp, 0b00000001 ; TOIE0: Interrupt bei Timer Overflow
out TIMSK, temp
</syntaxhighlight>
ist es besser, die Schreibweise
<syntaxhighlight lang="avrasm">
ldi temp, 1 << TOIE0
out TIMSK, temp
</syntaxhighlight>
zu wählen, da hier unmittelbar aus dem Ladekommando hervorgeht, welche Bedeutung das gesetzte Bit hat. Die vorher inkludierte m8def.inc definiert dazu alles Notwendige.

==Timer 1==

Timer 1 ist ein 16 Bit Timer

* Overflow Interrupt
* Clear Timer on Compare Match
* Input Capture
* 2 Compare Einheiten
* div. PWM Modi

===TCCR1B===

{{Byte|TCCR1B| ICNC1| ICES1| | WGM13| WGM12| CS12 | CS11 | CS10 }}

====CS12/CS10 - Clock Select====

{| {{Tabelle}}
|- style="background-color:#ffddcc"
! CS12 || CS11 || CS10 || Bedeutung
|-
|align="center"|0
|align="center"|0
|align="center"|0
||keine (Der Timer ist angehalten)
|-
|align="center"|0
|align="center"|0
|align="center"|1
||Vorteiler: 1
|-
|align="center"|0
|align="center"|1
|align="center"|0
||Vorteiler: 8
|-
|align="center"|0
|align="center"|1
|align="center"|1
||Vorteiler: 64
|-
|align="center"|1
|align="center"|0
|align="center"|0
||Vorteiler: 256
|-
|align="center"|1
|align="center"|0
|align="center"|1
||Vorteiler: 1024
|-
|align="center"|1
|align="center"|1
|align="center"|0
||Vorteiler: Externer Takt vom Pin T1, fallende Flanke
|-
|align="center"|1
|align="center"|1
|align="center"|1
||Vorteiler: Externer Takt vom Pin T1, steigende Flanke
|}

====ICES1 - Input Capture Edge Select====
ICES1 = 0 , falling edge
ICES1 = 1 , rising edge

====ICNC1 - Input Capture Noise Canceler====

===TCCR1A===

{{Byte|TCCR1A|COM1A1|COM1A0|COM1B1|COM1B0|FOC1A |FOC1B |WGM11 |WGM10 }}

===OCR1A===

{{Byte|| |||||||}}

{{Byte|| |||||||}}

===OCR1B===
{{Byte|| |||||||}}

{{Byte|| |||||||}}

===ICR1===
{{Byte|| |||||||}}

{{Byte|| |||||||}}

===TIMSK1===
{{Byte|TIMSK| | |TICIE1|OCIE1A|OCIE1B|TOIE1 | |}}

====TICIE1 - Timer 1 Input Capture Interrupt Enable====

====OCIE1A - Timer 1 Output Compare A Match Interrupt Enable====

====OCIE1B - Timer 1 Output Compare B Match Interrupt Enable====

====TOIE1 - Timer 1 Overflow Interrupt Enable====

==Timer 2==
Timer 2 ist ein 8 Bit Timer.

* Overflow Interrupt
* Compare Match Interrupt
* Clear Timer on Compare Match
* Phasen korrekte PWM

===TCCR2===

{{Byte|TCCR2| FOC2 | WGM20| COM21| COM20| WGM21| CS22 | CS21 | CS20 }}

====WGM21 - Waveform Generator Mode====

Ist diese Option Aktiviert dann wird das Zählregister des Timers (TCNT2) wieder auf 0 gesetzt,
sobal das Register as Output Compare Register (OCR2) und TCNT2 übereinstimmen.
Zu beachten ist dabei das wenn das Register kleiner als 255 gestellt ist, wird
der Timer nicht mehr überschritten und der Interrupt für den Overflow (TIMER2_OVF_vect) nicht mehr ausgelöst.
Stattdessen gibt es den Interrupt für Compare Match (TIMER2_COMP_vect)
Die Frequenz für die Interruptauslösung lässt sich dann wie folgt berechnen:
ISR_Freq = F_CPU : ( Prescaler * ORC2 )

====CS22/CS20 - Clock Select====

{| {{Tabelle}}
|- style="background-color:#ffddcc"
! CS22 || CS21 || CS20 || Bedeutung
|-
|align="center"|0
|align="center"|0
|align="center"|0
||keine (Der Timer ist angehalten)
|-
|align="center"|0
|align="center"|0
|align="center"|1
||Vorteiler: 1
|-
|align="center"|0
|align="center"|1
|align="center"|0
||Vorteiler: 8
|-
|align="center"|0
|align="center"|1
|align="center"|1
||Vorteiler: 32
|-
|align="center"|1
|align="center"|0
|align="center"|0
||Vorteiler: 64
|-
|align="center"|1
|align="center"|0
|align="center"|1
||Vorteiler: 128
|-
|align="center"|1
|align="center"|1
|align="center"|0
||Vorteiler: 256
|-
|align="center"|1
|align="center"|1
|align="center"|1
||Vorteiler: 1024
|}

===OCR2===

{{Byte|| |||||||}}

===TIMSK2===
{{Byte|TIMSK| OCIE2| TOIE2| | | | | | }}

====OCIE2 - Timer 2 Output Compare Interrupt Enable====
====TOIE2 Timer 2 Overflow Interrupt Enable====

==Was geht noch mit einem Timer?==

Timer sind sehr universelle Microcontroller Bestandteile. Für weitergehende Studien ist es daher unerlässlich, das entsprechende Datenblatt des Microcontrollers zu studieren. Oft ist es z. B. möglich, dass der Timer bei erreichen von bestimmten Zählerständen einen Ausgabepin von sich aus ein-/aus-/umschaltet. Er erledigt dann das, was wir oben noch mit einem Interrupt gemacht haben, eigenständig komplett in Hardware. Bei einigen Timern ist es möglich, damit eine [[PWM]] (Pulsweiten-Modulation) aufzubauen.

Ein paar der Timermodule lassen sich auch als Counter verwenden. Damit kann man z. B. die Anzahl externer Ereignisse wie Schaltvorgänge eines Inkrementalgebers bestimmen.

Andere bieten die Möglichkeit, über einen externen Uhrenquarz getaktet zu werden (Anwendung z. B. eine "Echtzeituhr" oder als "Weckfunktion" aus einem Standby/Powerdownmodus).

Durch geschickte Umprogrammierung in Echtzeit, lässt sich mit einem Timer eine [[PLL]] aufbauen, die sich fortwährend auf einen Eingangstakt synchronisiert. Damit wird vermieden, dass der Controller ein Signal ständig abpollen muss, sondern das Signale wird per Timer-Interrupt verarbeitet. Massgeblich ist die Messung der aktuellen- und Schätzung der kommenden Flanke mithilfe eines einstellbaren [[Taktteiler]]-verhältnisses.

== Weblinks ==
* [http://www.uni-koblenz.de/~physik/informatik/MCU/Timer.pdf Timer/Counter und PWM beim ATMega16 Mikrocontroller] Proseminar von Marcel Jakobs, September 2006 (PDF)
* [http://frank.circleofcurrent.com/cache/avrtimercalc.htm AVR Timer Calculator]

----

{{Navigation_zurückhochvor|
zurücktext=Speicher|
zurücklink=AVR-Tutorial: Speicher|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Uhr|
vorlink=AVR-Tutorial: Uhr}}

[[Category:AVR-Tutorial|Timer]]
[[Category:Timer und Uhren]]

AVR-Tutorial: Timer

2015-03-04T00:28:24Z

2001:A60:13D1:CB01:352D:6309:9D08:7E1F: /* TIMSK */

Timer sind eines der Hauptarbeitspferde in unserem Mikrocontroller. Mit ihrer Hilfe ist es möglich, in regelmäßigen Zeitabständen Aktionen zu veranlassen. Aber Timer können noch mehr!
* Timer können mit einem externen Pin hochgezählt werden
* Es gibt Möglichkeiten, bei bestimmten Zählerständen einen Interrupt auslösen zu lassen
* Timer können aber auch völlig selbstständig Signale an einem Ausgabepin erzeugen
* ...

Aber der Reihe nach und kurz zur Erinnerung: Die Beispiele passen zu einem ATmega8 und ggf. einer Reihe anderer AVR, können bei einigen Typen aber abweichen.

==Was ist ein Timer?==

Ein Timer ist im Grunde nichts anderes als ein bestimmtes Register im Mikrocontroller, das hardwaregesteuert fortlaufend um 1 erhöht (oder verringert) wird (statt um 1 erhöhen sagt man auch '''inkrementieren''', und das Gegenstück, '''dekrementieren''', bedeutet um 1 verringern). Anstatt also Befehle im Programm vorzusehen, die regelmäßig ausgeführt werden und ein Register inkrementieren, erledigt dies der Mikrocontroller ganz von alleine. Dazu ist es möglich, den Timer mit dem Systemtakt zu verbinden und so die Genauigkeit des Quarzes auszunutzen, um ein Register regelmäßig und vor allen Dingen unabhängig vom restlichen Programmfluss (!) hochzählen zu lassen.

Davon alleine hätte man aber noch keinen großen Gewinn. Nützlich wird das Ganze erst dann, wenn man bei bestimmten Zählerständen eine Aktion ausführen lassen kann. Einer der 'bestimmten Zählerstände' ist zum Beispiel der '''Overflow'''. Das Zählregister eines Timers kann natürlich nicht beliebig lange inkrementiert werden – z. B. ist der höchste Zählerstand, den ein 8-Bit-Timer erreichen kann, 28 – 1 = 255. Beim nächsten Inkrementierschritt tritt ein Überlauf (engl. Overflow) auf, der den Timerstand wieder zu 0 werden lässt. Und hier liegt der springende Punkt. Wir können uns nämlich an diesen Overflow "anhängen" und den Controller so konfigurieren, dass beim Auftreten des Timer-Overflows ein Interrupt ausgelöst wird.

Die kann auch alles nochmal im Datenblatt von Atmel zu einigen ATMega Datenblättern nachgelesen werden: http://www.atmel.com/Images/doc8161.pdf

==Der Vorteiler (Prescaler)==

Wenn also der Quarzoszillator mit 4 MHz schwingt, dann würde auch der Timer 4 Millionen mal in der Sekunde erhöht werden. Da der Timer jedes Mal von 0 bis 255 zählt, bevor ein Overflow auftritt, heißt das auch, dass in einer Sekunde 4000000 / 256 = 15625 Overflows vorkommen. Ganz schön schnell! Nur: Oft ist das nicht sinnvoll. Um diese Raten zu verzögern, gibt es den Vorteiler, oder auf Englisch, Prescaler. Er kann z.B. auf die Werte 1, 8, 64, 256 oder 1024 eingestellt werden, je nach Timer (Bitte Datenblatt konsultieren!). Seine Aufgabe ist es, den Systemtakt um den angegebenen Faktor zu teilen. Steht der Vorteiler also auf 1024, so wird nur bei jedem 1024-ten Impuls vom Systemtakt das Timerregister um 1 erhöht. Entsprechend weniger häufig kommen dann natürlich die Overflows. Der Systemtakt sei wieder 4000000. Dann wird der Timer in 1 Sekunde 4000000 / 1024 = 3906.25 mal erhöht. Da der Timer wieder jedesmal bis 255 zählen muss bis ein Overflow auftritt, bedeutet dies, dass in 1 Sekunde 3906.25 / 256 = 15.25 Overflows auftreten.

Systemtakt: 4Mhz

Vorteiler Overflows/Sekunde Zeit zwischen
2 Overflows [s]

1 15625 0.000064
8 1953.125 0.000512
64 244.1406 0.004096
256 61.0351 0.016384
1024 15.2587 0.065536

Die Zeit (in Sekunden) zwischen 2 Overflows lässt sich sehr leicht berechnen:
<math>t=\frac{2^\text{Bit des Timers} \cdot \text{Vorteiler}}{\text{Systemtakt in Hz}}</math> .

==Erste Tests==

Ein Programm, das einen Timer Overflow in Aktion zeigt, könnte z. B. so aussehen:

<syntaxhighlight lang="avrasm">
.include "m8def.inc"

.def temp = r16
.def leds = r17

.org 0x0000
rjmp main ; Reset Handler
.org OVF0addr
rjmp timer0_overflow ; Timer Overflow Handler

main:
; Stackpointer initialisieren
ldi temp, HIGH(RAMEND)
out SPH, temp
ldi temp, LOW(RAMEND)
out SPL, temp

ldi temp, 0xFF ; Port B auf Ausgang
out DDRB, temp

ldi leds, 0xFF

ldi temp, (1<<CS00) ; CS00 setzen: Teiler 1
out TCCR0, temp

ldi temp, (1<<TOIE0) ; TOIE0: Interrupt bei Timer Overflow
out TIMSK, temp

sei

loop: rjmp loop

timer0_overflow: ; Timer 0 Overflow Handler
out PORTB, leds
com leds
reti
</syntaxhighlight>

Das Programm beginnt mit der [[AVR-Tutorial:_Interrupts|Interrupt-Vektoren-Tabelle]]. Dort ist an der Adresse OVF0Addr ein Sprung zur Marke timer0_overflow eingetragen. Wenn also ein Overflow Interrupt vom Timer 0 auftritt, so wird dieser Interrupt durch den '''rjmp''' weitergeleitet an die Stelle timer0_overflow.

Das Hauptprogramm beginnt ganz normal mit der Belegung des Stackpointers. Danach wird der Port B auf Ausgang geschaltet, wir wollen hier wieder die LED anschliessen.

Durch Beschreiben von TCCR0 mit dem Bitmuster 0b00000001, hier ausgedrückt durch (1<<CS00), wird der Vorteiler auf 1 gesetzt. Für die ersten Versuche empfiehlt es sich, das Programm mit dem AVR-Studio zunächst zu simulieren. Würden wir einen größeren Vorteiler benutzen, so müsste man ziemlich oft mittels F11 einen simulierten Schritt ausführen, um eine Änderung im Timerregister zu erreichen.

Die nächsten Anweisungen setzen im TIMSK Register das TOIE0 Bit. Sinn der Sache ist es, dem Timer zu erlauben, bei Erreichen eines Overflow einen Interrupt auszulösen.

Zum Schluss noch die Interrupts generell mittels '''sei''' freigeben. Dieser Schritt ist obligatorisch. Im Mikrocontroller können viele Quellen einen Interrupt auslösen. Daraus folgt: Für jede mögliche Quelle muss festgelegt werden, ob sie einen Interrupt erzeugen darf oder nicht. Die Oberhoheit hat aber das globale Interrupt Flag. Mit ihm können alle Interrupts, egal von welcher Quelle sie kommen, unterdrückt werden.

Damit ist die Initialisierung beendet und das Hauptprogramm kann sich schlafen legen. Die '''loop: rjmp loop''' Schleife macht genau dieses.

Tritt nun ein Overflow am Timer auf, so wird über den Umweg über die Interrupt Vektor Tabelle der Programmteil timer0_overflow angesprungen. Dieser gibt einfach nur den Inhalt des Registers leds am Port B aus. Danach wird das leds Register mit einer '''com''' Operation negiert, so dass aus allen 0 Bits eine 1 wird und umgekehrt. Die Overflow Behandlung ist damit beendet und mittels '''reti''' wird der Interrupt Handler wieder verlassen.

==Simulation im AVR-Studio==

Es lohnt sich, den ganzen Vorgang im AVR-Studio simulieren zu lassen. Dazu am besten in der linken I/O View Ansicht die Einträge für PORTB und TIMER_COUNTER_0 öffnen. Wird mittels F11 durch das Programm gegangen, so sieht man, dass ab dem Moment, ab dem der Vorteiler auf 1 gesetzt wird, der Timer 0 im TCNT0 Register zu zählen anfängt. Mit jedem Druck auf F11 erhöht sich der Zählerstand. Irgendwann ist dann die Endlosschleife loop erreicht. Drücken Sie weiterhin F11 und beobachten sie, wie TCNT0 immer höher zählt, bis der Overflow erreicht wird. In dem Moment, in dem der Overflow erreicht wird, wird der Interrupt ausgelöst (hierfür muss für das Debuggen im AVR-Studio "Mask interrupts while stepping" deaktiviert sein, zu finden in Tools -> Options). Mit dem nächsten F11 landen sie in der Interrupt Vektor Tabelle und von dort geht es weiter zu timer_0_overflow. Weitere Tastendrücke von F11 erledigen dann die Ausgabe auf den Port B, das Invertieren des Registers r17 und der Interrupt ist damit behandelt. Nach dem '''reti''' macht der Microcontroller genau an der Stelle weiter, an der er vom Interrupt unterbrochen wurde. Und der Timer 0 hat in der Zwischenzeit weitergezählt! Nach exakt weiteren 256 Schritten, vom Auftreten des ersten Overflows an gerechnet, wird der nächste Overflow ausgelöst.

==Wie schnell schaltet denn jetzt der Port?==

Eine berechtigte Frage. Dazu müssen wir etwas rechnen. Keine Angst, es ist nicht schwer, und wer das Prinzip bisher verstanden hat, der sollte keine Schwierigkeiten haben, die Berechnung nachzuvollziehen.

Der Quarzoszillator schwingt mit 4 MHz. Das heißt, in 1 Sekunde werden 4000000 Taktzyklen generiert. Durch die Wahl des Vorteilers von 1 bedeutet das auch, dass der Timer 4000000 mal in der Sekunde erhöht wird. Von einem Overflow zum nächsten muss der Timer 256 Zählvorgänge ausführen. Also werden in 1 Sekunde 4000000 / 256 = 15625 Overflows generiert. Bei jedem Overflow schalten wir die LEDs jeweils in den anderen Zustand. D.h die LEDs blinken mit einer Frequenz von 7812.5 Hz. Das ist zuviel als dass wir es noch sehen könnten.

Was können wir also tun, um diese Blinkfrequenz zu verringern? Im Moment ist unsere einzige Einflussgröße der Vorteiler. Wie sieht die Rechnung aus, wenn wir einen Vorteiler von 1024 wählen?

Wiederrum: Der Systemtakt sei 4 Mhz. Durch den Vorteiler von 1024 werden daraus 4000000 / 1024 = 3906.25 Pulse pro Sekunde für den Timer. Der zählt wiederum 256 Zustände von einem Overflow zum nächsten. 3906.25 / 256 = 15.2587. Und wiederum: Im Overflow werden die LEDs ja abwechselnd ein und ausgeschaltet, also dividieren wir noch durch 2: 15.2587 / 2 = 7.629. Also knapp 7 Hz. Diese Frequenz müsste man schon mit freiem Auge sehen. Die LEDs werden ziemlich schnell vor sich hin blinken.

Reicht diese Verzögerung noch immer nicht, dann haben wir 2 Möglichkeiten:
* Entweder wir benutzen einen anderen Timer. Timer 1 beispielsweise ist ein 16 Bit Timer. Der Timer zählt also nicht von 0 bis 255 sondern von 0 bis 65535. Bei entsprechender Umarbeitung des Programms und einem Vorteiler von 1024 bedeutet das, dass die LEDs einen Ein/Aus Zyklus in 33 Sekunden absolvieren.
* Oder wir schalten die LEDs nicht bei jedem Timer Overflow um. Man könnte zum Beispiel in einem Register bis 7 zählen und nur dann, wenn dieses Register 7 erreicht hat, wird
** das Register wieder auf 0 gesetzt und
** die LEDs umgeschaltet.

==Timer 0==

Timer 0 ist ein 8 Bit Timer.

* Overflow Interrupt

===TCCR0===
====TCCR - Timer/Counter Control Register====
{{Byte |TCCR0 | | | | | | CS02 | CS01 | CS00 }}

====CS02/CS00 - Clock Select====

{| {{Tabelle}}
|- style="background-color:#ffddcc"
! CS02 || CS01 || CS00 || Bedeutung
|-
|align="center"|0
|align="center"|0
|align="center"|0
||keine (Der Timer ist angehalten)
|-
|align="center"|0
|align="center"|0
|align="center"|1
||Vorteiler: 1
|-
|align="center"|0
|align="center"|1
|align="center"|0
||Vorteiler: 8
|-
|align="center"|0
|align="center"|1
|align="center"|1
||Vorteiler: 64
|-
|align="center"|1
|align="center"|0
|align="center"|0
||Vorteiler: 256
|-
|align="center"|1
|align="center"|0
|align="center"|1
||Vorteiler: 1024
|-
|align="center"|1
|align="center"|1
|align="center"|0
||Vorteiler: Externer Takt vom Pin T0, fallende Flanke
|-
|align="center"|1
|align="center"|1
|align="center"|1
||Vorteiler: Externer Takt vom Pin T0, steigende Flanke
|}

===TIMSK - Timer/Counter
Interrupt Mask
Register===

{{Byte|TIMSK| | | | | | | OCIE0 | TOIE0 }}

====TOIE0 - Timer 0 Overflow Interrupt Enable====
Ist dieses Bit gesetzt, so wird beim Auftreten eines Overflows am Timer ein Interrupt ausgelöst.

Anstatt der Schreibweise
<syntaxhighlight lang="avrasm">
ldi temp, 0b00000001 ; TOIE0: Interrupt bei Timer Overflow
out TIMSK, temp
</syntaxhighlight>
ist es besser, die Schreibweise
<syntaxhighlight lang="avrasm">
ldi temp, 1 << TOIE0
out TIMSK, temp
</syntaxhighlight>
zu wählen, da hier unmittelbar aus dem Ladekommando hervorgeht, welche Bedeutung das gesetzte Bit hat. Die vorher inkludierte m8def.inc definiert dazu alles Notwendige.

==Timer 1==

Timer 1 ist ein 16 Bit Timer

* Overflow Interrupt
* Clear Timer on Compare Match
* Input Capture
* 2 Compare Einheiten
* div. PWM Modi

===TCCR1B===

{{Byte|TCCR1B| ICNC1| ICES1| | WGM13| WGM12| CS12 | CS11 | CS10 }}

====CS12/CS10 - Clock Select====

{| {{Tabelle}}
|- style="background-color:#ffddcc"
! CS12 || CS11 || CS10 || Bedeutung
|-
|align="center"|0
|align="center"|0
|align="center"|0
||keine (Der Timer ist angehalten)
|-
|align="center"|0
|align="center"|0
|align="center"|1
||Vorteiler: 1
|-
|align="center"|0
|align="center"|1
|align="center"|0
||Vorteiler: 8
|-
|align="center"|0
|align="center"|1
|align="center"|1
||Vorteiler: 64
|-
|align="center"|1
|align="center"|0
|align="center"|0
||Vorteiler: 256
|-
|align="center"|1
|align="center"|0
|align="center"|1
||Vorteiler: 1024
|-
|align="center"|1
|align="center"|1
|align="center"|0
||Vorteiler: Externer Takt vom Pin T1, fallende Flanke
|-
|align="center"|1
|align="center"|1
|align="center"|1
||Vorteiler: Externer Takt vom Pin T1, steigende Flanke
|}

====ICES1 - Input Capture Edge Select====
ICES1 = 0 , falling edge
ICES1 = 1 , rising edge

====ICNC1 - Input Capture Noise Canceler====

===TCCR1A===

{{Byte|TCCR1A|COM1A1|COM1A0|COM1B1|COM1B0|FOC1A |FOC1B |WGM11 |WGM10 }}

===OCR1A===

{{Byte|| |||||||}}

{{Byte|| |||||||}}

===OCR1B===
{{Byte|| |||||||}}

{{Byte|| |||||||}}

===ICR1===
{{Byte|| |||||||}}

{{Byte|| |||||||}}

===TIMSK1===
{{Byte|TIMSK| | |TICIE1|OCIE1A|OCIE1B|TOIE1 | |}}

====TICIE1 - Timer 1 Input Capture Interrupt Enable====

====OCIE1A - Timer 1 Output Compare A Match Interrupt Enable====

====OCIE1B - Timer 1 Output Compare B Match Interrupt Enable====

====TOIE1 - Timer 1 Overflow Interrupt Enable====

==Timer 2==
Timer 2 ist ein 8 Bit Timer.

* Overflow Interrupt
* Compare Match Interrupt
* Clear Timer on Compare Match
* Phasen korrekte PWM

===TCCR2===

{{Byte|TCCR2| FOC2 | WGM20| COM21| COM20| WGM21| CS22 | CS21 | CS20 }}

====WGM21 - Waveform Generator Mode====

Ist diese Option Aktiviert dann wird das Zählregister des Timers (TCNT2) wieder auf 0 gesetzt,
sobal das Register as Output Compare Register (OCR2) und TCNT2 übereinstimmen.
Zu beachten ist dabei das wenn das Register kleiner als 255 gestellt ist, wird
der Timer nicht mehr überschritten und der Interrupt für den Overflow (TIMER2_OVF_vect) nicht mehr ausgelöst.
Stattdessen gibt es den Interrupt für Compare Match (TIMER2_COMP_vect)
Die Frequenz für die Interruptauslösung lässt sich dann wie folgt berechnen:
ISR_Freq = F_CPU : ( Prescaler * ORC2 )

====CS22/CS20 - Clock Select====

{| {{Tabelle}}
|- style="background-color:#ffddcc"
! CS22 || CS21 || CS20 || Bedeutung
|-
|align="center"|0
|align="center"|0
|align="center"|0
||keine (Der Timer ist angehalten)
|-
|align="center"|0
|align="center"|0
|align="center"|1
||Vorteiler: 1
|-
|align="center"|0
|align="center"|1
|align="center"|0
||Vorteiler: 8
|-
|align="center"|0
|align="center"|1
|align="center"|1
||Vorteiler: 32
|-
|align="center"|1
|align="center"|0
|align="center"|0
||Vorteiler: 64
|-
|align="center"|1
|align="center"|0
|align="center"|1
||Vorteiler: 128
|-
|align="center"|1
|align="center"|1
|align="center"|0
||Vorteiler: 256
|-
|align="center"|1
|align="center"|1
|align="center"|1
||Vorteiler: 1024
|}

===OCR2===

{{Byte|| |||||||}}

===TIMSK2===
{{Byte|TIMSK| OCIE2| TOIE2| | | | | | }}

====OCIE2 - Timer 2 Output Compare Interrupt Enable====
====TOIE2 Timer 2 Overflow Interrupt Enable====

==Was geht noch mit einem Timer?==

Timer sind sehr universelle Microcontroller Bestandteile. Für weitergehende Studien ist es daher unerlässlich, das entsprechende Datenblatt des Microcontrollers zu studieren. Oft ist es z. B. möglich, dass der Timer bei erreichen von bestimmten Zählerständen einen Ausgabepin von sich aus ein-/aus-/umschaltet. Er erledigt dann das, was wir oben noch mit einem Interrupt gemacht haben, eigenständig komplett in Hardware. Bei einigen Timern ist es möglich, damit eine [[PWM]] (Pulsweiten-Modulation) aufzubauen.

Ein paar der Timermodule lassen sich auch als Counter verwenden. Damit kann man z. B. die Anzahl externer Ereignisse wie Schaltvorgänge eines Inkrementalgebers bestimmen.

Andere bieten die Möglichkeit, über einen externen Uhrenquarz getaktet zu werden (Anwendung z. B. eine "Echtzeituhr" oder als "Weckfunktion" aus einem Standby/Powerdownmodus).

Durch geschickte Umprogrammierung in Echtzeit, lässt sich mit einem Timer eine [[PLL]] aufbauen, die sich fortwährend auf einen Eingangstakt synchronisiert. Damit wird vermieden, dass der Controller ein Signal ständig abpollen muss, sondern das Signale wird per Timer-Interrupt verarbeitet. Massgeblich ist die Messung der aktuellen- und Schätzung der kommenden Flanke mithilfe eines einstellbaren [[Taktteiler]]-verhältnisses.

== Weblinks ==
* [http://www.uni-koblenz.de/~physik/informatik/MCU/Timer.pdf Timer/Counter und PWM beim ATMega16 Mikrocontroller] Proseminar von Marcel Jakobs, September 2006 (PDF)
* [http://frank.circleofcurrent.com/cache/avrtimercalc.htm AVR Timer Calculator]

----

{{Navigation_zurückhochvor|
zurücktext=Speicher|
zurücklink=AVR-Tutorial: Speicher|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Uhr|
vorlink=AVR-Tutorial: Uhr}}

[[Category:AVR-Tutorial|Timer]]
[[Category:Timer und Uhren]]

AVR-Tutorial: Timer

2015-03-04T00:23:57Z

2001:A60:13D1:CB01:352D:6309:9D08:7E1F: /* Simulation im AVR-Studio */

Timer sind eines der Hauptarbeitspferde in unserem Mikrocontroller. Mit ihrer Hilfe ist es möglich, in regelmäßigen Zeitabständen Aktionen zu veranlassen. Aber Timer können noch mehr!
* Timer können mit einem externen Pin hochgezählt werden
* Es gibt Möglichkeiten, bei bestimmten Zählerständen einen Interrupt auslösen zu lassen
* Timer können aber auch völlig selbstständig Signale an einem Ausgabepin erzeugen
* ...

Aber der Reihe nach und kurz zur Erinnerung: Die Beispiele passen zu einem ATmega8 und ggf. einer Reihe anderer AVR, können bei einigen Typen aber abweichen.

==Was ist ein Timer?==

Ein Timer ist im Grunde nichts anderes als ein bestimmtes Register im Mikrocontroller, das hardwaregesteuert fortlaufend um 1 erhöht (oder verringert) wird (statt um 1 erhöhen sagt man auch '''inkrementieren''', und das Gegenstück, '''dekrementieren''', bedeutet um 1 verringern). Anstatt also Befehle im Programm vorzusehen, die regelmäßig ausgeführt werden und ein Register inkrementieren, erledigt dies der Mikrocontroller ganz von alleine. Dazu ist es möglich, den Timer mit dem Systemtakt zu verbinden und so die Genauigkeit des Quarzes auszunutzen, um ein Register regelmäßig und vor allen Dingen unabhängig vom restlichen Programmfluss (!) hochzählen zu lassen.

Davon alleine hätte man aber noch keinen großen Gewinn. Nützlich wird das Ganze erst dann, wenn man bei bestimmten Zählerständen eine Aktion ausführen lassen kann. Einer der 'bestimmten Zählerstände' ist zum Beispiel der '''Overflow'''. Das Zählregister eines Timers kann natürlich nicht beliebig lange inkrementiert werden – z. B. ist der höchste Zählerstand, den ein 8-Bit-Timer erreichen kann, 28 – 1 = 255. Beim nächsten Inkrementierschritt tritt ein Überlauf (engl. Overflow) auf, der den Timerstand wieder zu 0 werden lässt. Und hier liegt der springende Punkt. Wir können uns nämlich an diesen Overflow "anhängen" und den Controller so konfigurieren, dass beim Auftreten des Timer-Overflows ein Interrupt ausgelöst wird.

Die kann auch alles nochmal im Datenblatt von Atmel zu einigen ATMega Datenblättern nachgelesen werden: http://www.atmel.com/Images/doc8161.pdf

==Der Vorteiler (Prescaler)==

Wenn also der Quarzoszillator mit 4 MHz schwingt, dann würde auch der Timer 4 Millionen mal in der Sekunde erhöht werden. Da der Timer jedes Mal von 0 bis 255 zählt, bevor ein Overflow auftritt, heißt das auch, dass in einer Sekunde 4000000 / 256 = 15625 Overflows vorkommen. Ganz schön schnell! Nur: Oft ist das nicht sinnvoll. Um diese Raten zu verzögern, gibt es den Vorteiler, oder auf Englisch, Prescaler. Er kann z.B. auf die Werte 1, 8, 64, 256 oder 1024 eingestellt werden, je nach Timer (Bitte Datenblatt konsultieren!). Seine Aufgabe ist es, den Systemtakt um den angegebenen Faktor zu teilen. Steht der Vorteiler also auf 1024, so wird nur bei jedem 1024-ten Impuls vom Systemtakt das Timerregister um 1 erhöht. Entsprechend weniger häufig kommen dann natürlich die Overflows. Der Systemtakt sei wieder 4000000. Dann wird der Timer in 1 Sekunde 4000000 / 1024 = 3906.25 mal erhöht. Da der Timer wieder jedesmal bis 255 zählen muss bis ein Overflow auftritt, bedeutet dies, dass in 1 Sekunde 3906.25 / 256 = 15.25 Overflows auftreten.

Systemtakt: 4Mhz

Vorteiler Overflows/Sekunde Zeit zwischen
2 Overflows [s]

1 15625 0.000064
8 1953.125 0.000512
64 244.1406 0.004096
256 61.0351 0.016384
1024 15.2587 0.065536

Die Zeit (in Sekunden) zwischen 2 Overflows lässt sich sehr leicht berechnen:
<math>t=\frac{2^\text{Bit des Timers} \cdot \text{Vorteiler}}{\text{Systemtakt in Hz}}</math> .

==Erste Tests==

Ein Programm, das einen Timer Overflow in Aktion zeigt, könnte z. B. so aussehen:

<syntaxhighlight lang="avrasm">
.include "m8def.inc"

.def temp = r16
.def leds = r17

.org 0x0000
rjmp main ; Reset Handler
.org OVF0addr
rjmp timer0_overflow ; Timer Overflow Handler

main:
; Stackpointer initialisieren
ldi temp, HIGH(RAMEND)
out SPH, temp
ldi temp, LOW(RAMEND)
out SPL, temp

ldi temp, 0xFF ; Port B auf Ausgang
out DDRB, temp

ldi leds, 0xFF

ldi temp, (1<<CS00) ; CS00 setzen: Teiler 1
out TCCR0, temp

ldi temp, (1<<TOIE0) ; TOIE0: Interrupt bei Timer Overflow
out TIMSK, temp

sei

loop: rjmp loop

timer0_overflow: ; Timer 0 Overflow Handler
out PORTB, leds
com leds
reti
</syntaxhighlight>

Das Programm beginnt mit der [[AVR-Tutorial:_Interrupts|Interrupt-Vektoren-Tabelle]]. Dort ist an der Adresse OVF0Addr ein Sprung zur Marke timer0_overflow eingetragen. Wenn also ein Overflow Interrupt vom Timer 0 auftritt, so wird dieser Interrupt durch den '''rjmp''' weitergeleitet an die Stelle timer0_overflow.

Das Hauptprogramm beginnt ganz normal mit der Belegung des Stackpointers. Danach wird der Port B auf Ausgang geschaltet, wir wollen hier wieder die LED anschliessen.

Durch Beschreiben von TCCR0 mit dem Bitmuster 0b00000001, hier ausgedrückt durch (1<<CS00), wird der Vorteiler auf 1 gesetzt. Für die ersten Versuche empfiehlt es sich, das Programm mit dem AVR-Studio zunächst zu simulieren. Würden wir einen größeren Vorteiler benutzen, so müsste man ziemlich oft mittels F11 einen simulierten Schritt ausführen, um eine Änderung im Timerregister zu erreichen.

Die nächsten Anweisungen setzen im TIMSK Register das TOIE0 Bit. Sinn der Sache ist es, dem Timer zu erlauben, bei Erreichen eines Overflow einen Interrupt auszulösen.

Zum Schluss noch die Interrupts generell mittels '''sei''' freigeben. Dieser Schritt ist obligatorisch. Im Mikrocontroller können viele Quellen einen Interrupt auslösen. Daraus folgt: Für jede mögliche Quelle muss festgelegt werden, ob sie einen Interrupt erzeugen darf oder nicht. Die Oberhoheit hat aber das globale Interrupt Flag. Mit ihm können alle Interrupts, egal von welcher Quelle sie kommen, unterdrückt werden.

Damit ist die Initialisierung beendet und das Hauptprogramm kann sich schlafen legen. Die '''loop: rjmp loop''' Schleife macht genau dieses.

Tritt nun ein Overflow am Timer auf, so wird über den Umweg über die Interrupt Vektor Tabelle der Programmteil timer0_overflow angesprungen. Dieser gibt einfach nur den Inhalt des Registers leds am Port B aus. Danach wird das leds Register mit einer '''com''' Operation negiert, so dass aus allen 0 Bits eine 1 wird und umgekehrt. Die Overflow Behandlung ist damit beendet und mittels '''reti''' wird der Interrupt Handler wieder verlassen.

==Simulation im AVR-Studio==

Es lohnt sich, den ganzen Vorgang im AVR-Studio simulieren zu lassen. Dazu am besten in der linken I/O View Ansicht die Einträge für PORTB und TIMER_COUNTER_0 öffnen. Wird mittels F11 durch das Programm gegangen, so sieht man, dass ab dem Moment, ab dem der Vorteiler auf 1 gesetzt wird, der Timer 0 im TCNT0 Register zu zählen anfängt. Mit jedem Druck auf F11 erhöht sich der Zählerstand. Irgendwann ist dann die Endlosschleife loop erreicht. Drücken Sie weiterhin F11 und beobachten sie, wie TCNT0 immer höher zählt, bis der Overflow erreicht wird. In dem Moment, in dem der Overflow erreicht wird, wird der Interrupt ausgelöst (hierfür muss für das Debuggen im AVR-Studio "Mask interrupts while stepping" deaktiviert sein, zu finden in Tools -> Options). Mit dem nächsten F11 landen sie in der Interrupt Vektor Tabelle und von dort geht es weiter zu timer_0_overflow. Weitere Tastendrücke von F11 erledigen dann die Ausgabe auf den Port B, das Invertieren des Registers r17 und der Interrupt ist damit behandelt. Nach dem '''reti''' macht der Microcontroller genau an der Stelle weiter, an der er vom Interrupt unterbrochen wurde. Und der Timer 0 hat in der Zwischenzeit weitergezählt! Nach exakt weiteren 256 Schritten, vom Auftreten des ersten Overflows an gerechnet, wird der nächste Overflow ausgelöst.

==Wie schnell schaltet denn jetzt der Port?==

Eine berechtigte Frage. Dazu müssen wir etwas rechnen. Keine Angst, es ist nicht schwer, und wer das Prinzip bisher verstanden hat, der sollte keine Schwierigkeiten haben, die Berechnung nachzuvollziehen.

Der Quarzoszillator schwingt mit 4 MHz. Das heißt, in 1 Sekunde werden 4000000 Taktzyklen generiert. Durch die Wahl des Vorteilers von 1 bedeutet das auch, dass der Timer 4000000 mal in der Sekunde erhöht wird. Von einem Overflow zum nächsten muss der Timer 256 Zählvorgänge ausführen. Also werden in 1 Sekunde 4000000 / 256 = 15625 Overflows generiert. Bei jedem Overflow schalten wir die LEDs jeweils in den anderen Zustand. D.h die LEDs blinken mit einer Frequenz von 7812.5 Hz. Das ist zuviel als dass wir es noch sehen könnten.

Was können wir also tun, um diese Blinkfrequenz zu verringern? Im Moment ist unsere einzige Einflussgröße der Vorteiler. Wie sieht die Rechnung aus, wenn wir einen Vorteiler von 1024 wählen?

Wiederrum: Der Systemtakt sei 4 Mhz. Durch den Vorteiler von 1024 werden daraus 4000000 / 1024 = 3906.25 Pulse pro Sekunde für den Timer. Der zählt wiederum 256 Zustände von einem Overflow zum nächsten. 3906.25 / 256 = 15.2587. Und wiederum: Im Overflow werden die LEDs ja abwechselnd ein und ausgeschaltet, also dividieren wir noch durch 2: 15.2587 / 2 = 7.629. Also knapp 7 Hz. Diese Frequenz müsste man schon mit freiem Auge sehen. Die LEDs werden ziemlich schnell vor sich hin blinken.

Reicht diese Verzögerung noch immer nicht, dann haben wir 2 Möglichkeiten:
* Entweder wir benutzen einen anderen Timer. Timer 1 beispielsweise ist ein 16 Bit Timer. Der Timer zählt also nicht von 0 bis 255 sondern von 0 bis 65535. Bei entsprechender Umarbeitung des Programms und einem Vorteiler von 1024 bedeutet das, dass die LEDs einen Ein/Aus Zyklus in 33 Sekunden absolvieren.
* Oder wir schalten die LEDs nicht bei jedem Timer Overflow um. Man könnte zum Beispiel in einem Register bis 7 zählen und nur dann, wenn dieses Register 7 erreicht hat, wird
** das Register wieder auf 0 gesetzt und
** die LEDs umgeschaltet.

==Timer 0==

Timer 0 ist ein 8 Bit Timer.

* Overflow Interrupt

===TCCR0===
====TCCR - Timer/Counter Control Register====
{{Byte |TCCR0 | | | | | | CS02 | CS01 | CS00 }}

====CS02/CS00 - Clock Select====

{| {{Tabelle}}
|- style="background-color:#ffddcc"
! CS02 || CS01 || CS00 || Bedeutung
|-
|align="center"|0
|align="center"|0
|align="center"|0
||keine (Der Timer ist angehalten)
|-
|align="center"|0
|align="center"|0
|align="center"|1
||Vorteiler: 1
|-
|align="center"|0
|align="center"|1
|align="center"|0
||Vorteiler: 8
|-
|align="center"|0
|align="center"|1
|align="center"|1
||Vorteiler: 64
|-
|align="center"|1
|align="center"|0
|align="center"|0
||Vorteiler: 256
|-
|align="center"|1
|align="center"|0
|align="center"|1
||Vorteiler: 1024
|-
|align="center"|1
|align="center"|1
|align="center"|0
||Vorteiler: Externer Takt vom Pin T0, fallende Flanke
|-
|align="center"|1
|align="center"|1
|align="center"|1
||Vorteiler: Externer Takt vom Pin T0, steigende Flanke
|}

===TIMSK===

{{Byte|TIMSK| | | | | | | OCIE0 | TOIE0 }}

====TOIE0 - Timer 0 Overflow Interrupt Enable====
Ist dieses Bit gesetzt, so wird beim Auftreten eines Overflows am Timer ein Interrupt ausgelöst.

Anstatt der Schreibweise
<syntaxhighlight lang="avrasm">
ldi temp, 0b00000001 ; TOIE0: Interrupt bei Timer Overflow
out TIMSK, temp
</syntaxhighlight>
ist es besser, die Schreibweise
<syntaxhighlight lang="avrasm">
ldi temp, 1 << TOIE0
out TIMSK, temp
</syntaxhighlight>
zu wählen, da hier unmittelbar aus dem Ladekommando hervorgeht, welche Bedeutung das gesetzte Bit hat. Die vorher inkludierte m8def.inc definiert dazu alles Notwendige.

==Timer 1==

Timer 1 ist ein 16 Bit Timer

* Overflow Interrupt
* Clear Timer on Compare Match
* Input Capture
* 2 Compare Einheiten
* div. PWM Modi

===TCCR1B===

{{Byte|TCCR1B| ICNC1| ICES1| | WGM13| WGM12| CS12 | CS11 | CS10 }}

====CS12/CS10 - Clock Select====

{| {{Tabelle}}
|- style="background-color:#ffddcc"
! CS12 || CS11 || CS10 || Bedeutung
|-
|align="center"|0
|align="center"|0
|align="center"|0
||keine (Der Timer ist angehalten)
|-
|align="center"|0
|align="center"|0
|align="center"|1
||Vorteiler: 1
|-
|align="center"|0
|align="center"|1
|align="center"|0
||Vorteiler: 8
|-
|align="center"|0
|align="center"|1
|align="center"|1
||Vorteiler: 64
|-
|align="center"|1
|align="center"|0
|align="center"|0
||Vorteiler: 256
|-
|align="center"|1
|align="center"|0
|align="center"|1
||Vorteiler: 1024
|-
|align="center"|1
|align="center"|1
|align="center"|0
||Vorteiler: Externer Takt vom Pin T1, fallende Flanke
|-
|align="center"|1
|align="center"|1
|align="center"|1
||Vorteiler: Externer Takt vom Pin T1, steigende Flanke
|}

====ICES1 - Input Capture Edge Select====
ICES1 = 0 , falling edge
ICES1 = 1 , rising edge

====ICNC1 - Input Capture Noise Canceler====

===TCCR1A===

{{Byte|TCCR1A|COM1A1|COM1A0|COM1B1|COM1B0|FOC1A |FOC1B |WGM11 |WGM10 }}

===OCR1A===

{{Byte|| |||||||}}

{{Byte|| |||||||}}

===OCR1B===
{{Byte|| |||||||}}

{{Byte|| |||||||}}

===ICR1===
{{Byte|| |||||||}}

{{Byte|| |||||||}}

===TIMSK1===
{{Byte|TIMSK| | |TICIE1|OCIE1A|OCIE1B|TOIE1 | |}}

====TICIE1 - Timer 1 Input Capture Interrupt Enable====

====OCIE1A - Timer 1 Output Compare A Match Interrupt Enable====

====OCIE1B - Timer 1 Output Compare B Match Interrupt Enable====

====TOIE1 - Timer 1 Overflow Interrupt Enable====

==Timer 2==
Timer 2 ist ein 8 Bit Timer.

* Overflow Interrupt
* Compare Match Interrupt
* Clear Timer on Compare Match
* Phasen korrekte PWM

===TCCR2===

{{Byte|TCCR2| FOC2 | WGM20| COM21| COM20| WGM21| CS22 | CS21 | CS20 }}

====WGM21 - Waveform Generator Mode====

Ist diese Option Aktiviert dann wird das Zählregister des Timers (TCNT2) wieder auf 0 gesetzt,
sobal das Register as Output Compare Register (OCR2) und TCNT2 übereinstimmen.
Zu beachten ist dabei das wenn das Register kleiner als 255 gestellt ist, wird
der Timer nicht mehr überschritten und der Interrupt für den Overflow (TIMER2_OVF_vect) nicht mehr ausgelöst.
Stattdessen gibt es den Interrupt für Compare Match (TIMER2_COMP_vect)
Die Frequenz für die Interruptauslösung lässt sich dann wie folgt berechnen:
ISR_Freq = F_CPU : ( Prescaler * ORC2 )

====CS22/CS20 - Clock Select====

{| {{Tabelle}}
|- style="background-color:#ffddcc"
! CS22 || CS21 || CS20 || Bedeutung
|-
|align="center"|0
|align="center"|0
|align="center"|0
||keine (Der Timer ist angehalten)
|-
|align="center"|0
|align="center"|0
|align="center"|1
||Vorteiler: 1
|-
|align="center"|0
|align="center"|1
|align="center"|0
||Vorteiler: 8
|-
|align="center"|0
|align="center"|1
|align="center"|1
||Vorteiler: 32
|-
|align="center"|1
|align="center"|0
|align="center"|0
||Vorteiler: 64
|-
|align="center"|1
|align="center"|0
|align="center"|1
||Vorteiler: 128
|-
|align="center"|1
|align="center"|1
|align="center"|0
||Vorteiler: 256
|-
|align="center"|1
|align="center"|1
|align="center"|1
||Vorteiler: 1024
|}

===OCR2===

{{Byte|| |||||||}}

===TIMSK2===
{{Byte|TIMSK| OCIE2| TOIE2| | | | | | }}

====OCIE2 - Timer 2 Output Compare Interrupt Enable====
====TOIE2 Timer 2 Overflow Interrupt Enable====

==Was geht noch mit einem Timer?==

Timer sind sehr universelle Microcontroller Bestandteile. Für weitergehende Studien ist es daher unerlässlich, das entsprechende Datenblatt des Microcontrollers zu studieren. Oft ist es z. B. möglich, dass der Timer bei erreichen von bestimmten Zählerständen einen Ausgabepin von sich aus ein-/aus-/umschaltet. Er erledigt dann das, was wir oben noch mit einem Interrupt gemacht haben, eigenständig komplett in Hardware. Bei einigen Timern ist es möglich, damit eine [[PWM]] (Pulsweiten-Modulation) aufzubauen.

Ein paar der Timermodule lassen sich auch als Counter verwenden. Damit kann man z. B. die Anzahl externer Ereignisse wie Schaltvorgänge eines Inkrementalgebers bestimmen.

Andere bieten die Möglichkeit, über einen externen Uhrenquarz getaktet zu werden (Anwendung z. B. eine "Echtzeituhr" oder als "Weckfunktion" aus einem Standby/Powerdownmodus).

Durch geschickte Umprogrammierung in Echtzeit, lässt sich mit einem Timer eine [[PLL]] aufbauen, die sich fortwährend auf einen Eingangstakt synchronisiert. Damit wird vermieden, dass der Controller ein Signal ständig abpollen muss, sondern das Signale wird per Timer-Interrupt verarbeitet. Massgeblich ist die Messung der aktuellen- und Schätzung der kommenden Flanke mithilfe eines einstellbaren [[Taktteiler]]-verhältnisses.

== Weblinks ==
* [http://www.uni-koblenz.de/~physik/informatik/MCU/Timer.pdf Timer/Counter und PWM beim ATMega16 Mikrocontroller] Proseminar von Marcel Jakobs, September 2006 (PDF)
* [http://frank.circleofcurrent.com/cache/avrtimercalc.htm AVR Timer Calculator]

----

{{Navigation_zurückhochvor|
zurücktext=Speicher|
zurücklink=AVR-Tutorial: Speicher|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Uhr|
vorlink=AVR-Tutorial: Uhr}}

[[Category:AVR-Tutorial|Timer]]
[[Category:Timer und Uhren]]