Hamming code:

Ziel: 	_ erkennen von bit-Fehlern bei Übertragung von Daten.
	_ korrektur von 1Bit-Fehlern.
Howto: 	_ zusätzlich zu Daten Bits Paritätsbits übertragen. Werden an Stelle von zweierpotenz in Datenbits eingefügt. - HÄ?
	_ Brauche 1+n Paritätsbits für Daten der Länge 2^n. (Siehe Beispiel)

a. i. Hämming Abstand: Anzahl der Bits die geändert werden müssen um von gültigen code zum nächsten zu gehen.

ii. Um d einzelbit Felhler erkennen zu können brauche ich Hämming Abstand d+1. Weil es dann nicht mehr möglich ist dass d Einzelbitfehler ein anderes gültiges Codewort erzeugen.
iii. Für eine Korrektur von d Einzelbitfehler sind Codes mit Abstand 2d+1 erforderlich, weil dann die zulässigen Codewörter soweit voneinander entfernt sind das bei d Fehlern ein Codewort immer noch näher ist als ein Anderes. - HÄ?

b. 8-bit Daten:

log2(8) = 3 => 3+1 Paritätsbit nötig
=> 8+4 Bits Hämming-Code

1  2  3  4  5  6  7  8  9  10 11 12
?  ?  1  ?  0  1  0  ?  1  1  1  0

P.Bit 1 ? 1 0 0 1 1 → 1 (Summe von belegtem) P.Bit 2 ? 1 1 0 1 1 → 0 P.Bit 4 ? 0 1 0 0 → 1 P.Bit 8 ? 1 1 1 0 → 1

Code: 101101011110

Schritte: 1. Wie lang wird mein Code:

	2. Schreibe bit Zahlen aus, Hämmings an die zweier Potenzen, mit daten bits ausfüllen.
	3. Schreibe P.Bits hin: Wo deken sie Zahlen ab?	PBit1 prüft alles wo bei Stelle 1 ne eins is, also 1, 11, 101, 111 etc
							PBit2 prüft alles wo bei Stelle 2 ne eins is, also 11, 110, 111, 1011
	4. Rechne PBits aus: Summe, 0 wenn gerade, sonst 1.

TiY:

For 01010001 Also 12Bit Hämming.

1  2  3  4  5  6  7  8  9  10 11 12
?  ?  0  ?  1  0  1  ?	0  0  0  1

PBit 1 ? 0 1 1 0 0 → 0 PBit 2 ? 0 0 1 0 0 → 1 PBit 4 ? 1 0 1 1 → 1 PBit 8 ? 0 0 0 1 → 1

Code: 010110110001

c. i. Code to Word:

1  2  3  4  5  6  7  8  9  10 11 12
1  1  0  1  0  1  1  0  0  1  1  1

P1 1 0 0 1 0 1 * P2 1 0 1 1 1 1 * P4 1 0 1 1 1 P8 0 0 1 1 1 *

Methode eins: Nummer der fehlerhaften Paritätsbits addieren ergibt Stelle des Fehlerhaften bits. Hie: 1+2+8: Bit nr 11 Methode zwei: Finde Stelle die all diese Paritätsbits prüfen.

Any way: Bit 11 is guilty.

ii. Code Word:
1  2  3  4  5  6  7  8  9  10 11 12
1  1  0  1  1  1  1  0  0  1  1  1

P1 1 0 1 1 0 1 P2 1 0 1 1 1 1 * P4 1 1 1 1 1 * P8 0 0 1 1 1 *

Falsch aber nicht findbar. Fehler bei Bit 14? Mehrere Fehler.

T_8: RAID.

RAID: redundant array of independant disk.

Ziel: 	_ Erhöhung v. Zuverlässigkeit.
	_ Erhöhung v. (Zugriffzeit) Festplatten Geschwindichkeit.
HowTo:	Mehrere ?, Platten werden zu einer logischen Platte zusammen geschaltet.
	Realisierung auf Controller Ebene. (-> Keine Software Anpassung nötig)
	Verwendung eines RAID-Controllers andstelle separater Platten-Controllers - HÄ?

RAID-Level 0: (check WIKI)

_ Unterteilung von "simulierten"? Platten in "Stripes"
_ Pro Stripe k Sektoren
_ Aufeinander folgende Stripes werden zyklisch auf laufwerke verteilt.
_ Paralleler zugriff auf =/= Platten.

a. Keine Redundanz, simuliert lediglich eine große logische Platte. b. + Maximale beschleunigung. Sei Datei aus ++ Blöcken, dann wird verteilt. Parallele bearbeitung möglich.

1. Ausfall einer Platte beschädigt Datei.

c. Datenmengen sollten gelesen werden.

 Ausfall einer Platte darf kein Schaden verursachen.
 Es muss mit geringem Aufwand möglich sein, den Datenbestand bereit zu stellen: Austausch von defekter Platte + einspielen von Backup.

d. foo

e. RAID6 erlaubt ausfall von bis zu 2 Platten, und ausfall von einer Platte während rekonstruktion möglich. (Unlike R5)

T_9: Optischer Speicher.

a. Modus 1:

16 Byte Preambel
2048 Byte Datei
258 Byte ECC
32x Geschwindichkeit
75 Sektor pro sec bei normaler Geschwindichkeit.

b. CD-ROM: Anordnung von Sektoren als Spirale

Festplatte: "" als Kreise
Positionieren auf Spirale schwieriger.

c. Audio muss konstant gelesen werden (120cm/s) d. SS DL haben 2 Schichten: Bodenschicht reflektierend, drübere nur semi. Untere Schicht benötigt größere Bits/Lands → 10% weniger Speicher.

DS SL hat das Pb nicht. (Duh.)

A11

Dnf: Disjunktive Normalform ⇒ Disjunktion (ODER-Verknüpfung + ) von Konjuktiontermen Bsp: a.b.c+d.e

KNF: Konjunktive Normalform ⇒ Konjunktion (UND-Verknüpfung . ) von Disfunktionstermen (a+b+c).(-b+d)

KDNF: nicht minimisierte Form dh jeder Term enthält jede Variable Bsp: mit a,b,c als Variablen (a.b.-c)+(-ab-c)+(-a-bc) Regeln: p.X + -p.X.-Y

K=kanonisch

a. f(a,b,c,d) = c.-a + d.-c.-b + -d.b.-a

KDNF: Regel: p.X + -p.X = X

Alle Terme müssen alle Variablen enthalten, deshalb expand mit verwendung von Regel.

b. g(a,b,c,d) = d + -d.c.a + -d.c.-a

KKNF:

Methode eins: Tabelle

a|b|c|d||d|-d.c.a|-d.c.-a|g

0|0|0|0||0| 0 | 0 |0 /!\ 0|0|0|1||1| 0 | 0 |1 0|0|1|0||0| 0 | 1 |1 0|0|1|1||1| 0 | 0 |1 0|1|0|0||0| 0 | 0 |0 /!\ 0|1|0|1||1| 0 | 0 |1 0|1|1|0||0| 0 | 1 |1 0|1|1|1||1| 0 | 0 |1 1|0|0|0||0| 0 | 0 |0 /!\ 1|0|0|1||1| 0 | 0 |1 1|0|1|0||0| 1 | 0 |1 1|0|1|1||1| 0 | 0 |1 1|1|0|0||0| 0 | 0 |0 /!\ 1|1|0|1||1| 0 | 0 |1 1|1|1|0||0| 1 | 0 |1 1|1|1|1||1| 0 | 0 |1

UND nur wahr wenn alle Literale 1 sind (wahr) g Wahr sobald ein Term wahr ist. Get everything and stuff it in: g(a,b,c,d) = -¹⁾

Sei -(a + b) = -a.-b

g(a,b,c,d) = -(-a.-b.-c.-d).-(-a.b.-c.-d).-(a.-b.-c.-d).-(a.b.-c.-d)

	= (a + b + c + d).(a + -b + c + d).(-a + b + c + d).(-a + -b + c + d)

Methode zwei:

g(a,b,c,d) = d + -d.c.a + -d.c.-a

	= d + c.-d
	= d + c

c. NOR = NOT OR Form.

T_13

Quine-McCluskey-Verfahren:

f(x) = given, check page

T_14

Vorzeichen A | Vorzeichen B | Carry In | Carry Out | Vorzeichen Ergebniss | Korr. Vorzeichen | Überlauf? | Bemerkung

0 | 0 | 0 | 0 | 0 | 0 | No | 0 | 0 | 1 | 0 | 1 | 0 | Ja | In =/= Out 0 | 1 | 0 | 0 | 1 | 1 | No | 0 | 1 | 1 | 1 | 0 | 0 | No | 1 | 0 | 0 | 0 | 1 | 1 | No | 1 | 0 | 1 | 1 | 0 | 0 | No | 1 | 1 | 0 | 1 | 0 | 1 | Ja | In =/= Out 1 | 1 | 1 | 1 | 1 | 1 | No |

Anmerkung: Wenn Vorzeichen unterschiedlich sind, dann zeigt das Carry In den betragmäßig kleineren Summanden an.

T_15

out50 = -in50. in1.-in2 +
        -in50.-in1. in2 +
        -in50. in1. in2
      = -in50.in1.-in2 +
        -in50.in2
      = -in50(in1.-in2+in2)
      = -in50(in1+in2)
      
out1 =  in50. in1.-in2 +
       -in50.-in1. in2 +
        in50. in1. in2
     =  in50. in1 +
       -in50.-in1.in2

out2 =  in50.-in1.in2 +
       -in50. in1.in2 +
        in50. in1.in2
     = in50.-in1.in2 +
       in1.in2
     = in50.-in2 +
       in1.in2
     = in2(in50+in1)

• Datenprozessor: Arithmetische Operationen
• Befehlsprozessor: Steuerung des Programmablaufs

• Einheitliche Adressierung von Programm & Daten
• Nur ein Bus

• Addressbuss: n Bit
• Datenbuss: 4*8 = 32 Bit

Verbindung zwischen CPU & RAM da hier alle Daten übertragen werden müssen.

Wenigste Code Bytes: Mem-Mem Wenigste Daten Bytes: Load-Store

Stack datenbytes änderung: 4 4 0 0 4 4 0 0 4 0 4 0 4

for(i = 0; i < 8 ; i++) {
  if(x < 0) {
    // Zweierkompliment --> linkerste bit = 1 --> wir müssen 1 rechts rein shiften
    x = x + x; //shift left (shift 0 in)
    x = x + 1; // New 0 to 1
  } else {
    x = x + 1; // Shift left
  }
}