status wird nur durch externe Hardware (z. B. ein Peripherie-Register/ISR) verändert, nicht durch den Code der Schleife. Der Compiler „sieht" nur, dass status im Schleifenrumpf nie geändert wird → er darf den Wert einmal in ein Register laden und die Schleife durch eine Endlosschleife ersetzen. Mit volatile int status; muss der Compiler bei jedem Durchlauf den tatsächlichen Wert neu lesen → die Schleife endet, wenn die Hardware status setzt.

Falsch. Beschrieben ist Memory-Mapped I/O. DMA = ein separater Controller überträgt Daten zwischen Peripherie und Speicher ohne den Prozessorkern. (KL20 Aufg. 1.4 - klassische Falle.)

reg |=  (1u << 5);      // (a) setzen
reg &= ~(1u << 12);     // (b) löschen (Maske invertieren!)
reg ^=  (1u << 0);      // (c) toggeln
if (reg & (1u << 7)) { ... }   // (d) testen

Merkhilfe: |= setzt, &= ~ löscht, ^= toggelt, & testet. Alle lassen die übrigen Bits unverändert.

reg = (1<<5) überschreibt das ganze Register mit 0x20 und löscht damit alle anderen Bits (z. B. bereits konfigurierte Pins). Zum Setzen eines einzelnen Bits ohne die anderen zu stören: reg |= (1<<5);. Genau deshalb bietet Atmel getrennte SODR/CODR-Register (atomar, kein Read-Modify-Write).

(a) 1 << 14 = 16384 (= 0x4000). (b) 0x0F000000 >> 24 = 0x0000000F = 15. (c) Bits 8-11 = 0xF << 8 = 0x00000F00.

(a) -O0 zum Debuggen (stabiles Zeilen-Mapping), -O2 als Release-Standard (gute Balance). -Os für kleine Codegröße (Flash). (b) Aggressive Optimierung entfernt „überflüssige" Lese-/Schreibzugriffe. Bei Peripherie-Registern/HW-Variablen führt das zu Fehlern (weggelassene Zugriffe). volatile verbietet diese Optimierung für die betroffene Variable.

(1) static, (2) volatile, (3) const. Kombinationen möglich, z. B. static volatile für ein modulinternes HW-Flag; ein nur lesbares Statusregister ist const volatile.

Ergebnis = 0 → Z = 1. Nicht negativ → N = 0. Bei ARM-Subtraktion bedeutet C = 1 = kein Borrow (Minuend ≥ Subtrahend), also C = 1. Kein Vorzeichenüberlauf → V = 0. Falle: Bei Subtraktion ist C=1 das „Gutfall"-Ergebnis (kein Borrow) - nicht intuitiv.

Thumb = 16-Bit-Befehle → ~65 % der Codegröße, höhere Codedichte, energieeffizienter/schneller bei 16-Bit-Speichern. Nachteile: meist nur Register R0-R7 direkt, keine bedingte Ausführung (außer Branches), auf 32-Bit-Speicher langsamer. Thumb-2 (Cortex-M3) mischt 16-/32-Bit-Befehle. Das T-Bit im CPSR zeigt den Zustand an.

(a) Thread Mode (Anwendungscode, nach Reset) und Handler Mode (Exceptions/Interrupts). (b) MSP (Main SP) für OS/Handler, PSP (Process SP) für unprivilegierten Anwendungscode; nur einer ist sichtbar (banked). (c) Ja, Handler Mode ist immer privilegiert.

Bei Branch (Sprung), Exception/Interrupt oder Breakpoint - dann sind die bereits geladenen Folgebefehle ungültig. Ein Flush kostet Takte → Branches sind „teuer".

• PID 11 < 32 → PMC->PMC_PCER0 = 1 << 11;
• PID 35 ≥ 32 → PMC->PMC_PCER1 = 1 << (35-32); (Bit 3)

Methode: PID 0-31 → PCER0 Bit=PID; PID 32-44 → PCER1 Bit=PID−32.

Für atomare Bit-Operationen ohne Read-Modify-Write → keine Race Condition, wenn eine ISR gleichzeitig ein anderes Bit schaltet. Status wird über …SR nur gelesen.

CPU-Takt: ein, Peripherie-Takt: aus. So startet der Kern sofort und schaltet dann gezielt nur die benötigte Peripherie ein → minimaler Energieverbrauch.

Dynamische CMOS-Verlustleistung ist proportional zur Schaltfrequenz ($P \sim C\,U^2 f$). Weniger/kein Umschalten → weniger Verbrauch. Clock-Gating (Baustein von der Clock trennen) senkt den dynamischen Anteil auf nahezu 0.

Der Peripherie-Takt für den PIO-Baustein wurde nicht eingeschaltet (PMC_PCER). Ohne Clock ist der PIO-Controller „tot". Erster Blick bei nicht-funktionierender Peripherie: Power Management / PMC.

0b1101101 → Bits a=1,b=0,c=1,d=1,e=0,f=1,g=1 → Segmente a, c, d, f, g → Ziffer 5.

1. PMC_PCER (Clock an) → 2. PIO_PER (Pin dem PIO zuordnen) → 3. PIO_OER (als Ausgang) → 4. SODR/CODR (Pegel).

Pull-Up einschalten (PIO_PUER). Ruhezustand: Pin auf High (= 1); gedrückt: Low (= 0) → active low. (Ohne Pull-Up wäre der offene Eingang floating → zufällige Werte.) Mechanische Taster zusätzlich entprellen.

1. Peripherie-Clock einschalten (PMC). 2. Pin vom PIO lösen: PIO_PDR (PIO Disable). 3. Peripherie A oder B wählen: PIO_ABSR. Danach steuert das USART-Modul den Pin. Merke: PIO_PER = PIO steuert; PIO_PDR = Peripherie steuert.

(a) Ohne Decoder: 8 Segmentleitungen (a-g + dp) + 4 Stellenauswahl = 12 Pins (statt 8×4=32 ohne Multiplex). (b) Mit BCD-Decoder: 5 (4 BCD + dp) + 4 Stellenauswahl = 9 Pins.

4 + 4 = 8 Pins statt 16. Abfrage im Zeitmultiplex: Spalten nacheinander aktivieren (Output), Reihen messen (Input, mit Pull-Up/Down). Aus aktiver Spalte + gemessener Reihe folgt die Taste.

Weil die Ausgangsstufe eines µC nach Masse meist mehr Strom „sinken" kann, als sie nach High „sourcen" kann. Bei low-aktiv fließt der LED-Strom von $+U_B$ in den Pin (Sink) → der Prozessor muss den Strom nicht selbst liefern.

9600 Baud, 8 Datenbits, None Parität, 1 Stoppbit. Minimal 2 Leitungen: TXD + RXD, gekreuzt.

• Start: SDA fällt auf Low während SCL High. Stopp: SDA steigt auf High während SCL High.
• Sonst ändert sich SDA nur bei SCL Low.
• ACK = Low (Empfänger bestätigt), NACK = High. Idle = beide High.

Falsch. Das Shift-Register (TSR) serialisiert; THR ist nur der Puffer für die CPU. Empfang analog: RSR deserialisiert → aus RHR lesen.

Pro Byte-Rahmen: 1 Start + 8 Daten + 0 Parität + 1 Stopp = 10 Bit. 100 Bytes = 1000 Bit. Zeit = 1000 / 9600 ≈ 0,104 s = 104 ms. Falle: Nicht 8 Bit pro Zeichen rechnen - der Rahmen hat 10 Bit.

Anzahl Einsen = 5 (ungerade). Even: Paritätsbit = 1 (macht 6, gerade). Odd: Paritätsbit = 0 (5 ist schon ungerade).

I²C = synchron (Taktleitung SCL). RS-232 = asynchron. Async braucht ein Startbit, damit sich der Empfänger auf den Zeichenbeginn synchronisiert und danach in Bit-Mitte abtastet.

Negative Logik mit hohen Spannungen → große Störsicherheit über lange Kabel. µC arbeiten mit TTL/CMOS → ein Pegelwandler (MAX232) erzeugt die ±-Spannungen und wandelt zurück.

0x50 = 1010000, 0x48 = 1001000. Vergleich MSB zuerst: Bit6 1=1, Bit5 0=0, Bit4 A=1, B=0. B zieht SDA auf Low; A sendet 1, liest aber 0 → A verliert und stoppt. Master B (0x48) gewinnt. Regel: Wer als Erster eine 0 gegen die 1 eines anderen durchsetzt, gewinnt → effektiv die niedrigere Adresse. Der Verlierer stört die Übertragung nicht.

Ideal = 32·10⁶/(50·65536) ≈ 9,77 → Prescaler 32 (8 wäre zu klein → RC>65536). RC = 32·10⁶/(32·50) = 20 000 (< 65536).

Ideal ≈ 4,88 → Prescaler 8. RC = 16·10⁶/(8·50) = 40 000. T_step = 8/16 MHz = 0,5 µs → RA = 1,5 ms/0,5 µs = 3 000 (= 7,5 %).

T_step = 32/16 MHz = 2 µs; T_A = 1000·2 µs = 2 ms → 500 Hz. High von RA…RC = 900 Schritte → 90 %. 1 kHz symmetrisch: RC = 1 ms/2 µs = 500, RA = 250 (50 %).

T_A = (3250−125)·8/25·10⁶ = 3125·320 ns = 1 ms. Mindest-Messdauer ≥ 2·T_A = 2 ms (Worst Case).

T_step = 8/5·10⁶ = 1,6 µs = 1600 ns.

(a) D = RA/RC = 25 %. (b) RA = 0,40·10 000 = 4 000.

Schall läuft hin und zurück → s = v·t/2 = 340 · 1,2·10⁻³ / 2 = 0,408/2 = 0,204 m = 20,4 cm. Falle: Ohne den Faktor /2 ergäbe sich der doppelte (falsche) Abstand.

(a) T_ovf = 2¹⁶·1024/8·10⁶ = 65536·1024/8·10⁶ ≈ 8,39 s. (b) 32 Bit → Faktor 65536 mehr Zählbereich → Überlauf erst nach Stunden; lange Zeiten ohne Kaskadierung.

T = (1200−200)·32/16·10⁶ = 1000·2 µs = 2 ms → f = 500 Hz. (T_step = 2 µs.)

f_A = 0,1 Hz. Selbst mit Prescaler 1024: RC = 32·10⁶/(1024·0,1) = 312 500 - das ist > 65 536, passt nicht in 16 Bit. → Kaskadierung zweier Zähler oder 32-Bit-Timer. (Grenze: RC ≤ 2^Bitbreite.)

TIOA: RA/RC = 30 %; TIOB: RB/RC = 70 %. Ein Zähler, gemeinsame Frequenz, zwei unabhängige Tastverhältnisse.

Compare-Mode: bei Counter==RC → Interrupt + Reset. T_step = 8/8 MHz = 1 µs → RC = 1000.

(a) f(t) = 2·sin(2π·50·t) + 1·sin(2π·150·t). (b) sin(100π t)→50 Hz → A=2; sin(300π t)→150 Hz → A=1. Merkregel: sin(kπt) → f = k/2.

f_s > 2·400 = 800 Hz (strikt) → nur 850 Hz. Bei 700 Hz: Alias |700−400| = 300 Hz.

U = 200·0,5 mV = 100 mV, Schritt = 0,5·0,5 = 0,25 mV → 2^n ≥ 100/0,25 = 400 → n = 9 (2⁹=512).

800·10·2 Byte = 16 000 Byte (16 Bit = 2 Byte).

Falsch. Das Wägeverfahren (sukzessive Approximation, MSB zuerst) ist schneller und braucht konstant n Schritte; das Zählverfahren ist langsam und wertabhängig.

Erst ab Index 3 (n−1) berechenbar:

• m₃ = (4+8+6+10)/4 = 7
• m₄ = (8+6+10+12)/4 = 9
• m₅ = (6+10+12+8)/4 = 9

Wirkung: Tiefpass (glättet Rauschen), aber verzögert.

(a) ΔU = 5 V/2¹⁰ = 5 V/1024 ≈ 4,88 mV. (b) e_max = ½ LSB ≈ 2,44 mV.

(a) 1 LSB = 6 V/2⁸ = 6 V/256 ≈ 23,4 mV. (b) 0xC0 = 192 → U = 192/256 · 6 V = 4,5 V.

Pro zusätzlichem Bit ist 4×-Oversampling nötig → für 2 Bit: 4² = 16× (allgemein 4^(Δbits)). Nebeneffekte: besserer SNR, einfacherer Anti-Aliasing-Filter.

(a) |12−10| = 2 Hz. (b) |11−10| = 1 Hz. (c) f_s = 5 Hz: Signal faltet auf |10 − 2·5| = 0 Hz → Gleichanteil. Alle verletzen Nyquist.

(a) 60·44100·16 bit = 5 292 000 Byte ≈ 5292 kByte. (b) 60·8000·8 bit = 480 000 Byte = 480 kByte. Verhältnis ≈ 11×.

(1) I (Integral), (2) P (Proportional), (3) D (Differential).

Bei Stellglied-Sättigung wächst der I-Anteil weiter, obwohl die Stellgröße nicht steigen kann → langes Nachschwingen. Anti-Windup: I-Anteil begrenzen (Clamping).

Ohne Hysterese schaltet er am Sollwert sehr schnell ein/aus (Rattern). Mit Hysterese (Schmitt-Trigger): einschalten unter einer unteren, ausschalten über einer oberen Schwelle → ruhiges Schalten.

Steuerung: kein Feedback → kann auf Störungen nicht reagieren. Regelung: misst den Istwert und korrigiert die Regeldifferenz → kompensiert Störgrößen (z. B. Praktikums-Fahrzeug).

PID-Diskretisierung nutzt die Abtastzeit T (Integral→Summe·T, Differential→Differenz/T). Ein konstantes T ist Voraussetzung für Stabilität. Polling ist nicht deterministisch → Jitter verfälscht I-/D-Anteil. Daher Timer-Interrupt (fester Takt).

g = 101001 (6 Bit → 5 Prüfbits). Nachricht + 5 Nullen, Modulo-2-Division → Rest 01010. Gesendet: 10011111001 01010.

(a) 100101. (b) + 5 Nullen, Division → Rest 10100. Gesendet: 111010111 10100.

11110010 ÷ 10011 → Rest 0000 → gültig. HW: LFSR (Schieberegister + EXOR-Gatter).

g = 1101 (Grad 3 → 3 Prüfbits). Nachricht + 3 Nullen = 1010000. Modulo-2 (XOR):

1010000
1101          (Pos 0)
-------
0111000
 1101         (Pos 1)
 ------
 0001100
    1101      (Pos 3)
    ----
    0000001

Rest = 001 → Prüfbits 001, gesendet 1010001. Kontrolle: 1010001 ÷ 1101 → Rest 000.

(a) XOR: 10110 ⊕ 11011 = 01101 → 3 Einsen → d = 3. (b) Erkennen d ≥ e+1 → 2 Fehler erkennbar; Korrigieren d ≥ 2e+1 → 1 Fehler korrigierbar.

Ein Paritätsbit erkennt nur eine ungerade Anzahl Bitfehler - bei 2 (geraden) Fehlern versagt es. CRC erkennt zusätzlich Bündelfehler bis zum Grad des Polynoms und praktisch alle Mehrfachfehler; Stärke hängt vom Generatorpolynom ab.

• NRZ: Pegel = Bit (0=Low, 1=High), pro Bit konstant.
• Manchester (802.3): Mittenflanke je Bit, 1 = steigend, 0 = fallend.
• Selbsttaktend = Manchester (Flanke in jedem Bit). NRZ nicht.

Manchester: 1 Bit = 2 Symbole → 2 MBaud.

→ Pegelfolge L, H, H, H, L, H, H.

802.3: steigend = 1, fallend = 0 → 1 1 0 1. (Nach G. E. Thomas invertiert: 0 0 1 0.)

NRZI-S toggelt nur bei 0. Bei einer langen Folge von Einsen gibt es keinen Pegelwechsel → wieder Synchronisationsverlust. (NRZI-M analog mit langen Nullen.) Manchester löst das vollständig (Flanke in jedem Bit).

Vorteil: selbsttaktend. Nachteile: doppelte Bandbreite (Baud = 2·Bitrate) und ein Gleichspannungsanteil → erschwert galvanische Trennung.

Polling: einfacher; geringerer HW-Aufwand (Busy Waiting: sofortige Reaktion). Interrupt: CPU frei/Sleep (stromsparend); Ereignis wird immer überwacht, klareres Hauptprogramm.

d → c → b → a → e → f. (KL20 Aufg. 7.)

Die Nummer steht im Maschinencode des Befehls. Handler lädt den Befehl an [LR−4] und maskiert die oberen 8 Bit (BIC r0,r0,#0xff000000) → 24-Bit-Nummer.

Eine Unterbrechung mitten in einer nicht-atomaren Operation führt zu inkonsistenten Daten (Race Condition). Schutz: kritischen Abschnitt durch kurzes Sperren der Interrupts kapseln; gemeinsame Variablen volatile.

NVIC: in den Kern integriert, automatisches Stacking, Tail-Chaining/Late-Arriving/verschachtelt, 16 Prioritäten. AIC: 8 Prioritäten + FIQ, Kontextsicherung/Reentrant explizit zu programmieren, EOICR am Ende.

Ja. Beim NVIC ist 0 = höchste Priorität - kleinerer Wert = höher. Wert 2 > Wert 5 (in Priorität) → der neue Interrupt verdrängt den laufenden. Falle: Beim AT91-AIC ist es umgekehrt (7 = höchste). Immer die Richtung prüfen!

Ein Geister-Interrupt: die Anforderung verschwindet, bevor die CPU sie verarbeitet (Glitch/spätes Löschen). Der AIC liefert die Adresse aus dem Spurious Vector Register. Ein Handler ist zwingend, sonst Absturz.

Synchroner Aufruf, um vom User Mode in den privilegierten (Supervisor/Handler) Mode zu wechseln → kontrollierter Aufruf von Systemdiensten (z. B. putchar). Die Nummer im Befehl wählt den Dienst.

PMC->PMC_PCER0 = (1u << ID_PIOA);   // 1) Peripherie-Takt für PIOA
PIOA->PIO_PER  = (1u << 19);        // 2) Pin vom PIO-Controller steuern
PIOA->PIO_OER  = (1u << 19);        // 3) als Ausgang
PIOA->PIO_SODR = (1u << 19);        // 4) High -> LED an (high-aktiv)

Reihenfolge merken: Takt -> PER -> OER -> Pegel. Ohne Schritt 1 ist der PIO „tot".

PMC->PMC_PCER0 = (1u << ID_PIOA);
PIOA->PIO_PER  = (1u << 11);        // PIO steuert den Pin
PIOA->PIO_ODR  = (1u << 11);        // Output Disable -> Eingang
PIOA->PIO_PUER = (1u << 11);        // Pull-Up an (Ruhe = High)

// gedrückt = Pin Low (active low):
int gedrueckt = !(PIOA->PIO_PDSR & (1u << 11));

PIO_PDSR liest den tatsächlichen Pin-Pegel. Ohne Pull-Up floatet der offene Eingang.

PMC->PMC_PCER0 = (1u << 18) | (1u << 27);   // beide PIDs < 32 -> PCER0

Beide IDs liegen unter 32, also dasselbe Register. Für PID ≥ 32 wäre es PMC_PCER1 mit Bit PID-32.

void putc(char c) {
    while (!(USART1->US_CSR & US_CSR_TXRDY)) ;  // warten bis Sender frei
    USART1->US_THR = c;                          // Byte ins Holding Register
}

TXRDY im US_CSR zeigt an, dass US_THR beschrieben werden darf. Das Shift-Register (TSR) serialisiert dann.

#define SET_BIT(r,n)    ((r) |=  (1u << (n)))
#define CLR_BIT(r,n)    ((r) &= ~(1u << (n)))   // Maske invertieren!
#define TGL_BIT(r,n)    ((r) ^=  (1u << (n)))
#define TST_BIT(r,n)    (((r) >> (n)) & 1u)

NVIC_SetPriority(TC0_IRQn, 2);   // 0 = höchste Priorität beim NVIC
NVIC_EnableIRQ(TC0_IRQn);

void TC0_Handler(void) {
    uint32_t status = TC0->TC_CHANNEL[0].TC_SR;  // Lesen von TC_SR löscht die Flags
    if (status & TC_SR_CPCS) {
        // RC-Compare aufgetreten -> hier reagieren
    }
}

Wichtig: im Handler TC_SR lesen, sonst bleibt das Interrupt-Flag gesetzt (Dauer-Interrupt).

T_step = 32/16 MHz = 2 µs. Für 1 kHz: T = 1 ms -> RC = 1 ms / 2 µs = 500. Symmetrie 50 %: RA = RC/2 = 250.

timerbase->TC_RA = 250;   // war 100
timerbase->TC_RC = 500;   // war 1000

Modus/ACPA/ACPC bleiben unverändert (Set@RA, Clear@RC). (Alternativ: TIOA per Toggle an RC und RC = 500 bei halbierter Periodenlogik - siehe RK2.)

timerbase->TC_RA = 6000;   // 0,60 * 10000

RC bleibt (Frequenz unverändert), nur RA steuert das Tastverhältnis.

RC = fCLK/(Prescaler·f) = 16e6/(8·100) = 20000. Tastverhältnis 7,5 % beibehalten: RA = 0,075·20000 = 1500.

timerbase->TC_RC = 20000;   // war 40000
timerbase->TC_RA = 1500;    // war 3000

Beide halbieren sich (doppelte Frequenz = halbe Periode); das Verhältnis RA/RC bleibt 7,5 %.

Prescaler von 8 auf 32 (Faktor 4) erhöhen:

// TC_CLKS_MCK8  ->  TC_CLKS_MCK32

T_A = RC·Prescaler/fCLK ist proportional zum Prescaler -> ×4. RA/RC (und damit das Tastverhältnis) bleiben unverändert. (Ein Faktor 2 wäre nicht möglich, da nur 2, 8, 32, 128, 1024 verfügbar sind.)

timerbase->TC_RB = timerbase->TC_RC / 2;   // 50 % für TIOB
// im TC_CMR zusätzlich die TIOB-Aktionen setzen:
//   TC_BCPB_CLEAR_OUTPUT | TC_BCPC_SET_OUTPUT

TIOB nutzt die Register RB (Compare) und BCPB/BCPC (Aktionen), analog zu RA/ACPA/ACPC bei TIOA. Frequenz ist für beide gleich (gemeinsamer Zähler, gemeinsames RC).

Bei low-aktiv leuchtet ein Segment, wenn der Pin Low ist. Also SODR und CODR vertauschen:

// high-aktiv:  einschalten = SODR,  ausschalten = CODR
// low-aktiv :  einschalten = CODR,  ausschalten = SODR
PIOA->PIO_CODR = segmentmaske;   // Segmente AN (Pin low)
PIOA->PIO_SODR = ~segmentmaske & alle_segmente;  // Rest AUS (Pin high)

Logik invertiert sich; die Pin-Zuordnung (a…g) bleibt gleich.

Nach dem Reset (Counter = 0) ist TIOA High; bei Counter = RA = 250 wird Clear (Low); bei Counter = RC = 1000 wieder Set + Reset. -> 25 % High am Periodenanfang.

        0      250                     1000
TIOA  ┌──────┐                        ┌──────
      │ high │        low             │
   ───┘      └────────────────────────┘
      |<25%>|<-------- 75% ---------->|

Periode = 1000 Schritte; High-Anteil = RA/RC = 25 %.

NRZ (Pegel = Bit): H L H H L

      1   0   1   1   0
NRZ ─┐   ┌───┐       ┌
     │ H │ L │ H   H │ L
     └───┘   └───────┘

Manchester 802.3 (Mittenflanke: 1 = steigend, 0 = fallend) - jedes Bit hat zwei Halbschritte:

Nur Manchester ist selbsttaktend (Flanke in jedem Bit).

Zähler läuft als Sägezahn. Bei der 1. steigenden Flanke wird der Zählerstand in RA geladen, bei der 2. steigenden Flanke in RB.

Eingang ┌────┐    ┌────┐
     ───┘    └────┘    └───
        ^RA        ^RB          (Flanken laden RA, RB)
Zähler   /|   /|   /|
        / |  / |  / |          (Sägezahn)

Periodendauer T = (RB − RA)·Prescaler/fCLK. Mindestmessdauer ≥ 2·T (Worst Case).

Treppenfunktion mit 2³ = 8 Stufen, Stufenbreite U/8:

Code
111                        ┌──
110                    ┌───┘
101                ┌───┘
100            ┌───┘
011        ┌───┘
010    ┌───┘
001 ┌──┘
000─┘
    0    U/8  ...        U   -> Eingangsspannung

Jede Stufe entspricht 1 LSB = U/8; der Quantisierungsfehler ist max. ½ LSB.

Es entsteht ein Alias von 2 Hz (|12 − 10| = 2 Hz). Die Abtastpunkte liegen jeweils etwas später in der 10-Hz-Schwingung und bilden eingehüllt eine langsame 2-Hz-Welle nach.

echte 10 Hz:  ∿∿∿∿∿∿∿∿∿∿   (viele schnelle Perioden)
Abtastpunkte: •     •     •     •      (12 Hz)
scheinbar:    \___/‾‾‾\___/          (langsame 2-Hz-Hüllkurve)

Ursache: Nyquist verletzt (fs = 12 < 2·10 = 20 Hz).

Beide starten bei Counter = 0 High; TIOA fällt bei 300 (30 %), TIOB bei 700 (70 %):

        0    300        700   1000
TIOA  ┌────┐                  ┌───
   ───┘    └──────────────────┘      (30 % High)
TIOB  ┌──────────────┐        ┌───
   ───┘              └────────┘      (70 % High)

Gleiche Frequenz (f = fCLK/(Prescaler·RC)), zwei unabhängige Tastverhältnisse.

Der Zähltakt ist fCLK/Prescaler, also dauert ein Zählschritt T_step = Prescaler/fCLK. Der Zähler läuft von 0 bis RC (RC Schritte pro Periode), daher T_A = RC·T_step = RC·Prescaler/fCLK. Umgestellt: f_A = 1/T_A = fCLK/(Prescaler·RC).

Die Messung kann zu einem beliebigen Zeitpunkt starten. Im Worst Case beginnt sie direkt nach einer steigenden Flanke - dann liegt die nächste Flanke fast eine ganze Periode entfernt, und die übernächste nochmal eine Periode später. Um zwei Flanken (= eine volle Periode) garantiert einzufangen, muss das Messfenster daher fast zwei Periodendauern breit sein -> Messdauer ≥ 2·T_A.

n Bit -> 2^n gleich große Stufen über den Bereich U -> 1 LSB = ΔU = U/2^n. Ein analoger Wert wird auf die nächste Stufe gerundet; der Abstand zur Stufenmitte ist höchstens eine halbe Stufe -> max. Fehler = ½·LSB = U/2^(n+1).

Mittelt man N unabhängige Messwerte, sinkt das (unkorrelierte) Rauschen um den Faktor √N in der Amplitude. Für N = 4: √4 = 2, also halbes Rauschen = eine Stufe feiner = +1 Bit effektive Auflösung. Für b zusätzliche Bits braucht man √N = 2^b, also N = 4^b (2 Bit -> 16×). Voraussetzung: genügend Rauschen und unkorrelierte Fehler.

Eine Sinusschwingung ist erst dann eindeutig bestimmt, wenn pro Periode mehr als zwei Abtastwerte vorliegen (ein Maximum und ein Minimum reichen gerade nicht, da Phase/Amplitude mehrdeutig werden). Für die höchste Frequenz fmax bedeutet das fs > 2·fmax. Bei fs ≤ 2·fmax fallen höhere Frequenzen als Aliase in den Basisbereich zurück.

Manchester codiert jedes Bit durch zwei Halbschritte (zwei Pegelzustände mit Flanke in der Mitte). Ein Symbol = ein Halbschritt -> pro Bit zwei Symbole -> Symbolrate (Baud) = 2 × Bitrate. Preis: doppelte Bandbreite; Vorteil: selbsttaktend, gleichspannungsfrei.

timer->TC_CMR = TC_WAVE               // Waveform-Modus
              | TC_CPCTRG             // Counter == RC setzt Zähler zurück
              | TC_CLKS_MCK8          // Prescaler = 8
              | TC_ACPC_SET_OUTPUT    // bei RC: TIOA = High (Set)
              | TC_ACPA_CLEAR_OUTPUT; // bei RA: TIOA = Low  (Clear)

Damit ist TIOA von 0…RA High -> High-Anteil = RA/RC. ACPA/ACPC-Code: 00 = keine, 01 = Set, 10 = Clear, 11 = Toggle.

timer->TC_CMR = TC_WAVE | TC_CPCTRG | TC_CLKS_MCKx
              | TC_ACPC_TOGGLE_OUTPUT;   // bei RC: TIOA toggeln

TIOA wechselt bei jedem RC-Ereignis den Pegel -> eine volle Periode dauert 2·RC-Schritte. Daher f = fCLK/(2·Prescaler·RC), Tastverhältnis automatisch 50 %.

timer->TC_CMR = TC_CLKS_MCKx        // (kein TC_WAVE -> Capture-Modus)
              | TC_ABETRG           // externer Trigger über TIOA
              | TC_ETRGEDG_RISING   // Triggerflanke = steigend (Reset)
              | TC_LDRA_RISING      // RA laden bei steigender Flanke
              | TC_LDRB_FALLING     // RB laden bei fallender Flanke
              | TC_LDBSTOP;         // Zähler stoppt, wenn RB geladen -> Messwert sicher

Fehlt TC_WAVE, ist es Capture. Impulsdauer = (RB − RA)·Prescaler/fCLK. Für die Periode (Flanke-zu-Flanke) lädt man RB bei der nächsten steigenden Flanke.

Das Feld TCCLKS (TC_CLKS_...): CLOCK1 = MCK/2, CLOCK2 = MCK/8, CLOCK3 = MCK/32, CLOCK4 = MCK/128 (CLOCK5 = SLCK). Beispiel TC_CLKS_MCK8 = TIMER_CLOCK2 = Prescaler 8.

PMC->PMC_PCER0 = (1u << ID_USART1);   // Takt fürs USART-Modul
PIOA->PIO_PDR  = pinmaske;            // PIO abschalten -> Peripherie steuert Pin
PIOA->PIO_ABSR &= ~pinmaske;          // Peripherie A wählen ( |= für Peripherie B )

Merke: PIO_PER = PIO steuert, PIO_PDR = Peripherie steuert. ABSR wählt A/B.

timer->TC_IER = TC_IER_CPCS;   // Interrupt bei RC-Compare freigeben
NVIC_EnableIRQ(TCx_IRQn);       // im NVIC freischalten

void TCx_Handler(void){
    (void) timer->TC_SR;        // TC_SR LESEN -> löscht das Interrupt-Flag!
    // ... Reaktion ...
}

Ohne das Lesen von TC_SR bleibt das Flag stehen und der Interrupt feuert endlos.

• Trigger: kurzer Impuls (max. 10 µs) -> Timer im Wave-Mode.
• Echo: Echodauer proportional zur Distanz -> Timer im Capture-Mode (RA/RB an den Flanken des Echo-Pins).
• Berechnung: s = v·t/2 = 340·1,5·10⁻³ / 2 = 0,510/2 = 0,255 m = 25,5 cm (Faktor ½ wegen hin und zurück).
• Messperiode typ. 20 ms; Ergebnis als Regelgröße an den PD/PID-Regler.

T_step = 8/8 MHz = 1 µs -> RC = 1 ms/1 µs = 1000, Compare-Mode (RC-Compare -> Interrupt + Reset).

volatile uint32_t ms = 0, sek = 0;
void TCx_Handler(void){
    (void) timer->TC_SR;      // Flag löschen
    if (++ms >= 1000) { ms = 0; sek++; }   // 1000 Ticks = 1 s
}

f = 1/20 ms = 50 Umdrehungen/s -> 50·60 = 3000 U/min. (Bei k Impulsen/Umdrehung: Drehzahl = f/k.)

• Drehmoment: über das Tastverhältnis eines PWM-Signals (Wave-Mode, RA/RC). Höherer High-Anteil -> mehr mittlere Spannung -> mehr Drehmoment (idealerweise linear).
• Drehrichtung: separater Digitalausgang (Vor/Zurück) -> Umpolung über eine H-Brücke/Relais.
• Die PWM-Frequenz nicht zu niedrig (Stottern) und nicht zu hoch (mechanische/Schaltgrenzen) wählen.

Rahmen = 10 Bit/Zeichen. (a) 115200/10 = 11520 Zeichen/s. (b) 1024·10 / 115200 = 10240/115200 ≈ 0,0889 s ≈ 89 ms.

1. Start -> Slave-Adresse (7 Bit) + R/W = 0 (Write) -> auf ACK warten.
2. Ggf. Registeradresse/Kommando-Byte senden (ACK).
3. 8 Datenbytes (je 1 Zeile der Matrix) nacheinander, jeweils MSB zuerst, nach jedem Byte ACK.
4. Stop.

Am SAM3X (TWI): Slave-Adresse in TWI_MMR (MREAD = 0), je Byte auf TXRDY warten, in THR schreiben, beim letzten Byte STOP im TWI_CR, am Ende auf TXCOMP warten. Pull-Ups an SDA/SCL nicht vergessen.