/media/sda-magnetic/david/Dokumente-15/fernuni-hagen/cs-i-ii/old-cs-2-03/cs/aufg101.txt


a1  a0  b1  b0  s2  s1  s0
0   0   0   0   0   0   0   
0   0   0   1   0   0   1
0   0   1   0   0   1   0
0   0   1   1   0   1   1
0   1   0   0   0   0   1
0   1   0   1   0   1   0
0   1   1   0   0   1   1
0   1   1   1   1   0   0   
1   0   0   0   0   1   0
1   0   0   1   0   1   1
1   0   1   0   1   0   0   
1   0   1   1   1   0   1   
1   1   0   0   0   1   1
1   1   0   1   1   0   0   
1   1   1   0   1   0   1
+++++++++++++++++++++++++
1   1   1   1   1   1   1

Wie wir jetzt vermuten können, tritt der Fall auch nur dann ein, wenn wirklich alle "Eingänge" auf 1 stehen.

wir müssen bedenken unser Ausgangswertebereich geht bis s^n

Nein, falsch, da habe ich etwas falsch gelesen. Das wäre einfach. Aber der Bus am Ausgang ist so groß, wie am Eingang. Also noch Mal:

a1  a0  b1  b0  s2  s1  s0
0   0   0   0   0   0   0   
0   0   0   1   0   0   1
0   0   1   0   0   1   0
0   0   1   1   0   1   1
0   1   0   0   0   0   1
0   1   0   1   0   1   0
0   1   1   0   0   1   1
0   1   1   1   1   0   0   
1   0   0   0   0   1   0
1   0   0   1   0   1   1
1   0   1   0   1   0   0   
1   0   1   1   1   0   1   
1   1   0   0   0   1   1
1   1   0   1   1   0   0   
1   1   1   0   1   0   1
+++++++++++++++++++++++++
1   1   1   1   1   1   1

Dann habe ich aber genau deswegen eine gute Idee - sobald s2 auf 1 steht, sagt der Multiplexer: 11

Das wäre diesen Fälle


a1  a0  b1  b0  s2  s1  s0
0   1   1   1   1   0   0   
1   0   1   0   1   0   0   
1   0   1   1   1   0   1   
1   1   0   1   1   0   0   
1   1   1   0   1   0   1
1   1   1   1   1   1   1

Ich erlaube mir, weil, das Zeichnen so mühsam ist, eine Formel hin zu schreiben. Dabei führe ich den Operator

+2 ein. Er deutet auf HalbaddiererAddierer hin und +, er deutet auf Addierer hin

Also, jetzt:




a1  a0  b1  b0  s2  s1  s0
0   0   0   0   0   0   0   
0   0   0   1   0   0   1
0   0   1   0   0   1   0
0   0   1   1   0   1   1
0   1   0   0   0   0   1
0   1   0   1   0   1   0
0   1   1   0   0   1   1
1   0   0   0   0   1   0
1   0   0   1   0   1   1   
1   1   0   0   0   1   1
   
c0 = 0
s0 = a0 xor b0 xor c0
c1 = (a0 and b0) or (a0 or b0) and c0
s1 = a1 xor b1 xor c1
c2 = (a1 and b1) or (a1 or b1) and c1

So, lautet die Gleichung für den Parallel-Addierer ohne Sättigung. Jetzt mit Sättigung

c0 = 0
s0 = [a0 xor b0 xor c0] or c2
c1 = (a0 and b0) or (a0 or b0) and c0
s1 = [a1 xor b1 xor c1] or c2
c2 = (a1 and b1) or (a1 or b1) and c1

Das Lustige ist: Das stimmt auf jeden Fall: Weil, sobald wir s2 gesetzt haben, verlassen wir den Bereich 2^(n-1)-1. Aber! Das ist garantiert. Die größte Zahl ist 11.  Oder so. Aber, was ich hingeschrieben habe ist eine Forml.
Das ist natürlich verführerisch und wichtig. Weil: Schauen Sie sich Intel an - selbst, wenn es GUI's gibt, die werden etwas wie ein Intel-VHDL verwenden. Das heißt, sie schreiben es in VHDL als Formel und malen keine Bilder. 

Diese Formel hat einen Nachteil - das würde man bei VHDL stark merken: Sie hat eine Rückkoplung. Genrell nicht falsch. Aber sie hat eine Rückkopplung. Um das Problem vollständig zu lösen: Bauen wir zwei solcher Schaltungen. Und die eine Schaltung ergibt, mit dem anderen das OR. Also

A1 = a1
B1 = b1
A0 = a0
B0 = b0


C0 = 0
S0 = [A0 xor B0 xor C0] or C2
C1 = (A0 and bB) or (A0 or B0) and C0
S1 = [A1 xor B1 xor C1] or C2
C2 = (A1 and B1) or (A1 or B1) and C1

c0 = 0
s0 = [a0 xor b0 xor c0] or C2
c1 = (a0 and b0) or (a0 or b0) and c0
s1 = [a1 xor b1 xor c1] or C2
c2 = (a1 and b1) or (a1 or b1) and c1

wichtig hier: Groß und Kleinschreibung