Musterklausur SS 2020 - Lösungen

Ausführliche Lösungen zur originalen Musterklausur Mikroprozessorsysteme SS 2020 (HS Darmstadt, Prof. Akelbein). Aufgabenstellung: Klausur-SS2020-Muster.pdf (Originaldatei unter Quellen).

Gesamt: 114 Punkte, 90 Minuten, 1 doppelseitig handbeschriebenes DIN-A4-Blatt, kein Taschenrechner. Format: maschinell auswertbar (Ankreuzen / Zahlen in Kästchen).

Aufgabe 1 - Mikroprozessorsysteme (18 P) [Kap. 1]

Ankreuzen, welche Aussagen richtig sind. (R = richtig/ankreuzen, F = falsch/leer)

1.1 Mikrocontroller

  • R MC sind für spezifische Anwendungen zugeschnitten (im Gegensatz zum universellen MP).
  • R MC besitzen eine feste, on-chip integrierte Speicherausstattung.
  • R Moderne MC = SoC: alle nötigen Komponenten auf einem Chip.

1.2 Peripheriebausteine

  • R Timer und serielle Schnittstellen sind on-chip-Peripherie.
  • F Sensoren und Aktoren sind extern, nicht on-chip. Der MC integriert nur die Ansteuerung (ADC, PIO, …).
  • R Man kann MC-Varianten mit genau der benötigten Peripherie wählen.

1.3 Hardwarenahe Programmierung

  • R volatile teilt dem Compiler mit, dass sich eine Variable durch Hardware/ISR außerhalb des Programmflusses ändern kann (kein Wegoptimieren).
  • R Memory-mapped Hardwareregister lassen sich als struct abbilden.
  • F Zeiger-Casting ist in der hardwarenahen Programmierung notwendig und üblich (Adresse → Registerzeiger), nicht zu vermeiden.

1.4 Direkter Speicherzugriff (DMA)

  • F Falle: die Beschreibung ("Zugriff auf Peripherie wie auf Speicher über Adressen") ist Memory-Mapped I/O, nicht DMA.
  • R DMA entlastet den Kern beim Transfer großer Datenmengen Speicher ↔ Peripherie.
  • F DMA ist kein Grundprinzip jedes Von-Neumann-Rechners und steckt nicht in jedem MC (nur in leistungsstärkeren).

1.5 AD-Wandlung

  • F Das ist die Beschreibung der DA-Wandlung. AD wandelt analog → digital.
  • F Umgekehrt: das Wägeverfahren (sukzessive Approximation, ~N Schritte) ist schneller als das Zählverfahren (bis zu 2^N Schritte).
  • R Maximaler Quantisierungsfehler = ½ LSB (Wert des halben niederwertigsten Bits).

1.6 Interrupts

  • F Interrupts müssen nicht unterschiedliche Prioritäten haben. Der Controller kann gleiche Prioritäten über eine feste Quellen-Reihenfolge auflösen. (Grenzfall der Aufgabe - die Begründung "sonst kann er nicht entscheiden" ist zu absolut.)
  • R Die ISR-Adresse lässt sich im Interrupt-Controller (Vektorregister) registrieren; die Routine ist frei programmierbar.
  • R Der Compiler behandelt eine ISR wie eine Funktion; über ein Attribut erzeugt er den ISR-spezifischen Rahmen (Kontextsicherung, Rücksprung mit Interrupt-Freigabe).

Aufgabe 2 - Timer-Bausteine (24 P) [Kap. 5]

Gegeben (aus dem Diagramm): Periode T=10 msT = 10\,\text{ms} (RC-Reset bei 10 ms), High-Anteil 3 ms. System: fCLK=5 MHzf_{CLK}=5\,\text{MHz}, 16-Bit-Zähler, Prescaler aus {2, 8, 32, 128, 1024}.

2.1 Frequenz: f=1/T=1/10 ms=100 Hzf = 1/T = 1/10\,\text{ms} = \mathbf{100\ Hz}.

2.2 Tastverhältnis: High 3 ms von 10 ms =30 %= \mathbf{30\ \%}.

2.3 Optimaler Prescaler: RC=fCLKPresc⋅fRC = \dfrac{f_{CLK}}{\text{Presc}\cdot f} muss ≤65535\le 65535 (16 Bit) und möglichst groß sein (feinste Auflösung). Presc 2 → RC = 25000 (passt). Prescaler = 2.

2.4 ns pro Zählschritt: Tstep=PrescfCLK=25⋅106=400 nsT_{step}=\dfrac{\text{Presc}}{f_{CLK}}=\dfrac{2}{5\cdot10^6}=\mathbf{400\ ns}.

2.5 RC: RC=5⋅1062⋅100=25 000RC=\dfrac{5\cdot10^6}{2\cdot100}=\mathbf{25\,000}.

2.6 RA (30 %): TIOA wird bei RC gesetzt (High am Periodenanfang) und bei RA gelöscht → RA legt die High-Dauer fest: RA=0,30⋅25 000=7 500RA = 0{,}30 \cdot 25\,000 = \mathbf{7\,500}.

2.7 RB (50 % an TIOB): RB=0,50⋅25 000=12 500RB = 0{,}50 \cdot 25\,000 = \mathbf{12\,500}.

2.8 ACPA (RA-Effekt auf TIOA): Bei RA soll TIOA von High auf Low → clear → 1 0.

2.9 ACPC (RC-Effekt auf TIOA): Bei RC (Neustart) soll TIOA auf High → set → 0 1. (set bei RC + clear bei RA erzeugt das Signal unabhängig vom Vorzustand.)

2.10 Capture-Modus: RA und RB werden von der Hardware an den Flanken geladen (gemessen). Zur Festlegung der Messdauer (Timeout) konfiguriert man vorher nur Register C.

Aufgabe 3 - Parallele I/O mit 7-Segment (16 P) [Kap. 3]

Zwei high-aktive Ziffern. Segmente je Ziffer: a=Bit0/8, b=1/9, c=2/10, d=3/11, e=4/12, f=5/13, g=6/14. SODR setzt (Segment an), CODR löscht. Rechte Ziffer = Bits 0-6, linke Ziffer = Bits 8-14.

3.1 CODR=0x7F7F (alles aus), dann SODR=0x5B7D. 0x5B7D: rechts 0x7D→ Segmente a,c,d,e,f,g = 6; links 0x5B→ a,b,d,e,g = 2. → Anzeige 26.

3.2 SODR=0x7F7F (alles an = 88), dann CODR=0x7879. Löscht rechts {a,d,e,f,g}→ Rest b,c = 1; links {d,e,f}→ Rest a,b,c = 7. → Anzeige 71.

3.3 CODR=0x7F7F; SODR=0x006D; SODR = *PIO_OSDR << 8 + 2; Nach SODR=0x006D: rechte Ziffer = a,c,d,f,g = 5. Nun die Falle - Operator-Rangfolge: in C bindet + stärker als <<, also ist << 8 + 2 gleich << 10 (nicht << 8). Beabsichtigt war offenbar << 8, um die rechte Ziffer (Bits 0-6) auf die linke (Bits 8-14) zu kopieren → dann stünde 55. Durch das um 2 zu große Schieben landen die Bits verschoben (Segmente c,e,f der linken Ziffer) → linke Ziffer ist keine gültige Ziffer. Ergebnis: rechts 5, links "kaputt". → Lehrpunkt: Klammern setzen ((x << 8) + 2).

3.4 CODR=0x7F7F; SODR = ~0x3099; ~0x3099 setzt alle Bits außer {0,3,4,7,12,13}; im Segmentbereich bleiben also gerade die richtigen: rechts 0x66→ b,c,f,g = 4; links 0x4F→ a,b,c,d,g = 3. → Anzeige 34.

Aufgabe 4 - Signalverarbeitung (17 P) [Kap. 7]

Frequenz einer Komponente sin⁡(kπt)\sin(k\pi t): f=kπ2π=k2 Hzf = \dfrac{k\pi}{2\pi}=\dfrac{k}{2}\,\text{Hz}. Die Amplitude liest man am jeweiligen ff aus dem Amplitudendiagramm ab (nicht vorhanden → 0).

Aufg.KomponenteFrequenzAmplitude (Diagramm)
4.1sin⁡(25πt)\sin(25\pi t)12,5 Hz1,5
4.2sin⁡(50πt)\sin(50\pi t)25 Hz0
4.3sin⁡(75πt)\sin(75\pi t)37,5 Hz0
4.4sin⁡(100πt)\sin(100\pi t)50 Hz5
4.5sin⁡(150πt)\sin(150\pi t)75 Hz3
4.6sin⁡(200πt)\sin(200\pi t)100 Hz2
4.7sin⁡(250πt)\sin(250\pi t)125 Hz0
4.8sin⁡(300πt)\sin(300\pi t)150 Hz2,5

Höchste enthaltene Frequenz fmax=150 Hzf_{max}=150\,\text{Hz}, zweithöchste f2=100 Hzf_{2}=100\,\text{Hz}.

4.9 Artefaktfrei abtasten (alle Komponenten): Nyquist verlangt fs>2 fmax=300 Hzf_s > 2\,f_{max}=300\,\text{Hz}. Aus der Liste also 350, 400, 450, 500, 550, 600, 650, 700, 750, 800 Hz (300 Hz genau an der Grenze reicht nicht).

4.10 Tiefpass-Wirkung (alle außer der höchsten): 2 f2<fs≤2 fmax2\,f_2 < f_s \le 2\,f_{max} → 200<fs≤300200 < f_s \le 300 → 250 und 300 Hz. (Genau diese Aufgabe steht hinter der Formel in Kap. 7 §3.)

4.11 Datenmenge: fs=800 Hzf_s=800\,\text{Hz}, 16 Bit = 2 Byte/Wert, 10 s: D=800⋅2 Byte⋅10=16 000 ByteD = 800 \cdot 2\,\text{Byte} \cdot 10 = \mathbf{16\,000\ Byte}.

Aufgabe 5 - Cyclic Redundancy Check (12 P) [Kap. 10]

Generator g(x)=x4+x+1g(x)=x^4+x+1.

5.1 Binärform: Bits 4, 1, 0 → 10011.

5.2 Checksumme für 00110010: Nachricht + 4 Nullen = 001100100000, Modulo-2-Division (XOR 10011 an jeder führenden 1):

Start:            0 0 1 1 0 0 1 0 0 0 0 0
XOR 10011 (Bit2): 0 0 0 1 0 1 0 0 0 0 0 0
XOR 10011 (Bit3): 0 0 0 0 0 1 1 1 0 0 0 0
XOR 10011 (Bit5): 0 0 0 0 0 0 1 1 1 1 0 0
XOR 10011 (Bit6): 0 0 0 0 0 0 0 1 1 0 1 0
XOR 10011 (Bit7): 0 0 0 0 0 0 0 0 1 0 0 1

Rest = letzte 4 Bit = 1001 (das ist die CRC-Checksumme).

5.3 Hardware: Eine CRC-Erzeugung mit festem Polynom ist ein rückgekoppeltes Schieberegister mit EXOR-Gattern (LFSR). → Schieberegister + EXOR-Gatter ankreuzen.

5.4 Gültigkeit von 11110010: Division des kompletten Codeworts durch 10011 ergibt Rest 0000 → die Nachricht ist gültig.

5.5 Iterationen: Die Polynomdivision schiebt jedes Nachrichtenbit einmal ein. Bei 8 Bit sind das 8 Iterationen.

Aufgabe 6 - Serielle Schnittstelle & Leitungscodes (15 P) [Kap. 4, Kap. 10]

Wahr/Falsch (USART-Struktur):

  • 6.1 Falsch - bei asynchroner Übertragung synchronisiert das Startbit den Empfänger, also mit/nach dessen Empfang, nicht vorher.
  • 6.2 Falsch - RxD empfängt die Daten; "von einem anderen Teilnehmer" ist irreführend: RxD ist die eigene Empfangsleitung.
  • 6.3 Wahr - das Receive Shift Register deserialisiert, danach liest das Programm das Byte aus dem Receive Hold Register.
  • 6.4 Wahr - das Transmit Hold Register schiebt die Daten bitweise ins Transmit Shift Register (Serialisierung).
  • 6.5 Falsch - CTS/DCD/RTS (Handshake) werden nicht bei jeder seriellen Schnittstelle verwendet.
  • 6.6 Wahr - über Mode- und Control-Register konfiguriert das Programm die Schnittstelle.
  • 6.7 Falsch - die Unterbrechungslogik löst nicht zwingend bei jedem Zeichen einen CPU-Interrupt aus (z. B. Polling, DMA/PDC, FIFO).

6.8 / 6.9 Manchester-Dekodierung. Regel je Mitten-Flanke eines Bits:

  • IEEE 802.3: steigende Flanke = 1, fallende = 0.
  • G. E. Thomas: invertiert - steigende = 0, fallende = 1. Bitfolge (4 Bit) ablesen: pro Bitintervall die Richtung der mittigen Flanke bestimmen und gemäß der jeweiligen Konvention übersetzen. Dieselbe Signalfigur ergibt in 6.9 damit die bitweise invertierte Folge von 6.8.

Aufgabe 7 - Hardware-Interrupts (12 P) [Kap. 6, Kap. 9]

Ablauf: [A] Peripherie → Interrupt-Controller, [B] Controller → CPU, [C] CPU → Controller, [D] Controller → CPU, [E] CPU → Peripherie.

7.1 Beschreibungen zuordnen:

  • Interruptanforderung einer HW-Komponente → [A]
  • Unterbrechung des laufenden Assemblerbefehls → [B] (CPU wird signalisiert und unterbricht)
  • CPU will den Inhalt des Interrupt-Vektor-Registers lesen → [C]
  • Lädt die Adresse der ISR aus dem Vektorregister in ein CPU-Register → [D]
  • Rücksprung aus ISR mittels Branch-Befehl → [E]

7.2 Angaben zuordnen:

  • Besitzt eine Priorität 7…0, damit der Controller parallele Interrupts ordnen kann → [A] (die Anforderung trägt die Priorität)
  • Signalisiert der CPU, dass ein Interrupt zu bearbeiten ist → [B]
  • Erzeugt einen Stack für die ISR → [B] (Kontextsicherung beim Annehmen)
  • Beschreibt das End-of-Interrupt-Command-Register mit beliebigem Wert → [E]
  • Lässt die CPU wieder unterbrechbar / reentrant-fähig werden → [E] (Rücksprung gibt Interrupts wieder frei)

(Laut Aufgabenhinweis muss nicht jeder Schritt eine passende Zeile haben - Schritt [C]/[D] bleiben in 7.2 ohne Zuordnung.)

Zur Aufgabenstellung (PDF) · Probeklausuren · Startseite