/media/sda-magnetic/david/Dok-15-2023-11-27/informatik/ASM-DIAGRAM-GENERATOR-2024-01-28/aufgabe20240124.txt


Aufgabe I-1
a)

Die Primimplikanten sind

not x4 and not x3 and x2 and x1

x4 and not x2
x4 and x1

b)

P1 ist Kernimplikant
P4 ist Kernimplikant

c)

c1)
1 Bit Komperator

b a     a = b   a < b   a > b
0 0     1       0       0
0 1     0       1       0
1 0     0       0       1
1 1     1       0       0

c2)

Volladdierer:
S = A XOR B XOR C
U = (A AND B) OR ((A OR B) AND C)

b   a       c   s
0   0       0   0
0   1       0   1
1   0       0   1
1   1       1   0

d)
1010101

2^0 + 2^2 + 2^4 + 2^6

1 + 4 + 8 + 64

9 + 68
77

7 111
6 stellig

000 111

Einerkomplement

111 000

111 001

d4)
11011001
00100110

2^1 + 2^2 + 2^5

1+4+32 = 37

-37

Aufgabe I-2
a)

Zustand     Eingabe     Ausgabe     Folgezustand        Code Folgezustand
                                                        z3+ z2+ z1+ z0+
0           0           0           2                   0   1   0   0
0           1           1           1                   0   0   1   0
1           0           0           3                   1   0   0   0
1           1           1           2                   0   1   0   0
2           0           1           1                   0   0   1   0
2           1           0           3                   1   0   0   0
3           0           1           0                   0   0   0   1
3           1           0           2                   0   1   0   0

z3+
Zustand     Eingabe     Ausgabe     Folgezustand        Code Folgezustand
                                                        z3+ z2+ z1+ z0+
1           0           0           3                   1   0   0   0
2           1           0           3                   1   0   0   0

z3+ <= (z1 and not x) or (z2 and x)


z2+
Zustand     Eingabe     Ausgabe     Folgezustand        Code Folgezustand
                                                        z3+ z2+ z1+ z0+
0           0           0           2                   0   1   0   0
1           1           1           2                   0   1   0   0
3           1           0           2                   0   1   0   0

z2+ <= (z0 and not x) or (z1 and x) or (z3 and x)

z1+
Zustand     Eingabe     Ausgabe     Folgezustand        Code Folgezustand
                                                        z3+ z2+ z1+ z0+
0           1           1           1                   0   0   1   0
1           0           1           1                   0   0   1   0

z1+ <= (z0 and x) or (z1 and not x)

z0+

Zustand     Eingabe     Ausgabe     Folgezustand        Code Folgezustand
                                                        z3+ z2+ z1+ z0+
3           0           1           0                   0   0   0   1

z0+ <= (z3 and not x)


y

Zustand     Eingabe     Ausgabe     Folgezustand        Code Folgezustand
                                                        z3+ z2+ z1+ z0+
0           1           1           1                   0   0   1   0
1           1           1           2                   0   1   0   0
2           0           1           1                   0   0   1   0
3           0           1           0                   0   0   0   1

y <= (z0 and x) or (z1 and x) or (z2 and not x) or (z3 and not x)


z3+ <= (z1 and not x) or (z2 and x)
z2+ <= (z0 and not x) or (z1 and x) or (z3 and x)
z1+ <= (z0 and x) or (z1 and not x)
z0+ <= (z3 and not x)
y <= (z0 and x) or (z1 and x) or (z2 and not x) or (z3 and not x)

b)

Zustand     Eingabe     Ausgabe     Folgezustand        Code Folgezustand
                                                        z3+ z2+ z1
1           0           1           3                   1   0   0

z3+ <= (z1 and not x)



z3+
Zustand     Eingabe     Ausgabe     Folgezustand        Code Folgezustand
                                                        z3+ z2+ z1
2           0           1           3                   1   0   0



z2+
Zustand     Eingabe     Ausgabe     Folgezustand        Code Folgezustand
                                                        z3+ z2+ z1
1           0           0           2                   0   1   0
1           1           0           2                   0   1   0
2           1           0           2                   0   1   0
3           1           0           2                   0   1   0

z2+ <= z1 or (z2 and x) or (z3 and x)



z1+
Zustand     Eingabe     Ausgabe     Folgezustand        Code Folgezustand
                                                        z3+ z2+ z1
3           0           1           1                   0   0   1

z1+ <= (z3 and not x)


y
Zustand     Eingabe     Ausgabe     Folgezustand        Code Folgezustand
                                                        z3+ z2+ z1
3           0           1           1                   0   0   1

y <= (z3 and not x)

z3+ <= (z1 and not x)
z2+ <= z1 or (z2 and x) or (z3 and x)
z1+ <= (z3 and not x)
y <= (z3 and not x)

c) Zustandsminimierung üben

Aufgabe I-3

a) A hat den Wert 4. Die "Schleife" (Iteration) bricht ab, sobald A grösser 3 ist. Bis dahin wird inkrementiert

b) Den Wert 1. Innerhalb eines Zustandes herrscht das Prinzip, dass echte Datenabhängigkeit nicht aufgelöst wird.

c) Damit wird eine Multiplikation erreicht. Zunächst eine Reihe. Doch die Multiplikation ist eine Reihe von Konstanten Werten. Es findet so oft statt, bis B = 0 ist
Damit lautet die Multiplikation A*B