Timer

Allgemeines zu Timern
Timer 0
Timer 1
Timer 2
Beispiel für Timer0

Allgemeines zu Timern

Alle Flash-PICs besitzen mindestens einen Timer. Größere PICs haben derer sogar drei.
Ein Timer ist nichts anderes als eine normale Zählschaltung. Sein Eingang kann mit einem I/O-Pin oder mit dem internen PIC-Takt verbunden werden. Dann zählt er mit dem eingespeisten Takt. Ist der Zähler mit dem PIC-Takt verbunden wird er im Allgemeinen als Timer bezeichnet. Ist er mit einem externen I/O-Pin verbunden, bezeichnet man ihn auch als Counter.

Jeder Zähler läuft einmal über. Ein 8-Bit Timer kann von 0 bis 255 zählen, ein 16-Bit-Timer kommt bis 65535. Hat der Timer seinen höchsten Zählwert erreicht, und bekommt dann einen weiteren Zählimpuls, dann springt er wieder auf 0 und kann von vorn beginnen. Bei diesem Überlauf gibt der Timer ein Signal aus, das ein bestimmtes Bit in einem Register des PIC setzt. Wenn man dieses Bit abfragt, weiß man also, ob der Timer übergelaufen ist. Das kann man in einem Programm als Zeitbasis nutzen. Außerdem kann beim Überlauf auch ein Interrupt ausgelöst werden. Das erspart das dauernde Abfragen (pollen) des Überlaufbits.

Der momentane Zählerstand des Timers ist nicht geheim, er liegt immer in einem speziellen Register, von wo man ihn auslesen kann. Man kann dieses Register auch beschreiben, und dadurch den Timer auf einen bestimmten Wert setzen, von dem er dann weiterzählt.

PICs besitzen bis zu 3 Timer: (PIC18Fxxx haben bis zu 5 Timer)

• Timer0 - 8 Bit , Vorteiler
• Timer1 - 16 Bit, Vorteiler
• Timer2 - 8 Bit, Vorteiler&Nachteiler, Periodenregister
• Timer3 - 16 Bit, Vorteiler (ähnlich wie Timer1)
• Timer4 - 8 Bit, Vorteiler&Nachteiler, Periodenregister  (ähnlich wie Timer2)

Timer 0

Der Timer 0 gehört zur Grundausstattung aller Flash-PICs. Er ist ein 8-Bit-Timer, kann also nur bis 255 zählen.

Seine Zählimpulse erhält er entweder über das Pin RA4, oder er wird mit 1/4 des PIC-Taktes gespeist. Der ausgewählte Takt kann direkt auf den Zähler gegeben werden, oder man verwendet einen Vorteiler, dessen Teilverhältnis von 1:2 bis zu 1:256 in 8 Stufen eingestellt werden kann.  Der Zähler zählt vorwärts von 0 bis 255 und beginnt dann von vorn. Der momentane Zählerstand ist im Register TMR0 zugänglich.  Bei Überlauf wird das Bit T0IF im INTCON Register gesetzt.

Die Programmierung des Timer0 erfolgt im Register OPTION_REG mit den Bits T0SE, T0CS, PSA sowie PS2..0.

T0CS (Timer0 clock source select)
Mit diese Bit wählt man die Taktquelle des Timer0 aus

• 0 - der Takt ist 1/4 des PIC-Taktes (bei einem 10 MHz-Quarz also 2,5 MHz)
• 1 - derTakt kommt vom Pin RA4

• 0 - Low-High-Flanke wird gezählt
• 1 - High-Low-Flanke wird gezählt

• 0 - der Vorteiler wird verwendet
• 1 -  den Vorteiler nicht verwenden

• PS2, PS1, PS0 = '000' - Teilverhältnis 2:1
• PS2, PS1, PS0 = '001' - Teilverhältnis 4:1
• PS2, PS1, PS0 = '010' - Teilverhältnis 8:1
• PS2, PS1, PS0 = '011' - Teilverhältnis 16:1
• PS2, PS1, PS0 = '100' - Teilverhältnis 32:1
• PS2, PS1, PS0 = '101' - Teilverhältnis 64:1
• PS2, PS1, PS0 = '110' - Teilverhältnis 128:1
• PS2, PS1, PS0 = '111' - Teilverhältnis 256:1

Den Vorteiler muss sich der Timer0 mit dem WDT (Watch dog timer) teilen. Da ein richtiges Teilen dieser Hardware kaum möglich ist, muss man sich also entscheiden, ob man den Vorteiler für den Timer0 oder für den WDT verwenden will.

Wenn man den Vorteiler für dem Timer0 verwendet, dann führt jeder schreibende Zugriff auf TMR0 dazu, das der Vorteiler die bereits gezählten Pulse wieder vergisst. Bei einem Vorteilerverhältnis von 256:1 gehen durch einen schreibenden Zugriff auf TMR0 also durchschnittlich über 100 Impulse verloren. Das muss man immer dann bedenken, wenn man mit dem Timer0 hochgenaue Zeitabläufe steurn will ( z.B. in einer Uhr).

Hinweis:
In PICs der Serien PIC18Fxxx wird ein Timer0 verwendet, der sich auf 16-Bit Breite umschalten lässt.
Die modernen PIC24, dsPIC...  haben keinen Timer0 mehr.

Timer1

Der Timer 1 ist ein 16-Bit Timer, der seine Zählimpulse entweder vom PIC-Takt oder vom I/O-Pin RC1 bzw. RC0 erhält. Der ausgewählte Takt wird durch einen Vorteiler, einen Synchronisator (wenn ausgewählt) und eine Torstufe zum 16-Bit-Zähler geleitet. Der Zähler zählt von 0 (0000h) bis 65535 (FFFFh). Dann läuft er über und beginnt bei 0 von vorn. Beim Überlauf wird das Bit TMR1IF gesetzt, das auch einen Interrupt auslösen kann (wenn aktiviert). Der Zählerstand kann über die beiden Register TMR1L (low-Teil) und TMR1H (High-Teil) ausgelesen und verändert  werden. Das CCP-Modul benötigt Timer1 für die Capture- sowie für die Compare-Funktion. Wird eine dieser Funktionen im CCP-Modul aktiviert, steht der Timer1 also nicht mehr frei zur Verfügung.

Der Eingang RC0/RC1
Das Pins RC0 kann den Timer1 als Input-Pin mit Pulsen versorgen. Es besteht aber auch die Möglichkeit, das Pin RC1 über einen Verstärker zum Pin RC0 zu schalten. dann wird RC0 automatisch Output-Pin und RC1 dient nun als Takt-Eingang. Sinn des ganzen ist es, mit RC0, RC1 und dem Verstärker einen Oszillator aufzubauen (entspricht dem Oszillator für den PIC-Takt im LP-Mode). Dazu werden RC0 und RC1 mit einem Resonator (z.B. einem Quarz) verbunden. Dieser wird durch den Verstärker zum Schwingen angeregt. Diese Schwingung is dann das Timer1 Inputsignal. Der Oszillator ist für Frequenzen bis zu maximal 200 kHz ausgelegt.
Wenn an RC0&RC1 ein 32,768kHz-Uhrenquarz angeschlossen wird, lässt sich mit dem Timer1 ein Zeitnormal aufbauen. (Oft benötigt man zur Ablaufsteuerung im Programm eine 'Uhr'.)
Bei einigen neueren Typen wie z.B. 16F87xA ist der Oszillator für 32,768 kHz optimiert. Dadurch ist die Funktion bis hinauf zu 200 kHz nicht mehr garantiert.

Vorteiler
Der Vorteiler des Timer1 ist immer im Signalpfad der Eingangspulse, beherrscht aber neben 8:1, 4:1 und 2:1 auch das Teilverhältnis 1:1, wodurch er sich dann nicht störend auswirkt.

Synchronisator
Der Synchronisator synchronisiert den Vorteilerausgang mit dem internen Zyklustakt (1/4 des externen PIC-Taktes). Der Synchronisator kann, aber muss nicht ausgewählt werden.

Torstufe
Durch die Torstufe kann der Eingang des Zählers für Impulse gesperrt werden.
 

Die Programmierung des Timer1 erfolgt im Register T1CON mit den Bits T1CKPS1&0, T1OSCEN, T1SYNC, TMR1CS sowie TMR1ON.

TMR1CS (Timer1 clock source select)
Mit diese Bit wählt man die Taktquelle des Timer1 aus

• 0 - der Takt ist 1/4 des PIC-Taktes (bei einem 10 MHz-Quarz also 2,5 MHz)
• 1 - derTakt kommt vom Pin RC0 bzw. RC1

• 0 - RC0 ist der Takteingang des Timer1
• 1 - RC1 ist der Takteingang des Timer1, an RC0 (nun Output) liegt das invertierte RC1-Signal an.

      Wird ein Quarz (bis wenige 100 kHz) zwischen RC0 und RC1 angeschlossen (+ 2 Kondensatoren)
     dann schwingt dieser und liefert den Takt für Timer1.

• T1CKPS1, T1CKPS0 = '00' - Teilverhältnis 1:1
• T1CKPS1, T1CKPS0 = '01' - Teilverhältnis 2:1
• T1CKPS1, T1CKPS0 = '10' - Teilverhältnis 4:1
• T1CKPS1, T1CKPS0 = '11' - Teilverhältnis 8:1

• 0 - der Syncronisator ist aktiv
• 1 - der Syncronisator wird nicht benutzt

• 0 - keine Impulse gelangen zum Zähler, der Timer1 steht still
• 1 - Impulse werden zum Zähler geleitet, der Timer1 läuft

Beispiel:

• Der Timer1 steht auf 01FFh.
• Wir lesen TMR1H = 01h.
• Der Timer incrementiert auf 0200h.
• Wir lesen TMR1L = 00h.
• Der ausgelesene Zählerstand ist 0100h - völlig falsch

• Der Timer1 steht auf 01FFh.
• Wir lesen TMR1L = FFh.
• Der Timer incrementiert auf 0200h.
• Wir lesen TMR1H = 02h.
• Der ausgelesene Zählerstand ist 02FFh - völlig falsch

Alternativ kann man den Timer1 natürlich auch mit TMR1ON=0 vorübergehend anhalten, aber das ist oft nicht gewünscht.

Ein ähnliches Problem ist das Schreiben in TMR1H und TMR1L:
 

; Einschreiben eines 16-Bit-Wertes in den laufenden Timer1************* TM1_write         clrf    TMR1L           ; Low Byte löschen = demnächst kommt kein Überlauf         movlw   Time_H2         ; High Byte laden         movwf   TMR1H, f        ; High Byte schreiben         movlw   Time_L2         ; Low  Byte laden         movwf   TMR1L, f        ; Low  Byte schreiben

Die Zählgeschwindigkeit des Timer1 ist im synchronen Mode begrenzt auf 1/4 des PIC-Taktes. Ein mit 20 MHz getakteter PIC kann seinen Timer1 also maximal mit 5 MHz zählen lassen. Dabei ist es egal, ob der interne Takt oder der Takt von RC0 genommen wird. Diese Begrenzung gilt aber nicht für den Vorteiler. Mit einem Vorteilerverhältnis von 8:1 lässt sich also theoretisch eine Frequenz von max 40 MHz an RC0 zählen. Der Hersteller garantiert in dieser Betriebsart 33 MHz.
Die Funktion des Timer1 ist im asynchronen Mode nur bis 16 MHz (an RC0) garantiert.

Timer2

Der 'Timer2 ist vielleicht schon vom PWM-Modul her bekannt, dort wird er nämlich zur PWM-Erzeugung benutzt.  Der Timer2 ist ein 8-Bit-Timer mit Vorteiler und Nachteiler. Mit seinen 8-Bit macht er eigentlich nicht viel her, er besitzt aber den Vorteil, dass man einstellen kann, wie weit er zählen soll, bevor er wieder bei Null anfängt. Man kann ihn also so programmieren, dass er z.B. immer von 0 bis 100 Zählt, und dann wieder bei 0 startet. (Bei den anderen Timern lässt sich so etwas nur per Software mit Hilfe eines Interrupts erreichen.) Der Timer2 kann ausschließlich durch den internen PIC-Takt getaktet werden. Dazu wird der PIC-Takt zunächst durch 4 geteilt, um den Zyklustakt zu erhalten. Dieser kann dann noch durch 4 oder durch 16 geteilt werden, bevor er in den 8-Bit Zähler eingespeist wird. Dieser Zähler zählt mit jedem Takt einen Schritt vorwärts. Der Zahlenwert im Zähler kann jederzeit durch das Programm ausgelesen oder verändert werden. Das erfolgt durch Lesen oder Schreiben auf das Register TMR2.

Der Wert im Timer2 wird durch einen Vergleicher ständig mit dem Wert im Register PR2 verglichen. Erreicht der Timer2 den Wert in PR2, dann gibt der Vergleicher ein Signal aus, das den Timer2 beim nächsten Takt auf 0 setzt.
Dieses Signal setzt über den Nachteiler auch das Interrupt-Flag TMR2IF. Da der Nachteiler auf jedes Teilverhältnis von 1:1 bis 16:1 eingestellt werden kann, benötigt es 1 bis 16 Durchläufe von Timer2, bis das Interrupt-Flag gesetzt wird.

Das im Blockschaltbild zu sehende 'TMR2-output'-Signal geht zum CCP-Modul, und kann dort für die PWM-Erzeugung benutzt werden.

Die Programmierung des Timer2 erfolgt im Register T2CON

TOUTPS3 ... TOUTPS0 (Timer2 Output Postscale Select bits)
Hier stellt man das Teilverhältnis des Nachteilers ein

• 0000 -  Teilverhältnis 1:1
• 0001 -  Teilverhältnis 2:1
• 0010 -  Teilverhältnis 3:1
• 0011 -  Teilverhältnis 4:1
• .....
• 1101 -  Teilverhältnis 14:1
• 1110 -  Teilverhältnis 15:1
• 1111 -  Teilverhältnis 16:1

• 0 - Timer 2 ist aus
• 1 - Timer 2 ist an

• T2CKPS1, T2CKPS0 = '00' - Teilverhältnis 1:1
• T2CKPS1, T2CKPS0 = '01' - Teilverhältnis 4:1
• T2CKPS1, T2CKPS0 = '10' - Teilverhältnis 16:1
• T2CKPS1, T2CKPS0 = '11' - Teilverhältnis 16:1

Beispiel für Timer0
Das folgende Beispiel entstammt dem Lernbeispiel LED-Ziffernanzeige. Hier wird der Timer0 benutzt, um alle 4 ms einen Interrupt auszulösen
Der PIC-Takt beträgt 4 MHz. Der Timer0 wird über den Vorteiler an den internen Takt (4 MHz / 4 = 1 MHz) angeschlossen. Der Vorteiler wird auf ein Teilverhältnis von 32:1 eingestellt. Damit gibt der Vorteiler alle 32 µs einen Impuls an den Timer0 ab. Nach 125 solchen Impulsen sind 4 ms vorbei. Deshalb wird der Timer0 am Beginn (und dann auch in jedem Interrupt) auf den Wert 131 eingestellt.. Nach 125 Impulsen läuft er dann jeweils über.
 

; Tektquelle: 4 MHz ;************************************************************** ; Includedatei für den 16F84 einbinden         #include <P16f84.INC> ; Configuration festlegen ; bis 4 MHz: Power on Timer, kein Watchdog, XT-Oscillator         __CONFIG        _PWRTE_ON & _WDT_OFF & _XT_OSC ;************************************************************** ; Variablennamen vergeben w_copy  Equ     0x20            ; Backup für Akkuregister s_copy  Equ     0x21            ; Backup für Statusregister ;************************************************************** ; los gehts mit dem Programm         org     0         goto    Init  ;************************************************************** ; die Interruptserviceroutine         org     4  intvec  bcf     INTCON, GIE     ; disable Interrupt         movwf   w_copy          ; w retten         swapf   STATUS, w       ; STATUS retten         movwf   s_copy          ;         movlw   D'131'          ; 256-125=131 ((1MHz : 32 ): 125 = 250 Hz)         movwf   TMR0 ; Intrrupt servic routine Int_serv  ;hier folgt die eigentliche Interrupt-Routine,  ;die 250 mal pro Sekunde aufgerufen wird   Int_end swapf   s_copy, w       ; STATUS zurück         movwf   STATUS          swapf   w_copy, f       ; w zurück mit flags         swapf   w_copy, w         bcf     INTCON, T0IF    ; Interrupt-Flag löschen         bsf     INTCON, GIE     ; enable Interrupt (macht RETFIE aber auch allein)         retfie ;************************************************************** ;Initialisierung am Anfang des Programms Init ; 250 Hz-Timer-Interrupt einstellen         bsf     STATUS, RP0     ; auf Bank 1 umschalten         movlw   B'10000100'     ; internen Takt zählen, Vorteiler zum Timer0, 32:1         movwf   OPTION_REG         movlw   D'131'          ; 256-125=131 ((1MHz : 32 ): 125 = 250 Hz)         bcf     STATUS, RP0     ; auf Bank 0 zurückschalten         movwf   TMR0         bsf     INTCON, T0IE    ; Timer0 interrupt erlauben         bsf     INTCON, GIE     ; Interrupt erlauben loop    goto    loop            ; eine Endlosschleife ;**********************************************************           end