Timer/Counter (Avr) - Versionsgeschichte

Besserwessi: /* Normaler Modus (Normal Mode) */

2014-11-08T11:35:48Z

‎Normaler Modus (Normal Mode)

Besserwessi: /* Normaler Modus (Normal Mode) */ Hinweis auf ISR() statt Signal()

2014-02-28T13:03:20Z

‎Normaler Modus (Normal Mode): Hinweis auf ISR() statt Signal()

Besserwessi am 28. Februar 2014 um 11:10 Uhr

2014-02-28T11:10:41Z

Besserwessi: /* Input Capture */

2013-03-29T11:19:35Z

‎Input Capture

Besserwessi: /* Input Capture */

2013-03-29T11:08:52Z

‎Input Capture

Besserwessi: /* Die Betriebsmodi */ Satz verschoben, Kleinigkeiten

2012-02-13T17:47:29Z

‎Die Betriebsmodi: Satz verschoben, Kleinigkeiten

Besserwessi: /* Normaler Modus (Normal Mode) */ Ergänzung zu Beispiel

2012-02-04T23:34:59Z

‎Normaler Modus (Normal Mode): Ergänzung zu Beispiel

Chypsylon: /* Weblinks */

2011-09-04T13:33:54Z

‎Weblinks

Besserwessi: /* Input Capture */

2010-09-11T11:45:55Z

‎Input Capture

Besserwessi: /* Normaler Modus (Normal Mode) */

2010-09-07T19:47:10Z

‎Normaler Modus (Normal Mode)

@@ Zeile 48: / Zeile 48: @@
 Damit haben wir den Wert errechnet, der bei jedem Interrupt, den der Timer0 auslöst, in TCNTx (in diesem Fall TCNT0) nachgeladen werden muss, damit die Interrupts in dem gewünschten Zeitabstand von einer Millisekunde ausgelöst werden.
-Zwischen dem Timer Overflow und dem tatsächlichen Aufrufen der ISR mit dem Nachladen des Timers ergibt sich eine kleine Verzögerung, die nicht einmal immer gleich ist. Bei einem genügend großen Prescaler (z.B. 64) kommt durch die Verzögerung kein zusätzlicher Timerschritt zustande, und auch die Methode mit dem Nachladen liefert exacte Ergebnisse. Bei kleinen Prescalern kommt  es durch die Verzögerung zu längeren und nicht immer gleichen Zeitabständen.  Wenn möglich wird für die Erzeugung einer konstanten Interruptrate deshalb besser der CTC Moduls benutzt.
+Zwischen dem Timer Overflow und dem tatsächlichen Aufrufen der ISR mit dem Nachladen des Timers ergibt sich eine kleine Verzögerung, die nicht einmal immer gleich ist. Bei einem genügend großen Prescaler (z.B. 64) kommt durch die Verzögerung kein zusätzlicher Timerschritt zustande, und auch die Methode mit dem Nachladen liefert exakte Ergebnisse. Bei kleinen Prescalern kommt  es durch die Verzögerung zu längeren und nicht immer gleichen Zeitabständen.  Wenn möglich wird für die Erzeugung einer konstanten Interruptrate deshalb besser der CTC Moduls benutzt.
-Zusammenfassend ein Beispielprogramm:
+Zusammenfassend ein Code-Beispiel (kein vollständiges Programm):
 <pre>

@@ Zeile 61: / Zeile 61: @@
 // ISR zum auffangen der Interrupts:
-SIGNAL(SIG_SIG_OVERFLOW2)
+SIGNAL(SIG_SIG_OVERFLOW2)       // alter Form, für neuere GCC Versionen:   ISR(TIMER2_OVF_vect)
+{
 	TCNT2 = 244;		// Nachladen
@@ Zeile 68: / Zeile 68: @@
 // Initialisierung:
-TCCR2 = (1<<CS22);		// Prescaler von 64
+TCCR2 = (1<<CS22);		// Prescaler von 64 und damit Timer starten
 TCNT2  = 244;			// Vorladen
-TIMSK |= (1<<TOIE2);		// Interrupts aktivieren und damit Timer starten
+TIMSK |= (1<<TOIE2);		// Interrupts aktivieren
 sei();

@@ Zeile 2: / Zeile 2: @@
 Die Konfigurationsmöglichkeiten sind von Timer zu Timer unterschiedlich.
-'''Hinweis:''' Die folgenden Code-Beispiele sind in C programmiert und wurden für einen [[ATMega32|ATmega32]] entwickelt. Sie lassen sich also ohne große Änderungen auch auf anderen Mikrocontrollern der AVR-Familie einsetzen.
+'''Hinweis:''' Die folgenden Code-Beispiele sind in C programmiert und wurden für einen [[ATMega32|ATmega32]] entwickelt. Sie lassen sich also ohne große Änderungen auch auf anderen Mikrocontrollern der AVR-Familie einsetzen. Allerdings hat Atmel bei den neueren µCs (etwa Mega88, Mega324 und fast alle der aktuellen Tiny) die Namen für die Register vielfach geändert.
 == Allgemeine Funktionsweise ==

@@ Zeile 97: / Zeile 97: @@
 ==== Input Capture ====
-Die 16 Bit Timer haben eine "Input Capture" Funktion. Dieser Hardwareteil dient zur genauen Zeitmessung. Außer in einigen PWM Betriebsarten, wo das ICP Register als TOP-wert für den Timer benutzt wird, ist die ICP-Funktion immer aktiv. Wenn am ICP Pin die über das Bit "ICESx" eingestellte Flanke auftritt, wird der aktuelle Zählerstand in das ICP Register kopiert. Außerdem kann ein Interrupt ausgelöst werden. Der Interrupt wird, wie die anderen Timer Interrupts, in den Registern TIMSK und TIFR an- oder abgestellt. Man kann zwar die ICP-Funktion selber nicht ohne weiteres abschalten, aber natürlich den dazugehörigen Interrupt.  Als eine spezielle Funktion ("Noise Cancler") gibt es die Möglichkeit sehr kurze Pulse (unter 4 Zyklen) zu unterdrücken. In der Regel kann man diese Funktion angestellt lassen, denn so schnell kann man die Daten ohnehin nicht verarbeiten.
+Die 16 Bit Timer haben eine "Input Capture" Funktion. Dieser Hardwareteil dient zur genauen Zeitmessung. Die typische Anwendung ist die Messung von kurze Zeiten, wie z.B. die Zeit für eine Motorumdrehung. Außer in einigen PWM Betriebsarten, wo das ICP Register als TOP-wert für den Timer benutzt wird, ist die ICP-Funktion immer aktiv. Wenn am ICP Pin die über das Bit "ICESx" eingestellte Flanke auftritt, wird der aktuelle Zählerstand in das ICP Register kopiert. Außerdem kann ein Interrupt ausgelöst werden. Der Interrupt wird, wie die anderen Timer Interrupts, in den Registern TIMSK und TIFR an- oder abgestellt. Man kann zwar die ICP-Funktion selber nicht ohne weiteres abschalten, aber natürlich den dazugehörigen Interrupt.  Als eine spezielle Funktion ("Noise Cancler") gibt es die Möglichkeit sehr kurze Pulse (unter 4 Zyklen) zu unterdrücken. In der Regel kann man diese Funktion angestellt lassen, denn so schnell kann man die Daten ohnehin nicht verarbeiten.
-Die typische Anwendung ist die Messung von kurze Zeiten, wie z.B. die Zeit für eine Motorumdrehung. Solange die 16 Bit des Timers ausreichen ist die Benutzung ganz einfach: Der Timer wird mit dem gewünschten Vorteiler im normalen Modus gestartet. Im ICP-Interrupt wird die Differenz aus zwei aufeinanderfolgenden Zeiten (Werte in ICP-Register) berechnet. Dazu wird jeweils die vorherige Zeit im RAM zwischengespeichert. Wenn man bei der Rechnung eventuelle Überläufe ignoriert, bekommt man die richtige Zeitdifferenz, auch wenn der Timer während der Messzeit einen Überlauf hatte. Das funktioniert so einfach, denn wenn noch weitere (höherwertige) Bytes vorhanden wären, damit es keinen Überlauf gibt, würde man genau so die unteren Bits berechnen.
+Solange die 16 Bit des Timers ausreichen ist die Benutzung ganz einfach: Der Timer wird mit dem gewünschten Vorteiler im normalen Modus gestartet. Im ICP-Interrupt wird die Differenz aus zwei aufeinanderfolgenden Zeiten (Werte in ICP-Register) berechnet. Dazu wird jeweils die vorherige Zeit im RAM zwischengespeichert. Wenn man bei der Rechnung (vorzeichenlose 16 Bit Zahlen) eventuelle Überläufe ignoriert, bekommt man die richtige Zeitdifferenz, auch wenn der Timer während der Messzeit einen Überlauf hatte. Das funktioniert so einfach, denn wenn noch weitere (höherwertige) Bytes vorhanden wären, damit es keinen Überlauf gibt, würde man genau so die unteren Bits berechnen.
-Etwas komplizierter wird es, wenn die 16 Bit Auflösung nicht mehr ausreicht. Dann kann der Timer-Überlauf benutzt werden, um auch längere Zeiten mit voller Auflösung zu messen. Die wesentliche Schwierigkeit ist es, den Fall zu berücksichtigen, dass ein Überlauf Interrupt und der ICP Interrupt fast gleichzeitig ausgelöst werden. Es kann passieren, dass der ICP-Interrupt aufgerufen wird, obwohl eigentlich erst der Overflow Interrupt dran gewesen wäre. Dieser seltene Fall läßt sich daran erkennen, dass das Overflow-Interrupt Flag gesetzt ist und der Wert im ICP Register klein ist (high Byte < 128, meistens 0).
+Etwas komplizierter wird es, wenn die 16 Bit Auflösung nicht mehr ausreicht. Dann kann der Timer-Überlauf benutzt werden, um auch längere Zeiten mit voller Auflösung zu messen. Die wesentliche Schwierigkeit ist es, den Fall zu berücksichtigen, dass ein Überlauf Interrupt und der ICP Interrupt fast gleichzeitig ausgelöst werden. Es kann passieren, dass der ICP-Interrupt aufgerufen wird, obwohl eigentlich erst der Overflow Interrupt dran gewesen wäre. Dieser seltene Fall lässt sich daran erkennen, dass das Overflow-Interrupt Flag gesetzt ist und der Wert im ICP Register klein ist (high Byte < 128, meistens 0).
 Beispielpropgramm (für GCC):

@@ Zeile 183: / Zeile 183: @@
   PORTC = 0xFF;  		  // Pullups an Eingängen
   DDRD  = (1<<PD1);                // Eingänge, außer PD1 = Tx (UART)
-  PORTC = 0xFF- (1<<PD1);          // Pullups an alle Eingängen (außer TX)
+  PORTD = 0xFF- (1<<PD1);          // Pullups an alle Eingängen (außer TX)
 // Timer1 initialisieren:
   TCCR1A = 0;                      // normal mode, keine PWM Ausgänge
@@ Zeile 194: / Zeile 194: @@
   zeitdifferenz = 0;
-  softtimer = 0;      // wird für Zeitdifferenzmessung nicht mal gebraucht,
+  softtimer = 0;         // wird für Zeitdifferenzmessung nicht mal gebraucht,
-                     // denn Differenz geht auch über Überlauf bei Softtimer
+                        // denn Differenz geht auch über Überlauf bei Softtimer
   set_sleep_mode (SLEEP_MODE_IDLE);  // idle Mode: timer läuft weiter, int zum aufwachen
-  sei();              // Interrupts erlauben: Messung startet
+  sei();                 // Interrupts erlauben: Messung startet
   while (1)
+  {
@@ Zeile 211: / Zeile 211: @@
    if (zeit > 0)
+   {
-     ultoa(zeit,puffer,10);   // nach ASCII umwandeln
+     ultoa(zeit,puffer,10);  // nach ASCII umwandeln
      i = 0;
      while (puffer[i])
@@ Zeile 217: / Zeile 217: @@
        putser(puffer[i++]);  // Ausgabe
+      }
-     putser(13);             // Zeilenumbruch senden
+     putser(13); putser(10); // Zeilenumbruch senden
-    putser(10);
+   }
   }  // Ende von While-schleife

@@ Zeile 94: / Zeile 94: @@
 Dieses Beispiel zeigt nicht unbedingt eine vorbildliche Nutzung des Timers. Eine ISR einfach nur zum schnellen Hochzählen der Zeit verbraucht recht viel Rechenzeit und sollte sonst eher vermieden werden. Das Hochzählen der "Zeit" ist eigentlich genau das, was der Timer in Hardware macht - nur halt nicht immer in geraden Zeitschritte, wie 0,1 ms, sondern halt in den Schritten, die der Prescaler vorgibt (z.B. 256 Takte). Die Umrechnung kann man aber gut auch bei der Wartezeit vorher, oder bei einer gemessenen Zeit nachher machen.
 ==== Input Capture ====
@@ Zeile 114: / Zeile 112: @@
 // mit leichten Anpassungen auch für Tiny2313, Mega16, Mega32,...
-#include <stdlib.h>         // für utoa
+#include <stdlib.h>          // für utoa
 #include <avr/io.h>
 #include <avr/interrupt.h>
-#include <avr/sleep.h>      // Unterstützung für sleep mode
+#include <avr/sleep.h>       // Unterstützung für sleep mode
-// #define F_CPU  1000000UL      // Definition der Frequenz ist normal in makefile
+#define F_CPU  1000000UL     // Definition der Frequenz, ist ggf. im makefile
 #define BAUD        19200UL
 #define UBRR_BAUD   ((F_CPU/(16UL*BAUD))-1)
-typedef union {  // union erlaubt einen effektiven, seperaten Zugriff auf Teile der Variable
+typedef union {  // union erlaubt einen effektiven, separaten Zugriff auf Teile der Variable
          unsigned long i32;
          struct {uint8_t i8l;        // low
@@ Zeile 131: / Zeile 129: @@
                } convert32to8;
-volatile unsigned long timestamp;    // volatile wegen Zugriff im Interrrupt
+volatile unsigned long timestamp;    // volatile wegen Zugriff im Interrupt
 volatile unsigned int softtimer;
 volatile unsigned long zeitdifferenz;
 unsigned long zeit;
-char puffer[12];           // puffer für Ausgabe als Ascii
+char puffer[12];           // Puffer für Ausgabe als Ascii
 ISR(TIMER1_OVF_vect)   	   // Timer1 Überlauf
@@ Zeile 167: / Zeile 165: @@
    UCSR0B = (1<<TXEN0);   // Aktivieren des Senders, bei Mega32 UCSRB
    UCSR0C = (1<<UCSZ01)|(1<<UCSZ00)|(1<<USBS0);   // bei Mega32 UCSRC
-// Einstellen des Datenformats: 8 Datenbits, 2 Stoppbit:
+// Einstellen des Datenformats: 8 Datenbits, 2 Stopbit:
+}
@@ Zeile 191: / Zeile 189: @@
            + (1 << ICES1);            // steigende Flanke auswählen
   TIMSK1 = (1<<TOIE1) + (1<<ICIE1);   // overflow und Input-capture aktivieren, Mega32: TIMSK
-  TIFR1 = (1<<TOIE1) + (1<<ICIE1);    // Schon aktive Interrrupts löschen, Mega32: TIFR
+  TIFR1 = (1<<TOIE1) + (1<<ICIE1);    // Schon aktive Interrupts löschen, Mega32: TIFR
 // UART initialisieren:
   uart_init();
@@ Zeile 203: / Zeile 201: @@
   while (1)
+  {
-   sleep_enable ();
+   sleep_enable ();      // Sleep Befehl freigeben
    sei();
    sleep_cpu();          // wartet auf irgendeinen Interrupt, z.B. ICP, timer_ovr,...
-   sleep_disable();
+   sleep_disable();      // Sleep Befehl sperren
    cli();		// Interrupt sperren wegen Zugriff auf volatile Variable
    zeit = zeitdifferenz;
@@ Zeile 227: / Zeile 225: @@
 === CTC Modus (Clear Timer on Compare Match mode) ===
-Der CTC Modus ist eine Erweiterung des "Output-Compare"-Funktion. Der CTC Modus eignet sich besonders, um einen mit konstanter Frequenz wiederkehrenden Interrupt zu erzeugen. Wie im normalen Modus zählt der Timer hoch. Wenn der Wert im OCRx Register erreicht wird, wird zusätzlich zum möglichen Interrupt der Zähler wieder auf 0 gesetzt. Es kann also die maximalen Zählergrenze selber definiert werden.
+Viele Timer haben "Output-Compare" Register: OCRx oder OCRAx,OCRBx. Wenn der Zähler den darin eingestellten Wert erreicht hat, kann ein Interrupts ausgelöst werden. Der CTC Modus ist eine Erweiterung des "Output-Compare"-Funktion. Der CTC Modus eignet sich besonders, um einen mit konstanter Frequenz wiederkehrenden Interrupt zu erzeugen. Wie im normalen Modus zählt der Timer hoch. Wenn der Wert im OCRx Register erreicht wird, wird zusätzlich zum möglichen Interrupt der Zähler wieder auf 0 gesetzt. Es kann also die maximalen Zählergrenze selber definiert werden.
 Dieses Diagramm veranschaulicht den CTC Modus.

← Nächstältere Version		Version vom 4. September 2011, 13:33 Uhr
Zeile 391:		Zeile 391:

	* [http://www.atmel.com/dyn/products/devices.asp?family_id=607 Die Datenblätter zu Atmel Controllern]		* [http://www.atmel.com/dyn/products/devices.asp?family_id=607 Die Datenblätter zu Atmel Controllern]
		+	* [http://frank.circleofcurrent.com/cache/avrtimercalc.htm Javascript-Toll zur Timerberechnung]
	* [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=169 AvrTimer Windows Berechnungstool (für Bascom, nur nach Anmeldung)]		* [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=169 AvrTimer Windows Berechnungstool (für Bascom, nur nach Anmeldung)]

@@ Zeile 48: / Zeile 48: @@
 Damit haben wir den Wert errechnet, der bei jedem Interrupt, den der Timer0 auslöst, in TCNTx (in diesem Fall TCNT0) nachgeladen werden muss, damit die Interrupts in dem gewünschten Zeitabstand von einer Millisekunde ausgelöst werden.
-Zwischen dem Timer Overflow und dem tatsächlichen Aufrufen der ISR mit dem Nachladen des Timers ergibt sich eine kleine Verzögerung, die nicht einmal immer gleich ist. Besonders bei kleinen Prescalern kann es dadurch zu Fehlern in der Zeit kommen. Wenn möglich wird für die Erzeugung einer konstanten Interruptrate deshalb besser der CTC Moduls benutzt.
+Zwischen dem Timer Overflow und dem tatsächlichen Aufrufen der ISR mit dem Nachladen des Timers ergibt sich eine kleine Verzögerung, die nicht einmal immer gleich ist. Bei einem genügend großen Prescaler (z.B. 64) kommt durch die Verzögerung kein zusätzlicher Timerschritt zustande, und auch die Methode mit dem Nachladen liefert exacte Ergebnisse. Bei kleinen Prescalern kommt  es durch die Verzögerung zu längeren und nicht immer gleichen Zeitabständen.  Wenn möglich wird für die Erzeugung einer konstanten Interruptrate deshalb besser der CTC Moduls benutzt.
 Zusammenfassend ein Beispielprogramm:
@@ Zeile 54: / Zeile 54: @@
 <pre>
 /* Es wird der Timer2 (8-Bit) eines ATmega32 verwendet, der mit einem Quarz mit 7,3728 MHz
-betrieben wird. Im Abstand von 0,01 ms erzeugt der Timer einen Interrupt, also eine
+betrieben wird. Im Abstand von etwa 0,1 ms erzeugt der Timer einen Interrupt, also eine
-Frequenz von 100000 Hz (oder 100 kHz). Der Timer wird auf einen Prescaler von 1 und
+Frequenz von 10000 Hz. Der Timer wird auf einen Prescaler von 64 und
-einem Preloader von  183 konfiguriert.*/
+einem Preloader von 244 konfiguriert.*/
 volatile uint8_t countTimer2;	// Speichert den aktuellen Zählerwert
@@ Zeile 63: / Zeile 63: @@
 SIGNAL(SIG_SIG_OVERFLOW2)
+{
 	countTimer2++;
+}
 // Initialisierung:
-TCCR2 = (1<<CS20);		// Prescaler von 1
+TCCR2 = (1<<CS22);		// Prescaler von 64
-TCNT2  = 183;			// Vorladen
+TCNT2  = 244;			// Vorladen
 TIMSK |= (1<<TOIE2);		// Interrupts aktivieren und damit Timer starten
 sei();
@@ Zeile 75: / Zeile 75: @@
 // Funktionen zum benutzen der Timer:
 /** Diese Funktion nicht aufrufen. Wird von sleep_millisec aufgerufen.
-Bei t=100 schläft die Funktion 1 ms. */
+Bei t=10 schläft die Funktion 1 ms. */
 inline void sleep (uint8_t t)
+{
 	// countTimer2 wird in der ISR oben inkrementiert
-	countTimer2 = 0;
+        countTimer2 = 0;         // 1 Byte Typ, daher kein cli()... sei() nötig
 	while (countTimer2 < t);
+}
@@ Zeile 88: / Zeile 88: @@
 	uint16_t i;
 	for(i=0; i<msec; i++) {
-		sleep(100);
+		sleep(10);
+	}
+}