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.

Die Teilnehmer sind Open-Drain/Open-Collector: Sie können eine Leitung nur aktiv auf Low ziehen, aber nicht aktiv auf High treiben. Den High-Pegel stellt allein der Pull-Up her. Ohne Pull-Ups blieben SDA/SCL nach dem Loslassen floating → kein definierter High-Pegel, keine Kommunikation. Da im Leerlauf niemand zieht, ziehen die Pull-Ups beide Leitungen auf High → idle high. Tipp: Genau daraus folgt auch, dass mehrere Teilnehmer eine Leitung gleichzeitig auf Low ziehen dürfen (Wired-AND) - Grundlage für ACK und Arbitrierung.

0x3A = 011 1010 (7 Bit). Das R/W-Bit ist das LSB des ersten Bytes, also wird die Adresse um 1 nach links geschoben:

• (a) Write (R/W=0): 0111 0100 = 0x74.
• (b) Read (R/W=1): 0111 0101 = 0x75.

Falle: Nicht einfach 0x3A senden. Die 7-Bit-Adresse steht in den oberen 7 Bit, das R/W-Bit kommt unten dazu (Adresse × 2, ggf. +1). MSB zuerst auf dem Bus.

Jedes übertragene Byte belegt 9 SCL-Takte: 8 Datenbits + 1 ACK. Übertragen werden 1 Adressbyte + 3 Datenbytes = 4 Bytes → 4 × 9 = 36 Taktimpulse. Bei 100 kBit/s ist 1 Bit = 10 µs → 36 × 10 µs = 360 µs. Mit Start- und Stop-Bedingung grob ≈ 0,38 ms. Falle: Pro Byte sind es 9 Takte (nicht 8) - das ACK-Bit wird gern vergessen. Start/Stop sind Zustandswechsel, keine vollen Datenbits.

Die ersten 7 getakteten Bits sind die Adresse: 1010001 = 0x51. Das 8. Bit ist das R/W-Bit = 0 → Schreibzugriff (Master→Slave). Die vom Slave getriebene 0 danach ist das ACK (Slave 0x51 ist vorhanden und bestätigt). Falle: Das 8. Bit gehört nicht zur Adresse, sondern ist R/W. Die Adresse ist nur 7 Bit breit. Das ACK kommt vom Empfänger, hier also vom Slave.

Regel: Während der Datenübertragung darf SDA sich nur ändern, wenn SCL = Low ist; bei SCL = High muss SDA stabil bleiben (der Empfänger tastet dann ab). Start und Stop sind die einzige Ausnahme: dort wechselt SDA gerade bei SCL = High. Weil eine SDA-Flanke bei SCL=High sonst nie vorkommt, ist sie eindeutig als Rahmensignal (Start = fallend, Stop = steigend) erkennbar.

Adress- und R/W-Bit sind identisch (0x50, Write) → hier fällt noch keine Entscheidung, beide senden dieselben Pegel. Die Arbitrierung läuft bitweise weiter in die Daten: 0x80 = 1000 0000, 0x40 = 0100 0000. Schon am ersten Datenbit (MSB) sendet A 1, B 0. B zieht SDA auf Low; A liest 0 obwohl es 1 sendet → A verliert, Master B gewinnt. Tipp: Arbitrierung endet nicht mit der Adresse - sie vergleicht jedes Bit weiter, bis sich die Sender unterscheiden. Der Verlierer zieht sich zurück, ohne die laufende Übertragung zu stören.

NACK = High = keine Bestätigung. Mögliche Ursachen (zwei genügen): (1) Unter dieser Adresse antwortet kein Slave (falsche Adresse im TWI_MMR.DADR, Zahlendreher, oder Adresse ohne R/W-Bit gedacht). (2) Der Slave ist nicht versorgt/getaktet oder falsch verdrahtet. (3) Pull-Ups fehlen, sodass der Slave die Leitung gar nicht sauber auf Low ziehen kann bzw. der Bus nie High wird. Falle: NACK heißt zunächst nur "keine Reaktion" - nicht automatisch "Slave defekt". Zuerst Adresse und Pull-Ups prüfen.

Gesund: Im Leerlauf sind beide Leitungen High (idle high durch Pull-Ups). Dauerhaft Low deutet auf: Kurzschluss nach Masse, ein Teilnehmer, der die Leitung festhält (hängender Baustein/Reset-Problem), oder fehlende/fehlerhafte Pull-Ups in Kombination mit einem aktiv ziehenden Ausgang. Ergebnis: Start-Bedingung (SDA-Flanke bei SCL=High) ist gar nicht erzeugbar → Bus blockiert.

Standard 100 kBit/s · Fast 400 kBit/s · Fast Mode Plus 1 MBit/s · High Speed 3,4 MBit/s · Ultra Fast 5 MBit/s. Ultra Fast Mode ist unidirektional (nur Schreiben).

(a) TWI_MMR (Master Mode Register): Slave-Adresse in DADR, Richtung in MREAD (0 = Write, 1 = Read); interne Adresslänge über IADRSZ. (b) Start setzen, Adresse+Write senden → auf TXRDY im TWI_SR warten → Byte in TWI_THR schreiben (ggf. für weitere Bytes wiederholen) → beim letzten Byte STOP im TWI_CR setzen → auf TXCOMP warten. Master aktivieren über MSEN im TWI_CR. Tipp: TXRDY = "THR frei, nächstes Byte darf rein", TXCOMP = "gesamte Übertragung inkl. Stop fertig". Nicht verwechseln.

AT91: keine I²C-Unterstützung. SAM3X: 2× TWI (Standard/Fast Mode, 7/10-Bit-Adressen, interruptfähig). RP2040: 2× I²C bis Fast Mode Plus. Falle: Eine I²C-Aufgabe, die sich explizit auf den AT91 bezieht, ist ein Hinweis auf einen Fehler in der Aufgabenstellung - der AT91 hat kein TWI.

Falle: Aussagen 3 und 7 sind die klassischen Verwechslungen (MSB/LSB und sync/async).

0x53 = 0101 0011.

• I²C (MSB zuerst): 0, 1, 0, 1, 0, 0, 1, 1.
• UART-Daten (LSB zuerst): 1, 1, 0, 0, 1, 0, 1, 0.

Falle: Das ist der meistgetestete Stolperstein des Kapitels: I²C = MSB zuerst, UART-Nutzdaten = LSB zuerst. Beim UART-Rahmen kommen außen noch Start-/Stopbit dazu, die Datenbits selbst laufen aber LSB zuerst.

Laut Skript bis zu 127 Slaves über die 7-Bit-Adresse.

Hinweis (Abweichung zur Praxis): 7 Bit ergeben rechnerisch 128 Adressen; die Skript-Zahl 127 ergibt sich, wenn man die allgemeine Ruf-Adresse 0x00 (General Call) abzieht. In der realen I²C-Spezifikation sind 16 Adressen reserviert, sodass praktisch nur 112 frei nutzbar sind. Für die Klausur zählt die Skript-Angabe 127; die Diskrepanz ist hier nur zur Einordnung vermerkt.

0x21 = 010 0001, Write → erstes Byte 0100 0010 = 0x42. 0xA5 = 1010 0101. Ablauf (MSB zuerst):

Schritt  Ereignis                         SDA (bei SCL=High)
1        START                            SDA fällt (SCL High)
2        Adressbit 6..0                   0 1 0 0 0 0 1
3        R/W-Bit                          0   (Write)
4        ACK (vom Slave)                  0
5        Datenbit 7..0                    1 0 1 0 0 1 0 1
6        ACK (vom Slave)                  0
7        STOP                             SDA steigt (SCL High)

Als Sequenzdiagramm:

sequenceDiagram
    participant M as Master
    participant S as Slave 0x21
    M->>S: START + 0100001 + R/W=0 (Write)
    S-->>M: ACK (0)
    M->>S: Datenbyte 10100101 (0xA5, MSB zuerst)
    S-->>M: ACK (0)
    M->>S: STOP

Falle: Zwischen den beiden Bytes liegt je ein ACK vom Slave (Low). Adresse+R/W ergeben zusammen genau ein 8-Bit-Rahmenbyte (0x42), nicht 7 Bit plus separates Bit.

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.

• a) Frequenz: Periode = 10 ms → f = 1/10 ms = 100 Hz.
• b) Tastverhältnis: High-Anteil 3 ms von 10 ms → 30 %.
• c) Prescaler: ideal = 5·10⁶/(100·65536) ≈ 0,76 → nächstgrößer 2 (RC = 25000 ≤ 65536).
• d) ns/Schritt: 2/5·10⁶ = 400 ns.
• e) RC: 5·10⁶/(2·100) = 25 000.
• f) RA: 0,30 · 25 000 = 7 500.
• g) RB (50 %): 0,50 · 25 000 = 12 500.

• a) S(t) = 3·sin(2π·100·t) + 1·sin(2π·200·t) + 2·sin(2π·400·t).
• b) f_max = 400 Hz.
• c) f_s > 2·400 = 800 Hz (strikt) → minimal etwas über 800 Hz.
• d) Alias = |700 − 400| = 300 Hz.

IEEE 802.3: steigende Mittenflanke = 1, fallende = 0. Flanken: steigend, fallend, steigend, steigend, fallend → 1 0 1 1 0. (Nach G. E. Thomas invertiert: 0 1 0 0 1.)

• T_step = 8/8·10⁶ = 1 µs.
• a) T = (9000 − 1000)·1 µs = 8 ms.
• b) f = 1/8 ms = 125 Hz.

• a) 8 Stufen = 2³ → 3 Bit.
• b) ΔU = 8 V/8 = 1 V.
• c) ½ LSB = 0,5 V.

• a) Ein Rechtecksignal (Fourier-Reihe der Rechteckfunktion).
• b) Ein ideales Rechteck enthält nur die ungeraden Harmonischen (100, 300, 500 Hz …); die geraden heben sich auf.
• c) Die k-te Harmonische fällt mit 1/k (1, 1/3, 1/5 …). Mehr Oberwellen → „eckiger".

Thumb ≈ 65 % der Codegröße → ca. 2600 Byte. Vorteil: höhere Codedichte, energieeffizienter/schneller bei 16-Bit-Speicher. Nachteil: eingeschränkter Befehlssatz (meist nur R0-R7, keine bedingte Ausführung außer Branches), auf 32-Bit-Speicher langsamer. Thumb-2 (Cortex-M3) mischt 16/32-Bit und hebt die Einschränkung auf.

(a) Beim Reset startet der Prozessor bei 0x00000000; dort muss nicht-flüchtiger Speicher (ROM/Flash) liegen. Im Betrieb will man an Adresse 0 aber RAM (für eine veränderbare Vektortabelle). Ein Memory Controller (EBI) blendet daher nach dem Start den RAM über Adresse 0 ein (Remapping). (b) Vektortabelle Flash → RAM kopieren: damit Interrupt-/Exception-Vektoren zur Laufzeit gesetzt/geändert werden können. Stacks je Modus setzen: ARM7 hat pro Modus (IRQ, SVC, …) einen eigenen Stackpointer, der vor der ersten Nutzung initialisiert werden muss.

Dafür: Startup-Code, Context-Switch im OS, zeitkritische ISR, extreme Optimierung, Verständnis von Compiler-Output/Fehlersuche. Dagegen: geringe Produktivität (Faktor 5-10), schlechte Lesbarkeit/Wartbarkeit, prozessorspezifisch (nicht portierbar). In großen Projekten (Linux-Kernel) < 3 %.

SPI-Leitungen: MOSI (Master Out Slave In), MISO (Master In Slave Out), SCK (Takt), SS/CS (Chip/Slave Select, pro Slave eine). Unterschiede zu I²C: (1) SPI ist Vollduplex (getrennte MOSI/MISO), I²C Halbduplex (eine SDA). (2) SPI adressiert per Chip-Select-Leitung statt per 7-Bit-Adresse. (3) SPI ist meist schneller, braucht aber mehr Leitungen. Beide sind synchron (eigener Takt).

Der Watchdog überwacht die Programmaktivität: das Programm muss in regelmäßigen Abständen ein Lebenszeichen senden (Watchdog zurücksetzen/„füttern"). Bleibt das aus (Absturz/Endlosschleife), nimmt der Watchdog einen Fehler an und löst einen Reset aus. (Analogie: Totmann-Knopf.)

USART1->US_TPR  = (uint32_t) buf;   // Transmit Pointer = Startadresse des Puffers
USART1->US_TCR  = len;              // Transmit Counter = Anzahl Bytes
USART1->US_PTCR = US_PTCR_TXTEN;    // PDC-Sender aktivieren

Die Hardware dekrementiert US_TCR bei jedem gesendeten Byte automatisch; erreicht der Zähler 0, wird der Interrupt ENDTX ausgelöst. Vorteil: die CPU ist während des Transfers frei (kein Byte-für-Byte-Polling).

(a) 0x400E0600 + 0x10 = 0x400E0610. (b) Direkt per Zeiger-Cast oder über eine Register-Struct:

*(volatile uint32_t *)(0x400E0600 + 0x10) = (1u << ID_PIOA);  // direkt
// oder sauberer:
PMC->PMC_PCER0 = (1u << ID_PIOA);   // Struct auf Basisadresse gemappt

(a) Timer 1 erzeugt eine 1-s-Periode (RC/Prescaler passend). Sein Überlauf liefert je einen Zählimpuls an Timer 2, der bis 60 zählt (Minuten); dessen Überlauf taktet Timer 3 (Stunden). (b) Die durch die Bitbreite eines einzelnen Zählers begrenzte Zeitdauer wird durch Hintereinanderschalten erweitert - so lassen sich sehr lange Zeiten (Stunden) messen/erzeugen, die ein einzelner 16-Bit-Zähler nicht schafft.

Die ersten vier Argumente werden in den Registern R0-R3 übergeben, weitere über den Stack. Der Rückgabewert steht in R0. Die Rücksprungadresse liegt im Link Register (R14/LR). C unterscheidet call by value (Wert) und call by reference (Zeiger/Adresse).

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.