Kapitel 5 - Timer / Counter (klausurkritisch)

← Startseite · Kap. 4 Serielle Schnittstelle · 5 Timer · → Kap. 6 Interrupts Verwandt: Kap. 3 PWM/PIO · Kap. 6 periodische Interrupts · Kap. 8 Regelung Quellen: [Q: TI] ES-06-TI Timer · [Q: ZF §6/§6a] · [Q: KL20 Aufg. 2] · [Q: ALT 2009/2012/Übungsklausur]

Dies ist das wichtigste Rechenkapitel. Timer bringen in jeder Klausur ~20–24 Punkte. Formeln unten auswendig können, Beispiele nachrechnen.

---

Inhalt

1. Timer vs. Counter
2. Zählregister & Äquivalenz Zähler↔Zeit
3. Flexibilisierung: RC & Prescaler
4. Die Kernformeln
5. Die drei Modi: Compare / Wave / Capture
6. PWM
7. Optimalen Prescaler wählen
8. Capture: Zeit-/Frequenzmessung
9. Anwendungen: Servo, Ultraschall, DC-Motor
10. AT91-Register (TC_CMR etc.)
11. Prüfungsrelevanz

---

1. Timer vs. Counter

Ein Timer/Counter ist Peripherie mit Registern + konfigurierbarer Hardware-Logik, die Bedingungen prüft und ohne CPU reagiert → paralleles Verhalten zum laufenden Programm.

• Timer (Zeitgeber): erzeugt in genau definierten Perioden ein Signal/Interrupt.
  • intern (Interrupt) → Compare Mode
  • extern (Signal am Pin) → Wave Mode
• Counter (Zähler): misst Zeit zwischen Signalen (Capture Mode) oder zählt externe Ereignisse (auch wenn die CPU steht).

2. Zählregister & Äquivalenz Zähler↔Zeit

• Ein Zählregister (Counter) wird durch einen Takt kontinuierlich inkrementiert. Breite z. B. 8/16/32 Bit.
• Ohne Maßnahme: bei Maximalwert Overflow → zurück auf 0.
• Äquivalenz Zähler ↔ Zeit: Periodendauer eines Zählschritts = T = 1/f.
  • Bei 1 MHz dauert ein Zählschritt 1 µs → Zählerstand 1000 ≙ 1000 µs = 1 ms.

3. Flexibilisierung: RC & Prescaler

Um beliebige Zeiten einzustellen, gibt es zwei Stellschrauben:

Flexibilisierung 1 - Reset-Register RC: Erreicht der Counter den Wert von RC (Counter == RC), wird er auf 0 zurückgesetzt → definiert die Periode unabhängig von der Bitbreite.

Flexibilisierung 2 - Prescaler (Vorteiler): Der Systemtakt wird durch einen Teiler reduziert → langsameres Zählen → längere Zeiten. Typische Werte (Zweierpotenzen): 2, 8, 32, 128, 1024.

4. Die Kernformeln

Diese Box ist der wichtigste Teil des Kapitels - auf den Spickzettel!

Dauer eines Zählschritts:

$$T_{prescaler} = \frac{\text{Prescaler}}{f_{CLK}}$$

Periodendauer / Frequenz des erzeugten Signals (mit RC):

$$T_A = \frac{RC \cdot \text{Prescaler}}{f_{CLK}} \qquad\qquad f_A = \frac{f_{CLK}}{\text{Prescaler} \cdot RC}$$

Register-Wert für gewünschte Periode:

$$RC = \frac{T_A \cdot f_{CLK}}{\text{Prescaler}} = \frac{f_{CLK}}{\text{Prescaler}\cdot f_A}$$

Tastverhältnis (Duty Cycle) bei PWM (High-Anteil):

$$\text{Duty} = \frac{RA}{RC}\ \Rightarrow\ RA = \text{Duty}\cdot RC$$

(je nach Aktionslogik; siehe §6)

Zeitmessung (Capture, Differenz zweier Register):

$$T = \frac{RB - RA}{\text{Prescaler}\cdot f_{CLK}}$$

Overflow-Zeit (ohne RC, volle Bitbreite):

$$T_{overflow} = \frac{2^{Bitbreite}\cdot \text{Prescaler}}{f_{CLK}}$$

„Zähler startet bei 0" - Off-by-one: Für exakt RC Zählschritte pro Periode lädt man RC mit (Anzahl − 1). In der Praxis/Klausur oft vernachlässigt (RC = Anzahl), aber bei „genau"-Formulierungen beachten (z. B. PWM-Beispiel: RC = 9999 für 10000 Schritte).

5. Die drei Modi

A) Compare Mode - periodische Interrupts

• Ziel: Aufgaben in gleichmäßigen Abständen (z. B. OS-Scheduler, Uhr).
• Bedingung: Counter == RC → Interrupt auslösen + Counter auf 0.
• Ergebnis: periodische Interrupts mit Frequenz f_A = f_CLK/(Prescaler·RC).

B) Wave Mode - Signalerzeugung

• Ziel: periodisches Signal an Ausgang TIOA/TIOB (z. B. Motor, Servo, PWM).
• Nutzt Vergleichsregister RA, (RB), RC. Aktionen: Ausgang Set (High), Clear (Low) oder Toggle.
• Beispiel-Logik:
  • Counter == RA → Ausgang = Low (Clear)
  • Counter == RC → Ausgang = High (Set) + Counter-Reset
• Zwei unabhängige Ausgänge (TIOA über RA, TIOB über RB) aus einem Counter möglich.

C) Capture Mode - Messung

• Ziel: Zeitdauern messen / Ereignisse zählen.
• Bedingung: Pegelwechsel (Flanke) an Eingang TIOA/TIOB.
• Aktion: aktuellen Counter-Stand in RA / RB laden (LDRA/LDRB).
  • z. B. steigende Flanke → RA = Counter; nächste (fallende/steigende) Flanke → RB = Counter.
• Gemessene Zeit = (RB − RA)/(Prescaler·f_CLK). Optional Counter bei Bedingung 2 stoppen (Messwert sichern); RC als Timeout.

6. PWM (Pulsweitenmodulation)

Verhältnis von High- zu Low-Anteil konfigurierbar. Typische Wave-Logik:

• Counter == RA → Clear (Low)
• Counter == RC → Set (High) + Counter-Reset → High-Anteil / Periode = RA / RC (Tastverhältnis).

Worked Example [Q: TI S. 17]: f_CLK = 32 MHz, T = 10 ms, Prescaler = 32, Tastverhältnis 25 %.

• T_prescaler = 32 / 32 MHz = 1 µs
• RC = T_A / T_prescaler = 10 ms / 1 µs = 10 000 → mit Off-by-one RC = 9999
• RA = 0,25 · 10 000 = 2 500 → RA = 2499

PWM-Anwendungen: LED dimmen (High-Anteil = Helligkeit) · DC-Motor (High-Anteil ≈ Drehmoment) · Servo (Impulslänge = Position) · analoges Signal via Tiefpass glätten.

7. Optimalen Prescaler wählen

Ziel: Bitbreite des Zählers möglichst weit ausnutzen (max. Auflösung) → kleinstmöglicher Prescaler, bei dem RC noch ins Register passt.

Rechenrezept:

1. Idealen Teiler bestimmen: Prescaler_ideal = f_CLK / (f_A · 2^Bitbreite).
2. Nächstgrößeren verfügbaren Prescaler wählen (2, 8, 32, 128, 1024).
3. RC neu berechnen: RC = f_CLK / (Prescaler · f_A).

Worked Example [Q: TI S. 16]: f_CLK = 32 MHz, 16-Bit-Zähler, f_A = 100 Hz (T=10 ms).

• Prescaler_ideal = 32 MHz / (100 Hz · 65536) = 3 200 000 / 65 536 ≈ 4,88
• Nächstgrößerer verfügbarer: 8 (nicht 32!).
• RC = 32 MHz / (8 · 100 Hz) = 40 000 (< 65 536 [x]).

„Nächstgrößer" ist Pflicht: Ein zu kleiner Prescaler → RC > 2^Bitbreite → passt nicht ins Register (Overflow). Ein zu großer → Auflösung verschenkt. Kleiner Prescaler = feine Auflösung, aber RC muss ≤ 2^Bitbreite bleiben.

Auflösung-Begründung (Klausurfrage): „Welcher Prescaler bringt bessere Auflösung?" → der kleinere, weil RC größer wird → mehr Zählschritte pro Periode → feinere Zeitauflösung.

8. Capture: Zeit- und Frequenzmessung

Periodendauer-Messung [Q: TI S. 25]: Prescaler = 8, f_CLK = 25 MHz (Taktdauer 40 ns), RA = 125, RB = 3250.

$$T_A = (3250-125)\cdot(8\cdot 40\text{ ns}) = 3125 \cdot 320\text{ ns} = 10^{-3}\text{ s} = 1\text{ ms}$$

Mindest-Messdauer: Beginnt die Messung im Worst Case direkt nach einer Flanke, passen fast zwei Perioden ins Intervall → Messdauer ≥ 2·T_A konfigurieren (im Beispiel ≥ 2 ms).

Ereignisse zählen: Takteingang direkt auf Pin legen → bei jeder (pos./neg.) Flanke +1. HW zählt viel schneller als SW. Anwendungen: Drehzahl-, Durchfluss-, Frequenz-, Stückzahlmessung, Quadraturencoder (Vor-/Rückwärtszähler).

9. Anwendungen

• Modellbau-Servo: PWM, 20 ms Periode (50 Hz); High-Anteil bestimmt Position; 1,5 ms = Mittelstellung.
• Ultraschallsensor (HC-SR04): Trigger-Impuls max. 10 µs (Wave), Echodauer messen (Capture). Echodauer ∝ Entfernung (hin und zurück!). Bei 340 m/s: Distanz_max = 340 · 10 µs / … → Messbereich 2–300 cm. Faustformel Entfernung: s = (v_Schall · t_Echo)/2.
• DC-Motor mit Richtungswechsel: Vor/Zurück per Relais (Umpolung); Tastverhältnis bestimmt Drehmoment (idealerweise linear). Frequenz nicht zu langsam (stottert) / zu hoch (mech. Grenzen).
• Kaskadierung: Zähler hintereinander → Zählbereich erweitern (Sekunden → Minuten → Stunden). Overflow/RC des einen erzeugt Zählimpuls fürs nächste.

10. AT91/SAM3X-Register

Init-Muster (Wave Mode) [Q: ALT 2009/2012]:

timerbase3->TC_CCR = TC_CLKDIS;            // Takt aus (vor Konfig)
timerbase3->TC_CMR =
      TC_ACPC_CLEAR_OUTPUT |   // bei Counter==RC → TIOA Clear (Low)
      TC_ACPA_SET_OUTPUT   |   // bei Counter==RA → TIOA Set  (High)
      TC_WAVE              |   // Waveform-Modus
      TC_CPCTRG            |   // RC-Compare setzt Counter zurück
      TC_CLKS_MCK32;           // Takt = MCK / 32   (Prescaler 32)
timerbase3->TC_RA = 100;                   // Compare A
timerbase3->TC_RC = 1000;                  // Compare C (Periode)
timerbase3->TC_CCR = TC_CLKEN;             // Takt an
timerbase3->TC_CCR = TC_SWTRG;             // Software-Trigger (Reset+Start)

Register	Funktion
TC_CMR (Channel Mode)	Modus (Wave/Capture), Takt/Prescaler (TC_CLKS_MCKx), Aktionen ACPA/ACPC (Set/Clear/Toggle), CPCTRG
TC_CCR (Channel Control)	CLKEN/CLKDIS, SWTRG (Software-Trigger = Reset+Start)
TC_RA TC_RB TC_RC	Compare/Capture-Register
TC_SR (Status)	CPCS (RC-Compare), LDRAS/LDRBS (RA/RB geladen), COVFS (Overflow)

ACPA/ACPC-Codierung (Aktion bei RA/RC-Compare auf TIOA): 00=none, 01=Set, 10=Clear, 11=Toggle. (Für symmetrisches Rechteck: an RA setzen, an RC löschen - oder Toggle bei RC mit RA=RC/2.)

Overflow-Beispiele: AT91 16-Bit @33 MHz, Teiler 1024 → Overflow nach ~2 s. SAM3X 32-Bit @84 MHz, Teiler 128 → ~6500 s (~1,8 h).

Beispiel: symmetrisches Rechteck 1 kHz [Q: ALT 2009 Aufg. 5b]

f_CLK = 16 MHz, Prescaler 32 → T_step = 32/16 MHz = 2 µs. Für 1 kHz: T = 1 ms → RC = 1 ms/2 µs = 500. Symmetrisch (50 %): RA = 250. (Alternativ TIOA per Toggle bei RC → dann RC = halbe Periode.)

---

Prüfungsrelevanz

Immer gefragt (KL20 Aufg. 2, jede Altklausur):

1. Frequenz aus Diagramm ablesen (f = 1/T).
2. Tastverhältnis aus Diagramm (High-Zeit / Periode · 100 %).
3. Optimalen Prescaler wählen (ideal rechnen → nächstgrößer).
4. ns pro Zählschritt = Prescaler / f_CLK.
5. RC für gewünschte Frequenz, RA für Tastverhältnis, RB für zweites Signal (z. B. 50 %).
6. ACPA/ACPC setzen; Capture: welche Register für Messdauer (→ RC).
7. Init-Code lesen → Signal skizzieren + Frequenz (Altklausuren).

Rechen-Tipp ohne Taschenrechner: Alle Werte sind so gewählt, dass sie glatt aufgehen (Zweierpotenzen, MHz/µs). Immer erst in µs/ns umrechnen, dann teilen.

Typische Fehler: Prescaler abrunden statt aufrunden · Off-by-one (RC vs. RC−1) · Hin-und-Rückweg beim Ultraschall vergessen (Faktor 2) · f_A-Formel: Prescaler und RC stehen beide im Nenner.

← Kap. 4 Serielle Schnittstelle · → Kap. 6 Interrupt Handling