Rechnersysteme

1.1 −91,625 in IEEE 754 (32 Bit)
Wandle die Dezimalzahl −91,625 in die IEEE 754 32‑Bit‑Darstellung um.

Gesucht sind das Vorzeichenbit, der Exponent (Bias 127) und die 23‑Bit‑Mantisse als zusammenhängende Bitfolge.

1.1. Konvertieren Sie von dezimal nach IEEE754‑32bit:

−91,625 Dez =

Schritt 1 – Vorzeichen

Die Zahl ist negativ ⇒ S = 1.

Schritt 2 – Betrag in Dual umwandeln

Ganzzahlteil 91: wiederholt durch 2 teilen, Reste von unten lesen:

91 ÷ 2 = 45Rest 1 45 ÷ 2 = 22Rest 1 22 ÷ 2 = 11Rest 0 11 ÷ 2 = 5Rest 1 5 ÷ 2 = 2Rest 1 2 ÷ 2 = 1Rest 0 1 ÷ 2 = 0Rest 1

⇒ 9110 = 10110112

Nachkommateil 0,625: wiederholt mit 2 multiplizieren, ganzzahlige Anteile von oben lesen:

0,625 · 2 = 1,25→ 1 0,25 · 2 = 0,5→ 0 0,5 · 2 = 1,0→ 1

⇒ 0,62510 = 0,1012

91,62510 = 1011011,1012

Schritt 3 – Normalisieren

Komma so verschieben, dass vor dem Komma genau eine 1 steht:

1011011,1012 = 1,011011101 · 26

Schritt 4 – Exponent (Bias 127)

E = 6 + 127 = 133 = 100001012

Schritt 5 – Mantisse (23 Bit, implizite 1 weglassen)

Nachkomma‑Bits 011011101 mit Nullen auf 23 Bit auffüllen:

M = 01101110100000000000000

S (1 Bit)Exponent (8 Bit)Mantisse (23 Bit)
Ergebnis:
1 10000101 01101110100000000000000
1.2 0,40625 in IEEE 754 (32 Bit)
Wandle die Dezimalzahl 0,40625 in die IEEE 754 32‑Bit‑Darstellung um.

Die Zahl ist positiv und kleiner als 1 — der Exponent wird also negativ.

1.2. Konvertieren Sie von dezimal nach IEEE754‑32bit:

0,40625 Dez =

Schritt 1 – Vorzeichen

Positiv ⇒ S = 0.

Schritt 2 – Nachkommateil in Dual

0,40625 · 2 = 0,8125→ 0 0,8125 · 2 = 1,625→ 1 0,625 · 2 = 1,25→ 1 0,25 · 2 = 0,5→ 0 0,5 · 2 = 1,0→ 1
0,4062510 = 0,011012

Schritt 3 – Normalisieren

0,011012 = 1,101 · 2−2

Schritt 4 – Exponent

E = −2 + 127 = 125 = 011111012

Schritt 5 – Mantisse

M = 10100000000000000000000 (101 + 20 Nullen)

Ergebnis:
0 01111101 10100000000000000000000
1.3 IEEE 754 zurück in Dezimal (erste Bitfolge)
Wandle die folgende IEEE 754 32‑Bit‑Zahl in eine Dezimalzahl um:

1  10000100  00111011100000000000000

Aufteilung: 1 Vorzeichenbit · 8 Exponentenbits · 23 Mantissenbits.

1.3. Konvertieren Sie von IEEE754 nach dezimal:

1 10000100 00111011100000000000000 IEEE754 =

Aufteilen

1 10000100 00111011100000000000000

Vorzeichen

S = 1 ⇒ negativ.

Exponent

Eroh = 100001002 = 128 + 4 = 132
e = 132 − 127 = 5

Mantisse mit impliziter 1

1,00111011100000000000000

Komma um 5 Stellen nach rechts

1,00111011100… · 25 = 100111,01112
  • Ganzzahl: 1001112 = 32+4+2+1 = 39
  • Nachkomma: 0,01112 = ¼ + ⅛ + 1/16 = 0,25 + 0,125 + 0,0625 = 0,4375
Ergebnis: −39,437510
1.4 IEEE 754 zurück in Dezimal (zweite Bitfolge)
Wandle die folgende IEEE 754 32‑Bit‑Zahl in eine Dezimalzahl um:

1  01111010  00000000000000000000000

Die Mantisse ist hier komplett 0 — d. h. die normalisierte Zahl ist exakt 1,0.

1.4. Konvertieren Sie von IEEE754 nach dezimal:

1 01111010 00000000000000000000000 IEEE54 =

(Im Aufgabenblatt steht „IEEE54" — vermutlich Tippfehler, gemeint ist IEEE 754.)

Aufteilen

1 01111010 00000000000000000000000

Bestandteile

  • Vorzeichen: 1 → negativ
  • Exponent: 011110102 = 64+32+16+8+2 = 122 ⇒ e = 122 − 127 = −5
  • Mantisse: 0…0 → mit impliziter 1: 1,0
−1 · 1,0 · 2−5 = − 1/32 = −0,03125
Ergebnis: −0,0312510
1.5 Hexadezimal 253 in Dezimal
Wandle die Hexadezimalzahl 25316 in eine Dezimalzahl um.

Nutze die Stellenwerte: 16², 16¹, 16⁰.

1.5. Konvertieren Sie von hexadezimal nach dezimal:

253 Hex =

Stellenwerte

Hexadezimal nutzt die Basis 16:

25316 = 2·16² + 5·16¹ + 3·16⁰
  • 2 · 256 = 512
  • 5 · 16 = 80
  • 3 · 1 = 3

Summe: 512 + 80 + 3 = 595

Ergebnis: 253Hex = 59510
1.6 117 − 61 im Zweierkomplement (Overflow prüfen)
Berechne 117 − 61 im 8‑Bit‑Zweierkomplement.

Stelle dazu +117 und −61 jeweils als 8‑Bit‑Zweierkomplement dar, addiere sie binär (anstatt zu subtrahieren) und bestimme das Overflow‑Flag.

1.6. Führen Sie folgende arithmetische Operation im 8Bit‑Zweierkomplement‑Code durch und ermitteln Sie den Wert des Overflow‑Flags:

        117 Dez
       − 61 Dez
       ─────────

Schritt 1 – Operanden codieren

+117: 64+32+16+4+1 = 117 ⇒ 01110101

−61 über Zweierkomplement:

  • +61 = 32+16+8+4+1 = 00111101
  • Bits invertieren: 11000010
  • + 1 addieren: 11000011

Schritt 2 – Binärer Addition

   Übertrag:  1 1 1 1 0 0 0 1 1
              0 1 1 1 0 1 0 1   (+117)
            + 1 1 0 0 0 0 1 1   (−61)
            -----------------
           1 0 0 1 1 1 0 0 0   Carry‑out = 1, Ergebnis = 0011 1000

Ergebnis (8 Bit, Carry verworfen): 00111000 = 32 + 16 + 8 = 56 ✓

Schritt 3 – Overflow‑Flag

Overflow‑Flag V = Carryin,MSB XOR Carryout,MSB
Carry in das MSB: 1, Carry aus dem MSB: 1, also V = 1 ⊕ 1 = 0.

Plausibilitätscheck: Beim Addieren von positiver + negativer Zahl kann kein Overflow auftreten — passt.

117 − 61 = 56  |  Bitmuster: 0011 1000  |  Overflow V = 0
2.1 Konjunktive Normalform & Schaltnetz
Gegeben: Boolesche Funktion in DNF:

Y = A·B·C ∨ ABC ∨ A·B·C ∨ A·B·C ∨ A·B·C

 Gesucht:

1. Die konjunktive Normalform (KNF) derselben Funktion.
2. Ein Schaltnetz mit AND‑, OR‑ und NOT‑Gattern, das Y realisiert.

2.1. Konvertieren Sie die boolsche Funktion Y in ihre konjunktive Normalform.

Y = ABC ∨ ABC ∨ ABC ∨ ABC ∨ ABC

Entwerfen Sie daraus die entsprechende logische Netzwerk unter ausschliesslicher Verwendung von AND‑ OR‑ bzw. NOT‑Gattern.

Schritt 1 – Wahrheitstabelle

Die gegebene DNF enthält die Minterme m0, m4, m5, m6, m7.

#ABCY→
00001ABC
10010Maxterm
20100Maxterm
30110Maxterm
41001ABC
51011ABC
61101ABC
71111ABC

Schritt 2 – Maxterme der Y=0‑Zeilen

  • (0,0,1) → (A ∨ B ∨ C)
  • (0,1,0) → (A ∨ B ∨ C)
  • (0,1,1) → (A ∨ B ∨ C)
KNF: Y = (A ∨ B ∨ C) · (A ∨ B ∨ C) · (A ∨ B ∨ C)

Schritt 3 – Schaltnetz (AND, OR, NOT)

B 1 ¬B C 1 ¬C A B ¬C ≥1 A ¬B C ≥1 A ¬B ¬C ≥1 & Y

Signale ¬B und ¬C kommen aus den Invertern oben und gehen in die OR‑Gatter, die sie als Eingang führen.

2.2 Disjunktive Minimalform per KV‑Diagramm
Gegeben: Boolesche Funktion in 4 Variablen:

Y = ABCD ∨ ABCD ∨ ABCD ∨ ABCD ∨ ABCD ∨ ABCD

 Gesucht:

Die disjunktive Minimalform (DMF) von Y, ermittelt über ein KV‑Diagramm (4‑Variablen‑Karnaugh).

2.2. Bestimmen Sie die disjunktive Minimalform der booleschen Funktion Y:

Y = ABCD ∨ ABCD ∨ ABCD ∨ ABCD ∨ ABCD ∨ ABCD

Minterme

m3, m7, m10, m11, m14, m15

KV‑Diagramm

CD=00CD=01CD=11CD=10
AB=000010
AB=010010
AB=110011
AB=100011

Blockbildung

  • Spalte CD=11 (4er): A, B beliebig → C·D
  • 2×2‑Block unten (AB=11/10, CD=11/10): B, D beliebig → A·C
DMF: Ymin = A·C ∨ C·D = C · (A ∨ D)
2.3 2‑Bit‑Vergleicher entwerfen (A < B)
Gegeben: Zwei 2‑Bit‑Zahlen A = A1A0 und B = B1B0. Gesucht:

Eine Schaltung, deren Ausgang Ygr = 1 genau dann ist, wenn A < B. Erstelle dazu Wahrheitstabelle, ermittle die Funktion (z. B. via KV) und gib das Schaltbild an.

2.3. Entwerfen Sie einen 2‑Bit‑Vergleicher. Es sollen die 2‑Bit‑Dualzahlen A und B in Betragsdarstellung miteinander verglichen und das Ergebnis des Vergleichs ausgegeben werden (wenn A<B, dann Ygr=1).

Wahrheitstabelle

A1A0B1B0ABYgr
0000000
0001011
0010021
0011031
0100100
0101110
0110121
0111131
1000200
1001210
1010220
1011231
1100300
1101310
1110320
1111330

KV‑Diagramm und Blöcke

B1B0=00011110
A1A0=000111
010011
110000
100010
  • 4er‑Block bei A1=0, B1=1 → A1·B1
  • 2er‑Block (m1, m3) → A1·A0·B0
  • 2er‑Block (m3, m11) → A0·B1·B0
Ygr = A1·B1 ∨ A1·A0·B0 ∨ A0·B1·B0
2.4 Volladdierer entwerfen (mit Carry‑out)
Entwirf einen 1‑Bit‑Volladdierer mit den Eingängen A, B und Übertrags‑Eingang Cin, sowie den Ausgängen S (Summe) und Cout (Übertrag‑Ausgang).

Gesucht: Wahrheitstabelle für alle 8 Eingangsbelegungen sowie eine Schaltung für Cout mit genau 3 AND‑ und 2 OR‑Gattern.

2.4. Erstellen Sie die Wahrheitstabelle eines Volladdierers mit den Eingängen A, B, Cin und den Ausgängen S und Cout. Entwerfen Sie das Schaltnetz für cout ausschliesslich unter Verwendung von drei Und‑ und zwei 2 Oder‑Gattern.

Wahrheitstabelle

ABCinSCout
00000
00110
01010
01101
10010
10101
11001
11111

Formeln

S = A ⊕ B ⊕ Cin
Cout = (A·B) ∨ (A·Cin) ∨ (B·Cin)

Klammerung: Cout = ((A·B) ∨ (A·Cin)) ∨ (B·Cin) ⇒ 3 AND + 2 OR.

A B & A·B A Cin & A·Cin B Cin & B·Cin ≥1 ≥1 Cout
2.5 XOR‑Funktion nur mit NOR‑Gattern
Realisiere die Funktion

Y = (A ∨ B) · (A ∨ B)

ausschließlich mit NOR‑Gattern. Diese Funktion entspricht der XOR‑Verknüpfung (Y = A ⊕ B).

2.5. Realisieren Sie die folgende Funktion Y als Netzwerk unter ausschliesslicher Verwendung von NOR‑Gattern

Y = (A + B) * (A + B)

Schritt 1 – Funktion vereinfachen

(A+B)·(A+B) = AA + AB + AB + BB = AB + AB = A ⊕ B

Y ist also die XOR‑Funktion.

Schritt 2 – NOR‑Identitäten

  • X = NOR(X, X)
  • X · Y = NOR( X, Y )

Schritt 3 – Realisierung mit 5 NOR‑Gattern

GatterBerechnungErgebnis
N1NOR(A, A)A
N2NOR(B, B)B
N3NOR(A, B)A·B
N4NOR(N1, N2)A·B
N5NOR(N3, N4)A ⊕ B = Y
Y = NOR( NOR(A,B), NOR( NOR(A,A), NOR(B,B) ) )
A A ≥1 N1 B B ≥1 N2 A B ≥1 N3 ≥1 N4 ≥1 N5 Y
3.1 Primzahl‑Test in MIPS
Schreibe ein MIPS‑Programm, das eine vorzeichenlose ganze Zahl n einliest und ausgibt, ob sie prim ist.

Eine Zahl ist prim, wenn sie nur durch 1 und sich selbst teilbar ist. Sonderfälle: n < 2 → nicht prim, n = 2 → prim.

3.1. Entwerfen und erstellen Sie ein MIPS‑Programm zur Detektion der Prim‑Eigenschaft einer vom Benutzer einzugebenden (vorzeichenlosen) ganzen Zahl.

Algorithmus

  • Eingabe n einlesen.
  • Sonderfälle: n < 2 → nicht prim, n = 2 → prim.
  • Schleife i = 2, 3, 4… solange i·i ≤ n: wenn n mod i == 0 → nicht prim.
  • Sonst: prim.
.data
prompt: .asciiz "Zahl eingeben: "
ja:     .asciiz " ist prim.\n"
nein:   .asciiz " ist nicht prim.\n"

.text
main:
    li $v0, 4           # Prompt ausgeben
    la $a0, prompt
    syscall

    li $v0, 5           # Integer einlesen
    syscall
    move $t0, $v0       # t0 = n

    li $t4, 2
    blt $t0, $t4, notprime  # n < 2 → nicht prim
    beq $t0, $t4, isprime   # n == 2 → prim

    li $t1, 2           # Teiler i = 2
loop:
    mul $t2, $t1, $t1  # i*i
    bgt $t2, $t0, isprime # i*i > n → prim

    div $t0, $t1
    mfhi $t3              # t3 = n mod i
    beqz $t3, notprime    # Teiler gefunden

    addi $t1, $t1, 1
    j loop

isprime:
    li $v0, 1
    move $a0, $t0
    syscall
    li $v0, 4
    la $a0, ja
    syscall
    j ende

notprime:
    li $v0, 1
    move $a0, $t0
    syscall
    li $v0, 4
    la $a0, nein
    syscall

ende:
    li $v0, 10
    syscall
3.2 Teiler‑Test in MIPS (ist b Teiler von a?)
Schreibe ein MIPS‑Programm, das zwei vorzeichenlose Zahlen a und b einliest und ausgibt, ob b ein Teiler von a ist.

Hinweis: b ist Teiler von a, wenn a mod b = 0. Sonderfall: b = 0 → kein Teiler.

3.2. Entwerfen und erstellen Sie ein MIPS‑Programm, das den Benutzer auffordert zwei (vorzeichenlose) ganze Zahlen a und b einzugeben. Anschliessend soll angezeigt werden ob b ein Teiler von a ist (Ganzahldivision ohne Rest).

Algorithmus

  • a und b einlesen.
  • Falls b = 0 → kein Teiler.
  • Sonst: a mod b berechnen. Wenn 0 → Teiler, sonst nicht.
.data
pa: .asciiz "a eingeben: "
pb: .asciiz "b eingeben: "
ja: .asciiz " ist Teiler von "
no: .asciiz " ist KEIN Teiler von "
nl: .asciiz ".\n"

.text
main:
    li $v0, 4
    la $a0, pa
    syscall
    li $v0, 5
    syscall
    move $t0, $v0       # a

    li $v0, 4
    la $a0, pb
    syscall
    li $v0, 5
    syscall
    move $t1, $v0       # b

    beqz $t1, no_div    # Division durch 0 abfangen
    div $t0, $t1
    mfhi $t2             # Rest

    li $v0, 1
    move $a0, $t1
    syscall

    bnez $t2, no_div
    li $v0, 4
    la $a0, ja
    syscall
    j show_a
no_div:
    li $v0, 4
    la $a0, no
    syscall
show_a:
    li $v0, 1
    move $a0, $t0
    syscall
    li $v0, 4
    la $a0, nl
    syscall
    li $v0, 10
    syscall
3.3 Dezimal in Dual umwandeln (MIPS)
Schreibe ein MIPS‑Programm, das eine Dezimalzahl einliest und sie als Dualzahl (Binärdarstellung) ausgibt.

Idee: wiederholtes Teilen durch 2, Reste sammeln, in umgekehrter Reihenfolge ausgeben — oder bitweise von der höchsten Stelle nach unten.

3.3. Entwerfen und erstellen Sie ein MIPS‑Programm, das die vom Benutzer einzugebende (vorzeichenlose) ganze Dezimalzahl in Dual‑Code konvertiert ausgibt.

Algorithmus

Wiederholt durch 2 teilen, Reste auf den Stack legen, anschließend in umgekehrter Reihenfolge ausgeben.

.data
prompt: .asciiz "Dezimalzahl: "
nl:     .asciiz "\n"

.text
main:
    li $v0, 4
    la $a0, prompt
    syscall
    li $v0, 5
    syscall
    move $t0, $v0       # n
    li $t1, 0            # Zähler

    bnez $t0, push_loop
    li $a0, '0'
    li $v0, 11
    syscall
    j ende

push_loop:
    beqz $t0, pop_loop
    andi $t2, $t0, 1
    addi $sp, $sp, -4
    sw $t2, 0($sp)
    srl $t0, $t0, 1
    addi $t1, $t1, 1
    j push_loop

pop_loop:
    beqz $t1, ende
    lw $t2, 0($sp)
    addi $sp, $sp, 4
    addi $t2, $t2, '0'
    move $a0, $t2
    li $v0, 11
    syscall
    addi $t1, $t1, -1
    j pop_loop

ende:
    li $v0, 4
    la $a0, nl
    syscall
    li $v0, 10
    syscall
3.4 Dezimal in Hexadezimal umwandeln (MIPS)
Schreibe ein MIPS‑Programm, das eine Dezimalzahl einliest und sie als Hexadezimalzahl ausgibt.

Hinweis: 4‑Bit‑Blöcke (Nibbles) bilden je eine Hex‑Ziffer. Für Werte ≥ 10 wird der Buchstabe A–F ausgegeben.

3.4. Entwerfen und erstellen Sie ein MIPS‑Programm, das die vom Benutzer einzugebende (vorzeichenlose) ganze Dezimalzahl in Hexadezimal‑Code konvertiert ausgibt.

Algorithmus

4‑Bit‑Nibbles von rechts mit andi … , 0xF abschneiden, auf den Stack legen, anschließend in umgekehrter Reihenfolge über eine Ziffern‑Tabelle ausgeben.

.data
prompt: .asciiz "Dezimalzahl: "
pref:   .asciiz "0x"
nl:     .asciiz "\n"
hexd:   .asciiz "0123456789ABCDEF"

.text
main:
    li $v0, 4
    la $a0, prompt
    syscall
    li $v0, 5
    syscall
    move $t0, $v0

    li $v0, 4
    la $a0, pref
    syscall

    li $t1, 0
    bnez $t0, push_loop
    li $a0, '0'
    li $v0, 11
    syscall
    j ende

push_loop:
    beqz $t0, pop_loop
    andi $t2, $t0, 0xF
    addi $sp, $sp, -4
    sw $t2, 0($sp)
    srl $t0, $t0, 4
    addi $t1, $t1, 1
    j push_loop

pop_loop:
    beqz $t1, ende
    lw $t2, 0($sp)
    addi $sp, $sp, 4
    la $t3, hexd
    add $t3, $t3, $t2
    lb $a0, 0($t3)
    li $v0, 11
    syscall
    addi $t1, $t1, -1
    j pop_loop

ende:
    li $v0, 4
    la $a0, nl
    syscall
    li $v0, 10
    syscall
3.5 Hexadezimal in Dezimal umwandeln (MIPS)
Schreibe ein MIPS‑Programm, das eine Hexadezimalzahl als String einliest (z. B. 1A3F) und sie als Dezimalwert ausgibt.

Idee: zeichenweise verarbeiten — bisheriges Ergebnis mit 16 multiplizieren (Linksshift um 4) und die nächste Ziffer addieren. Akzeptiert 0–9, A–F und a–f.

3.5. Entwerfen und erstellen Sie ein MIPS‑Programm, das die vom Benutzer einzugebende Hexadezimal‑Zahl in Dezimal‑Code konvertiert ausgibt.

Algorithmus

String einlesen, Zeichen für Zeichen interpretieren: bisheriges Ergebnis mit 16 multiplizieren (Linksshift um 4), Ziffer dekodieren und addieren. Akzeptiert 0‑9, A‑F, a‑f.

.data
prompt: .asciiz "Hex eingeben: "
out:    .asciiz "Dezimal: "
nl:     .asciiz "\n"
buf:    .space 32

.text
main:
    li $v0, 4
    la $a0, prompt
    syscall

    li $v0, 8             # String einlesen
    la $a0, buf
    li $a1, 32
    syscall

    la $t0, buf            # Zeiger
    li $t1, 0             # Akku

parse:
    lb $t2, 0($t0)
    beqz $t2, done
    beq $t2, 10, done     # Newline

    sll $t1, $t1, 4     # Akku · 16

    blt $t2, '0', skip
    bgt $t2, '9', try_AZ
    addi $t2, $t2, -'0'
    j add_d
try_AZ:
    blt $t2, 'A', skip
    bgt $t2, 'F', try_az
    addi $t2, $t2, -'A'+10
    j add_d
try_az:
    blt $t2, 'a', skip
    bgt $t2, 'f', skip
    addi $t2, $t2, -'a'+10
add_d:
    add $t1, $t1, $t2
skip:
    addi $t0, $t0, 1
    j parse

done:
    li $v0, 4
    la $a0, out
    syscall
    li $v0, 1
    move $a0, $t1
    syscall
    li $v0, 4
    la $a0, nl
    syscall
    li $v0, 10
    syscall