Erst mal vielen Dank, für die sehr gute Erklärung!!!
so gut kann sie ja nicht gewesen sein, wenn ich jetzt sehe was du dazu schreibst ;)
(nicht böse gemeint)
Wenn ich die Kontrollbits setze gibt es ja öfters verschiedene Möglichkeiten welche ich 1 oder 0 setze,
eben nicht! entweder 1 oder 0!!
da ich z.B. bei dem Code __1_101 - jetzt nur die 1. Stelle auf 1 setzen kann (1010101) oder die anderen beiden auch (1111101), da in beiden Darstellungen die Anzahl der Einsen in der Dualdarstellung gerade ist! Welche ist nun richtig?
nein, die Quersumme des Codeworts hat damit nix zu tun!,
die 1. Stelle ist 1, weil das 3. 5. und 7. Bit 1 ist, fertig,
für die anderen Kontrollbits ist das auch genau bestimmt,
da kannst du dir nix aussuchen:
das 2. Kontrollbit muss 0 sein, da das 3., 6. und 7. Bit zwei 1en und eine 0 enthält
das 3. Kontrollbit muss 0 sein, da das 5., 6. und 7. Bit wieder aus zwei 1en und einer 0 besteht
-> 1010101
alles andere ist falsch
wie gesagt hängt das mit der Dualdarstellung der Nummern zusammen,
das 3. Kontrollbit hat eine 1 in der ersten Spalte (4 = 100),
deswegen muss man für dieses Kontrollbits alle anderen Codebits betrachten,
die ebenfalls eine 1 in der ersten Spalte der Dualdarstellung ihrer Nummer haben
(also das 5., 6., und 7. = (101, 110 und 111))
————————–
Und ich verstehe nicht ganz wie der Empfänger das macht.
Als erstes kontrolliert er ob die Summe der Einsen in der Dualdarstellung von den Bits im Code, die den Wert 1 haben gerade ist, oder?
Und wenn die ungerade ist weiß er das die Übertragung falsch ist.
der Empfänger weiss ja, dass das Codewort nach diesem Verfahren geschützt ist,
also dass 1, 2 und 4 die Kontrollbits sind,
nun kontrolliert er nicht die gesammte Quersumme des Codeworts,
welche bei diesem Verfahren NIE gebraucht wird,
sondern er rechnet die einzelnen Kontrollbits nach,
nehmen wir das Beispiel aus dem pdf
statt
0101010 kam nun
0101011 an, also das letzte Bit gekippt,
nun wird das erste Kontrollbit nachgerechnet:
Bit Nummer 1, Nummer 3, Nummer 5 und Nummer 7 ergeben zusammen drei 1en und eine Null,
da ist ein Fehler,
dann werden die anderen Kontrollbits nachgerechnet, auch ob Fehler oder nicht,
nun kam raus, dass alle 3 Kontrollbits falsch sind
-> das falsche Bit ist Nummer 7, da 1 + 2 + 4 (Zweierpotenzen der Kontrollbits) = 7 ergibt
———
wäre der Fehler im 5. Bit, sähe es dann so aus:
0101110
dann würde das 1. und 3. Kontrollbit falsch sein, das 2. wäre noch korrekt,
denn in dessen Berechnung fliesst ja der Zustand des 5. Bits gar nicht ein,
also 1 und 3 falsch -> Zweierpotenz 1 und 4 -> 5. Bit falsch,
1-Bitfehler erkannt und sogar Korrektur möglich
Aber dann? Dann schaut er von der 7. (also der ltzten Stelle) welche 1 falsch sein könnte, in dem er schaut welche Kontrollbits zu welchem "Daten"-Bit gehören. Und wenn er jetzt erkannt hat, dass 1, 2 und 4 zum 7. Bit gehören, wie erkennt er jetzt, dass das 7. Bit falsch ist?
im Grunde andersrum, er schaut an welche Kontrollbits falsch sind
und daraus wird das falsche Bit errechnet,
—————
das ganze funktioniert auch wenn die Kontrollbits Fehler aufweisen,
springt zum Beispiel das erste Kontrollbit um:
1101010
dann ergibt die Prüfung, dass die Rechnung des ersten Kontrollbits falsch ist,
während die anderen beiden Rechungen korrekt sind,
-> 1. Kontrollbit, Zweierpotenz 1 -> 1. Bit ist falsch, also das Kontrollbit,
(müsste auch gar nicht korrigiert werden, da es ja nicht zum Code gehört,
aber das nur am Rande)
P.S. was hat das eigentlich noch mit dem Hamming-Abstand zu tun? Der gibt ja nur den minimalsten Unterschie der Blöcke in einem Code an. Aber für diese Codierung muss man doch von dem gar nichts wissen, oder?
man oh man, du bist mal vorbereitet..,
denk nicht das ich dir zu jedem solch einfachen Thema
stundenlange Postings schreibe ;)
es gibt korrekte und nicht korrekte Codewörter,
im Ursprungscode 0000, 0001, 0010 usw, da ist alles erlaubt, alles korrekt,
der minimale Abstand 1,
wenn da ein Fehler bei der Übertragung auftritt:
aus dem Beispiel-Code 0010 wird 0011,
dann könnte man gar nicht erkennen, dass ein Fehler auftrat,
da ja auch 0011 ein korrektes Codewort ist,
woher sollte der Empfänger wissen dass 0010 und nicht 0011 gemeint ist?
Abhilfe schafft die Redundanz:
wenn man diese 4 Bits in 7 Bits kodiert (wie zufälllig bei diesem Verfahren ;) ),
dann hat man für die 16 Codewörte Originalcode nun 2^7 = 128 Codewörter Platz,
davon sind optimalerweise (so wie bei diesem Verfahren hier) 112 falsch,
also wenn diese ankommen weiss man das ein Fehler auftrat,
wenn ein solch langes Codewort verfälscht wird, dann gibt es 127 Möglichkeiten,
in 15 davon wird ein anderes korrektes Codewort beim Empfänger ankommen,
in 112 Fällen ein falsches,
also ist diese Übertragung schon ziemlich sicher,
da doch ein Fehler meist zu einem inkorrekten Codewort führt,
der Hammingabstand bei diesem Verfahren ist recht hoch,
nämlich 3 schätze ich mal,
das kannst du gerne einfach nachrechnen:
du nimmst die 16 Ausgangscodewörter = 0000, 0001, …
und errechnest das Codewort mit Kontrollbits,
das ergibt 16 Stück, bei denen sicher immer mindestens 3 Bits unterschiedlich sind,
da der Hammingabstand 3 ist,
bräuchte es schon 3 Bitfehler um zu einem anderen korrekten Codewort zu kommen,
-> alle 1Bitfehler werden erkannt,
wenn ein 1Bitfehler auftritt kann man sogar vermuten,
welches das ursprüngliche Codewort war,
da ja ein Codewort nur 1 Bit entfernt ist,
während alle anderen möglichen korrekten Codewörter mindestens 2 Bit entfernt sind,
-> alle 1Bitfehler können korrigiert werden
genau wie in der bekannten Hamming-Theorie:
Hammingabstand = d
-> d-1 Bitfehler werden erkannt,
-> [abgerundet(d/2)]-1 Bitfehler werden korrigiert
