Übungsaufgaben zu Zahlensystemen und Codes: dual, hexadezimal, BCD, Gray-Code, Bitmasken und Adressen

Kopiere den Text in ein KI-Sprachmodell Deiner Wahl und passe Kompetenzstufe, Anzahl, Bearbeitungszeit und Szenario bei Bedarf an. Wie die Aufgaben aufgebaut sind, beschreibt der Artikel Wie sind die Aufgaben aufgebaut?. Prüfe die Ergebnisse mit dem Lehrartikel: KI-Sprachmodelle machen Fehler.

Erstelle neue Übungsaufgaben zum Thema „Zahlensysteme und Codes: dual,
hexadezimal, BCD, Gray-Code, Bitmasken und Adressen“.

Bauplan: Halte Dich an Aufbau, Kompetenzstufen, Operatoren,
Anforderungsbereiche, Punkte und Zeitschätzung, die im Artikel
https://oer-informatik.de/aufgaben-aufbau beschrieben sind.

Fachliche Grundlage:
- https://oer-informatik.de/zahlensysteme-codes
- https://oer-informatik.de/logische-verknuepfungen
- Stilbeispiel: https://oer-informatik.de/zahlensysteme-codes-uebungsaufgaben

Die Aufgaben sollen Inhalte zu diesen Schlagwörtern abdecken:
- Zahlensysteme
- Dualzahl
- Hexadezimalzahl
- BCD-Code
- Gray-Code
- Bit
- Bitmaske
- Adressbereich
- 7-Segment-Anzeige
- I2C-Adresse

Kompetenzstufe: Kernkompetenz (alternativ: Basiskompetenz, Profilkompetenz, Expertise)
Anzahl: 1 Aufgabe mit Teilaufgaben
Bearbeitungszeit in Minuten ca.: <5 bis 30 min>
Szenario: eines der Szenarien aus dem Bauplan

Vorgehen:
1. Lies zuerst die verlinkten Artikel. Kannst Du keine Webseiten
   abrufen, sag mir das, statt zu raten.
2. Steht bei einer Angabe noch ein Platzhalter in <…>, frag mich
   zuerst danach. Richte Punkte und Zahl der Teilaufgaben nach der
   Bearbeitungszeit (ca. 0,9 min je Punkt).
3. Gib je Aufgabe Titel mit Kompetenzstufe, Ausgangssituation und
   Teilaufgaben mit Operator und Punktzahl aus, dazu die geschätzte
   Bearbeitungszeit.
4. Gib die Beispiellösungen mit Punkteverteilung erst aus, wenn ich
   danach frage.

Geg.: Zählerstand intern dual, Anzeige über BCD-Leitungen

Ges.: richtige Aussage

Richtig ist Aussage 2 (2 Punkte): Das Bit ist die kleinste Informationseinheit mit den Werten 0 und 1; 8 Bit bilden ein Byte.

• Aussage 1 ist falsch: 4 Bit sind ein Halbbyte (Nibble); ein Byte hat 8 Bit und stellt 256 Werte dar.
• Aussage 3 ist falsch: Ein Bit kennt nur 0 und 1; für eine Dezimalziffer braucht man im BCD-Code 4 Bit.
• Aussage 4 ist falsch: Kleinste Einheit ist das Bit, und ein Byte fasst 8 Bit zusammen – nicht umgekehrt.

Geg.: Zählerstand 86_{10}

Ges.: 8-Bit-Dualzahl

Zweierpotenzen abziehen (1 Punkt): 86 - 64 = 22, 22 - 16 = 6, 6 - 4 = 2, 2 - 2 = 0 → Einsen bei 64, 16, 4 und 2.

86_{10} = \underline{\underline{0101\,0110_2}}

Ergebnis mit 8 Stellen (1 Punkt). Kontrolle: 64 + 16 + 4 + 2 = 86.

Ges.: Signale an den BCD-Leitungen von Zehner- und Einerstelle

Jede Dezimalziffer wird einzeln in 4 Bit codiert (je Stelle 1 Punkt):

• Zehnerstelle 8: 1000
• Einerstelle 6: 0110

86_{10} = \underline{\underline{1000\ 0110_\mathrm{BCD}}}

Die Hunderterstelle zeigt 0 (0000). Der BCD-Wert unterscheidet sich vom Dualwert aus b) (0101 0110).

Ges.: angezeigter Zählerstand

Jedes Nibble wird einzeln als Dezimalziffer gelesen (2 Punkte, je falscher Ziffer 1 Punkt Abzug):

Angezeigt wird \underline{\underline{537}} Flaschen.

Ges.: Begründung

Im BCD-Code steht jedes Nibble für eine Dezimalziffer 0 … 9, also 0000 bis 1001. 1011 entspräche dem Wert 11 und ist keine gültige Ziffer (Pseudotetrade); die Anzeige kann ihn nicht sinnvoll darstellen (1 Punkt).

Geg.: je Zeile ein Wert: \mathrm{3C}_{16}, 1011\,0010_2, 200_{10}, 0100\,1001_\mathrm{BCD}

Ges.: fehlende Darstellungen

Je zwei richtige Zellen 1 Punkt:

Rechenwege: \mathrm{3C}_{16} = 3 \cdot 16 + 12 = 60; 1011\,0010_2 = 128 + 32 + 16 + 2 = 178, die Vierergruppen 1011 und 0010 ergeben B und 2; 200 = 128 + 64 + 8; BCD 0100 1001 = Ziffern 4 und 9 = 49 = 32 + 16 + 1.

Geg.: Adresse \mathrm{6D}_{16}; Schalter 1 = Bit 0; ON = Low = 0

Ges.: Schalterstellungen

Umrechnen (1 Punkt): \mathrm{6D}_{16} = 0110\,1101_2.

Zuordnen (1 Punkt) und invertieren, weil ON eine 0 erzeugt (1 Punkt):

\underline{\underline{\text{Schalter 2, 5 und 8 auf ON, alle anderen auf OFF}}}

Geg.: Registerinhalt \mathrm{13}_{16}, Linksschieben um n = 3

Ges.: Ergebnis dual, hexadezimal, dezimal; Rechenoperation

\begin{aligned} &\text{(I)} && x_\mathrm{neu} = x \cdot 2^n \end{aligned}

0001 0011 um drei Stellen nach links, rechts werden Nullen nachgeschoben: 1001 1000 (1 Punkt). Es fallen keine Einsen heraus.

x_\mathrm{neu} = 19 \cdot 2^3 = \underline{\underline{152 = 1001\,1000_2 = \mathrm{98}_{16}}}

Das Linksschieben um 3 Stellen entspricht einer Multiplikation mit 2^3 = 8 (1 Punkt).

Geg.: Messwert \mathrm{C8}_{16} = 200, Division durch 4

Ges.: Schieberichtung und Stellenzahl; Ergebnis dezimal

\begin{aligned} &\text{(I)} && x_\mathrm{neu} = \frac{x}{2^n}\ \text{(ganzzahlig)} \end{aligned}

Wegen 4 = 2^2 wird um 2 Stellen nach rechts geschoben (1 Punkt): 1100 1000 → 0011 0010.

x_\mathrm{neu} = \frac{200}{4} = \underline{\underline{50}}

(1 Punkt)

Ges.: Ergebnis für \mathrm{C9}_{16} mit Erläuterung

1100 1001 (201) um zwei Stellen nach rechts ergibt ebenfalls 0011 0010 = \underline{\underline{50}}. Die beiden herausgeschobenen Bits 01 gehen verloren; das Rechtsschieben ist eine ganzzahlige Division durch 4, der Rest (201 : 4 = 50 Rest 1) fällt weg (1 Punkt).

Geg.: höchstens 5000 Kartons, Zählbeginn bei 0

Ges.: Mindestanzahl Kippglieder n; größter Zählerstand

\begin{aligned} &\text{(I)} && 2^n \geq N \\ &\text{(II)} && x_\mathrm{max} = 2^n - 1 \end{aligned}

Mit dem Zählerstand 0 muss der Zähler N = 5001 Stände darstellen (1 Punkt). 2^{12} = 4096 reicht nicht, 2^{13} = 8192 genügt:

n = \lceil \log_2 5001 \rceil = \lceil 12{,}3 \rceil = \underline{\underline{13\ \text{Kippglieder}}}

(1 Punkt) Mit II:

x_\mathrm{max} = 2^{13} - 1 = \underline{\underline{8191}}

(1 Punkt) Wer mit 5000 Ständen rechnet, kommt ebenfalls auf 13 Kippglieder.

Geg.: Winkelauflösung \Delta\varphi = 0{,}2°, eine Umdrehung 360°

Ges.: Mindest-Bitbreite n

\begin{aligned} &\text{(I)} && N = \frac{360°}{\Delta\varphi} \\ &\text{(II)} && 2^n \geq N \end{aligned}

I (1 Punkt):

N = \frac{360°}{0{,}2°} = 1800\ \text{Positionen}

I in II (2 Punkte): 2^{10} = 1024 < 1800 \leq 2048 = 2^{11}

n = \underline{\underline{11\ \mathrm{Bit}}}

Geg.: n = 12\ \mathrm{Bit} bzw. 13\ \mathrm{Bit}

Ges.: Stufenzahl; Änderung

\begin{aligned} &\text{(I)} && N = 2^n \end{aligned}

N_{12} = 2^{12} = \underline{\underline{4096}}\ \text{Stufen}

(1 Punkt) Mit einem Bit mehr verdoppelt sich die Stufenzahl auf 2^{13} = 8192; der Messbereich wird doppelt so fein aufgelöst (1 Punkt).

Geg.: 4-Bit-Absolutdrehgeber; Dualwert 1100; Gray-Wert 0111

Ges.: Begründung; Gray-Wert; Dualwert

\begin{aligned} &\text{(I)} && G_3 = B_3,\quad G_i = B_{i+1} \oplus B_i \\ &\text{(II)} && B_3 = G_3,\quad B_i = B_{i+1} \oplus G_i \end{aligned}

da) (2 Punkte) Beim Gray-Code unterscheiden sich benachbarte Positionen in genau einem Bit. Liest die Auswertung genau im Übergang zwischen zwei Positionen, kann nur dieses eine Bit unsicher sein; das Ergebnis ist dann eine der beiden Nachbarpositionen. Im Dualcode ändern sich oft mehrere Bits gleichzeitig (z. B. 0111 → 1000). Schalten die Spuren nicht exakt gleichzeitig, entstehen kurzzeitig weit entfernte Fehlwerte.

db) Dual → Gray mit I (1 Punkt): G_3 = 1, G_2 = 1 \oplus 1 = 0, G_1 = 1 \oplus 0 = 1, G_0 = 0 \oplus 0 = 0

1100_2 = \underline{\underline{1010_\mathrm{Gray}}}

Gray → dual mit II (1 Punkt): B_3 = 0, B_2 = 0 \oplus 1 = 1, B_1 = 1 \oplus 1 = 0, B_0 = 0 \oplus 1 = 1

0111_\mathrm{Gray} = \underline{\underline{0101_2 = 5}}

Geg.: 37 Taktimpulse, Start bei 0

Ges.: Bitmuster beider Zähler

Je Zähler 1 Punkt:

\underline{\underline{\text{binär: } 0010\,0101 \qquad \text{BCD: } 0011\ 0111}}

Der Binärzähler stellt den ganzen Wert dual dar, der BCD-Zähler jede Dezimalstelle in einer eigenen Dekade.

Geg.: Adressbereich \mathrm{8000}_{16} … \mathrm{BFFF}_{16}, 1 Byte je Adresse

Ges.: Anzahl der Speicherplätze; Größe in KiB

\begin{aligned} &\text{(I)} && N = A_\mathrm{Ende} - A_\mathrm{Anfang} + 1 \end{aligned}

N = \mathrm{BFFF}_{16} - \mathrm{8000}_{16} + 1 = \mathrm{4000}_{16} = \underline{\underline{16\,384}}

(1 Punkt)

\frac{16\,384\ \mathrm{Byte}}{1024\ \frac{\mathrm{Byte}}{\mathrm{KiB}}} = \underline{\underline{16\ \mathrm{KiB}}}

(1 Punkt)

Geg.: 2\ \mathrm{KiB}, Anfangsadresse \mathrm{5800}_{16}

Ges.: Mindestanzahl Adressleitungen n; Endadresse

\begin{aligned} &\text{(I)} && 2^n \geq N \\ &\text{(II)} && A_\mathrm{Ende} = A_\mathrm{Anfang} + N - 1 \end{aligned}

I (2 Punkte): N = 2 \cdot 1024 = 2048 = 2^{11}

n = \underline{\underline{11\ \text{Adressleitungen}\ (A_0 \dots A_{10})}}

II (2 Punkte): 2048 = \mathrm{800}_{16}

A_\mathrm{Ende} = \mathrm{5800}_{16} + \mathrm{800}_{16} - 1 = \underline{\underline{\mathrm{5FFF}_{16}}}

Geg.: 7-Bit-Adressen; reserviert: 0 und 120 … 127; kleinere Anlage mit 45 Sensoren

Ges.: nutzbare Adressen; Mindestzahl Adressbits

\begin{aligned} &\text{(I)} && N = 2^n - N_\mathrm{reserviert} \\ &\text{(II)} && 2^n \geq N \end{aligned}

I (2 Punkte): reserviert sind 1 + 8 = 9 Adressen.

N = 2^7 - 9 = 128 - 9 = \underline{\underline{119\ \text{Teilnehmer}}}

II (1 Punkt): 2^5 = 32 < 45 \leq 64 = 2^6 → \underline{\underline{6\ \text{Adressbits}}}

Geg.: feste Bits 0100; A2 = High, A1 = High, A0 = Low

Ges.: 7-Bit-Adresse; Schreib- und Leseadresse; Beschaltung für einen zweiten Baustein

7-Bit-Adresse (1 Punkt): 0100 + 110 = 010 0110 = \underline{\underline{\mathrm{26}_{16}}}

Schreibadresse, R/W = 0 angehängt (1 Punkt): 0100 1100 = \underline{\underline{\mathrm{4C}_{16}}}

Leseadresse, R/W = 1 angehängt (1 Punkt): 0100 1101 = \underline{\underline{\mathrm{4D}_{16}}}

Zweiter Baustein (1 Punkt): Er braucht eine andere Kombination an A2 A1 A0, z. B. A0 ebenfalls an High: 111 → 7-Bit-Adresse 010 0111 = \underline{\underline{\mathrm{27}_{16}}}. Jede der übrigen sieben Kombinationen ist richtig, wenn die Adresse dazu passt; insgesamt sind 2^3 = 8 gleiche Bausteine an einem Bus möglich.

Geg.: IPv4-Adresse binär 00001010.00010100.00000011.11111110

Ges.: Dezimalschreibweise

Jedes Oktett einzeln umrechnen (je falsches Oktett 1 Punkt Abzug):

\underline{\underline{10.20.3.254}}

Geg.: Port A = \mathrm{A6}_{16} = 1010\,0110_2

Ges.: Maske, Verknüpfung, Ergebnis für Bit 2

UND-Verknüpfung mit der Maske 0000 0100 = 0x04 (1 Punkt):

  1010 0110   Port A
& 0000 0100   Maske 0x04
-----------
  0000 0100   ungleich 0

Das Ergebnis ist 0x04 ≠ 0, also ist \underline{\underline{\text{Bit 2 gesetzt}}} (1 Punkt).

Ges.: Maske, Verknüpfung, neuer Portwert

UND-Verknüpfung mit 0000 1111 = 0x0F (1 Punkt): An den Stellen 4 bis 7 steht in der Maske eine 0, diese Bits werden gelöscht; die Einsen lassen Bit 0 bis 3 unverändert.

1010\,0110 \land 0000\,1111 = 0000\,0110 = \underline{\underline{\mathrm{06}_{16}}}

(1 Punkt)

Ges.: Maske, Verknüpfung, neuer Portwert

ODER-Verknüpfung mit 0000 1001 = 0x09 (1 Punkt): Die Einsen setzen Bit 0 und Bit 3, die Nullen lassen die übrigen Bits unverändert.

1010\,0110 \lor 0000\,1001 = 1010\,1111 = \underline{\underline{\mathrm{AF}_{16}}}

(1 Punkt)

Geg.: gemeinsame Kathode (Segment leuchtet bei 1); g = Bit 0, f = Bit 1, e = Bit 2, d = Bit 3, c = Bit 4, b = Bit 5, a = Bit 6, dp = Bit 7

Ges.: Portwerte für „4“, „7“, „F“

Je Zeichen 1 Punkt:

\underline{\underline{\text{„4“} = \mathrm{33}_{16},\ \text{„7“} = \mathrm{70}_{16},\ \text{„F“} = \mathrm{47}_{16}}}

Die Ziffer 7 wird manchmal zusätzlich mit Segment f dargestellt (0x72); das ist ebenfalls richtig, wenn es begründet wird.

Ges.: Änderung; Portwert für „4“

Bei gemeinsamer Anode leuchtet ein Segment, wenn sein Ausgang Low führt. Alle Bitmuster müssen deshalb invertiert werden (1 Punkt):

\overline{0011\,0011} = 1100\,1100 = \underline{\underline{\mathrm{CC}_{16}}}

(1 Punkt) Rechnerisch ist das ein Exklusiv-ODER mit 0xFF. Auch der Dezimalpunkt (Bit 7) muss dann auf 1 stehen, damit er dunkel bleibt.