Fehlererkennung Rechnernetze 1einstein.informatik.uni-oldenburg.de/lehre/semester/... · 2012. 4....
Transcript of Fehlererkennung Rechnernetze 1einstein.informatik.uni-oldenburg.de/lehre/semester/... · 2012. 4....
Rechnernetze 1 Seite 1 Prof. Dr. W. Kowalk
Rechnernetze 1FehlererkennungFehlererkennung
Rechnernetze 1 Seite 2 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
Datenübertragungüber physikalische Signalemehr oder minder hohe Anfälligkeit gegen Verfälschung der Signale
Empfänger interpretiert Signal anders als von Sender gemeint durch äußere Störeinflüsseinnere Unregelmäßigkeiten Zufall
beträchtliches Problem bei zuverlässiger Datenübertragung
Rechnernetze 1 Seite 3 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
Technische Systeme grundsätzlich nicht fehlerfrei Treten Fehler nur selten auf
innerhalb eines Rechensystemsin der Regel nicht berücksichtigt
Treten Fehler sehr häufig aufÜbertragung über stark gestörtes MediumMedium schwierig zu überprüfenFehler nicht vorhersehbar
angemessene Maßnahmen ergreifenRedundante ZusatzinformationGemeinsame BerechnungsvorschriftSender und Empfänger vergleichen ErgebnisFehlerhafte Daten korrigieren oder wiederholt senden
Rechnernetze 1 Seite 4 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
Was ist häufig?Wann ist Fehlererkennung/-korrektur notwendig?
Fehlerhäufigkeit quantitativ erfassenAuftreten von Fehlern möglichst sicher erkennen Angemessene Reaktion bei Fehlern → nächstes Kapitel
Keine absolute Sicherheit in realer Welt!heute
Korrigieren von Fehlern immer wichtiger
Rechnernetze 1 Seite 5 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
Entstehung von FehlernFehler in elektrischen Systemen
Empfänger eines Signals kann verschiedene Signalwerte nicht voneinander unterscheiden
Thermische Elektronenbewegung in Halbleitern/LeitungenElektromagnetische Einstrahlung
MotorenSpulen von ZündanlagenBlitze
Radioaktive EinstrahlungHöhenstrahlungnatürliche/künstliche Radioaktivität
Fehlerbündel (error burst)
Rechnernetze 1 Seite 6 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennungEntstehung von Fehlern
beschränkte Übertragungskapazität einer Leitung Signal zu stark gedämpft
Dämpfung frequenzabhängigunglückliche Signalfolge kann Fehler erzeugenÜberlagerung mit anderen physikalischen Effekten
elektrische Charakteristika ändern sich kurzfristig nichtFehler meist nur sehr schwierig einzugrenzenSignalveränderungen treten selten und unregelmäßig aufeinfache technische Maßnahmen häufig nicht ausreichend
elektrische Abschirmungen
Rechnernetze 1 Seite 7 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
Entstehung von FehlernZufällige Fehler
Nicht vorhersehbarKaum berechenbarFühren nicht immer zu FehlernGeräte möglichst fehlerarm ausgelegt
Messungen von Fehlern an realen SystemEinfache mathematische Modelle
Rechnernetze 1 Seite 8 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
Fehlerbeschreibungstatistische Darstellung für Auftreten falscher Werteeinfaches Modell
unabhängige Fehlerwahrscheinlichkeit Wahrscheinlichkeit für falsches Bit unabhängig von 'Vorgeschichte' (Auftreten des letzten Fehler)realistisches Modell
zufällige Fehler treten nur einzeln aufnicht gerade Fehlerbursts
ein erkanntes Bit kann verfälscht, aber richtig seinim Mittel jedes zweite 'falsche' Bit hat richtigen Wert
Fehlererkennung von Fehlerbursts mit anderen Methoden
Rechnernetze 1 Seite 9 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennungFehlerbeschreibung
Aufwändigere Modelle: Markov-Modelln Fehler in Folge im Zustand nkeine Fehler im Zustand 0Wahrscheinlichkeit zn, im Zustand n zu seinzn = p·zn-1 = pn·z0 = pn·(1-p)
Größere Anzahl von Bits einziehbarSehr geringe Fehlerwahrscheinlichkeiten
Rechnernetze 1 Seite 10 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
Fehlerhäufigkeit – BeispielSei Fehlerwahrscheinlichkeit ≈ 10-8
in Ethernet-Systemen im Mittel je Sekunde ein Fehler für praktische Anwendungen viel zu großer Wert
in fast jeder übertragenen Datei ein fehlerhaftes Bit Mehrfache Übertragung vergrößert Anzahl der Fehler schnell
Übertragungsfehler unbedingt erkennen und korrigieren!
Rechnernetze 1 Seite 11 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
Fehlerentdeckung durch RedundanzGrundlegende Methoden zur Fehlerentdeckung
fasse mehrere Bits in Blöcke zusammen fügen jedem Block ein oder mehrere Kontrollbits hinzu
Anzahl übertragener Bits größer als Nutzinformation Quantifizieren durch Redundanz relative zusätzliche Information zur Fehlererkennung
auch andere Definition (Informationstheorie) Zur Fehlerkorrektur mindestens zwei Verfahren
Falsche Blöcke werden noch einmal gesendet (ARQ)Fehlerkorrigierende Verfahren
Redundanz= Anzahl der übertragenen BitsAnzahl der Nutdatenbits
−1
Rechnernetze 1 Seite 12 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennungFehlerentdeckung durch Redundanz
ARQ-VerfahrenSender kennt richtige Nachricht Sende Nachricht bei Fehler noch einmalÜbliches Verfahren in klassischen Anwendungen
Nicht geeignet beim Lesen von verfälschten DatenträgernFehlerkorrektur
Füge ausreichend Redundanz zur Nachricht hinzuWichtig bei stark fehlerhaften Kanälen
Drahtlose Kommunikation Bluetooth� → FEC (forward error correction)
Wichtig bei Speicherung von Datenfalsche Daten bleiben falschCD-Kodierung
Rechnernetze 1 Seite 13 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennungBeispiel 1
Sende jeden Datenblock zweimal.Redundanz je Datenblock
Fehlerwahrscheinlichkeit je Datenblock
Jeden 10.000-sten Block zweimal sendenRedundanz für Datenübertragung:
R=21−1=1
P [mindestens ein Fehler in einem Block ]=
=1−1−10−71000≈ 110000,5
Redundanz= Anzahl der übertragenen BitsAnzahl der Nutdatenbits
−1=1,0001
Rechnernetze 1 Seite 14 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennungBeispiel 2
Sende jeden Datenblock dreimal.Redundanz je Datenblock
Entscheider- oder Schiedsrichterverfahren (arbiter)Bei Fehler entscheidet 'Mehrheit'
FragestellungenWahrscheinlichkeit eines unerkannten Fehlers10-7000 bei zweimaligem Senden des Datenblocks
Kosten für FehlererkennungKosten bei Nichterkennung von FehlernAbhängigkeiten von Fehlerwahrscheinlichkeiten
R=31−1=2
Rechnernetze 1 Seite 15 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlerkorrekturFehlerkorrektur
Hamming-Codesselbstkorrigierender Code (error correcting code)
Zusatzinformation um auftretende Fehler entdecken zugleich korrigieren
Hamming-CodesMathematiker Hamming (ca. 1950)
Verfahren zur Konstruktion eines Hamming-Codes
Rechnernetze 1 Seite 16 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlerkorrekturFehlerkorrekturHamming-Codes
Information mit k Bits kodierbar Alphabet umfasst höchstens 2k verschiedene Zeichen
Zusätzlich r Bits Redundanz-Information wie viele Redundanz-Bits mindestens?
Fehler von s Bits in Nachricht erkennen und korrigieren im folgenden nur s=1 (ein 1-Bit-Fehler)
b1b2...bkp1p2..pr Codewort mit k Nutzdatenbit und r Prüfbit
Hamming-Abstand zwischen zwei CodewörternAnzahl von Stellen mit verschiedenen Bits
1 1 0 0 1 0 0 10 1 0 0 1 0 1 1/ = = = = = / = => Hamming-Abstand ist 2
Rechnernetze 1 Seite 17 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlerkorrekturFehlerkorrektur
Hamming-CodesHamming-Abstand eines Alphabets
minimaler Abstand zweier verschiedener Codewörter in diesem Alphabet
konstruiere fehler-korrigierenden Code zu Alphabet mit k Bit-Wörtern, d.h. 2k Wörtern
Rechnernetze 1 Seite 18 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlerkorrekturFehlerkorrektur
Hamming-CodesCodewort C der Länge n=k+r Bits
genau ein Codewort mit Hammingabstand 0 (C) zu C genau n Codewörter mit Hamming-Abstand 1
genau eines der n Bits von C komplementiert 2k Zeichen, jedes belegt n+1 Codewörter→ (n+1)·2k Codewörter mit n Bits darstellbar→ (n+1)·2k = (k+r+1)·2k ≤ 2n = 2k+r
→ k+r+1 ≤ 2r (Hamming-Bedingung)r Prüfbits zur Sicherung von k Datenbits
Rechnernetze 1 Seite 19 Prof. Dr. W. Kowalk
Rechnernetze 1
Hamming-CodesBeispiel
k=4, r=3: k+r+1=4+3+1=8 ≤ 2r=23 = 8. Regel ordne Prüfbit r (=1,2,3) Bits mit Nummer q zu, wenn in q r-tes Bit gesetzt ist.Ist Bit q falsch, so sind die Paritäten derPrüfgruppen {pi}=P falsch, wobei:
Auf längere Bitfolgen erweiterbar!Im Prinzip auch für 2-Bitfehler
Aufwand!
FehlerkorrekturFehlerkorrektur
PrüfgruppenP P 1 2 31 001 12 010 13 011 1 14 100 15 101 1 16 110 1 17 111 1 1 1
Fehlerhaftes Bit Nr. 1 2 3 4 5 6 7Paritätsfehler in Gruppe(n) 1 2 1,2 3 1,3 2,3 1,2,3
q=∑i∈P
2i
Rechnernetze 1 Seite 20 Prof. Dr. W. Kowalk
Rechnernetze 1
Hamming-CodesBeispiel
k=4, r=3: k+r+1=4+3+1=8 ≤ 2r=23 = 8.
FehlerkorrekturFehlerkorrektur
PrüfgruppenP P 1 2 31 001 12 010 13 011 1 14 100 15 101 1 16 110 1 17 111 1 1 1
Fehlerhaftes Bit Nr. 1 2 3 4 5 6 7Paritätsfehler in Gruppe(n) 1 2 1,2 3 1,3 2,3 1,2,3
1 2 3 4 5 6 7Gruppe 1 0 0 0 0 0 0 0Gruppe 2 0 0 0 0 0 0 0Gruppe 3 0 0 0 0 0 0 0
1 0000001 1 0 0 0 0 0 02 0000010 0 1 0 0 0 0 03 0000100 0 0 1 0 0 0 04 0001000 0 0 0 1 0 0 05 0010000 0 0 0 0 1 0 06 0100000 0 0 0 0 0 1 07 1000000 0 0 0 0 0 0 1
Rechnernetze 1 Seite 21 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlerkorrekturFehlerkorrektur
Korrektur von FehlerburstsBitfehlerfolgen maximalen Länge m korrigieren.
m Codewörter in einem Block zusammenfassenzunächst erste Bits der m Codewörter sodann zweite Bits übertragenusw.
Fehlerfolge nicht länger als mhöchstens ein Bit falschlässt sich natürlich korrigierenRedundanz sehr hoch
Rechnernetze 1 Seite 22 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlerkorrekturFehlerkorrektur
Korrektur von FehlerburstsRedundanz verringern durch Erhöhung der Bits je CodewortHöchstens ein Fehlerburst je Block!Im folgenden nurnoch Fehlererkennung(Ausnahme: CRC)
Rechnernetze 1 Seite 23 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
FehlerwahrscheinlichkeitenNutzdatenlänge k BitsÜbertragungsdatenlänge n BitsDifferenz r=n-k Länge der PrüfinformationRedundanz
Blockfehlerwahrscheinlichkeit Block der Länge n Bitfehlerwahrscheinlichkeit pgenau s fehlerhafte Bits bei Binomialverteilung
R= n−kk
ps=ns⋅ps⋅1− pn− s
Rechnernetze 1 Seite 24 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
BlockfehlerwahrscheinlichkeitBlocklänge nBitfehlerwahrscheinlichkeiten pBitfehler in Block s, mindestens ein Fehler im Block
Rechnernetze 1 Seite 25 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennungBlockfehlerwahrscheinlichkeit 10-8
W. Bitfehler zu übersehen: 10-13 Blocklänge 128 Bits, wenn 1 Bitfehler erkennbarBlocklänge 1000 Bits, wenn 1+2 Bitfehler erkennbarBlocklänge 12000 Bits, wenn 1+2+3 Bitfehler erkennbar
Rechnernetze 1 Seite 26 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
mittlere Zeit bis zum nächsten Fehler mean time between error, MTBEBeispiel Ethernet
Blöcke mit 15000 Bits Länge10 MBit/s etwa 667 Blöcke je Sekunde jeder 8. falschmittlere Zeit zwischen zwei Fehlern ca. 12 msin jeder Sekunde über 80 Fehler
Mittlere Zeit zwischen zwei unentdeckten Fehlernmean time between undiscovered error, MTBUE
Rechnernetze 1 Seite 27 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennungFehlererkennung mit einem, zwei, drei Bitfehlern
Wahrscheinlichkeit eines unentdeckten fehlerhaften Ethernetblocks maximaler Länge: 5,6·10-7.Zeit zwischen zwei unentdeckten fehlerhaften Blöcken ca. 10.000 Sekunden oder 3 StundenGroße FehlerwahrscheinlichkeitQualität erheblich verbessert
Rechnernetze 1 Seite 28 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
hier Überblick über Art von Fehlernvertretbare Wahrscheinlichkeiten für unentdeckte Fehlerin Praxis häufig Fehlern nicht unabhängig Fehler in Bündeln (burst)Entdeckung von Fehlerbursts gesondert behandelnnicht in jedem Fall ein realistischen ModellAnhaltspunkte für zu treffende Maßnahmen
Rechnernetze 1 Seite 29 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
Prüfsummen
Prüfinformation einfache algebraische Verfahren arithmetische Summe (i.d.R. modulo größerer Zahl) → Prüfinformationin IP und TCP eingesetzt
Unterschiedliche Art der AdditionEiner- oder Zweierkomplementzahlen Im Internet Einerkomplement-Verfahren
Rechnernetze 1 Seite 30 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
PrüfsummenZweierkomplementzahlen ohne Überlauf
Einfache Bitfehler werden mit Sicherheit erkanntZweifache Bitfehler werden nicht alle erkannt0100 + 0010 = 01101100 + 1010 = 10110Dreifache Bitfehler werden nicht alle erkannt0100 + 0010 + 0001 = 01111100 + 0110 + 0101 = 10111
Verfahren sehr schwach!
Rechnernetze 1 Seite 31 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennungPrüfsummen
EinerkomplementzahlenIn IP (Header) TCP (Ganzer Datenblock)UDP (optional)
Einfache Bitfehler werden mit Sicherheit erkanntZweifache Bitfehler werden nicht alle erkannt0010 + 0001 = 00110000 + 0011 = 0011Dreifache Bitfehler werden nicht alle erkannt0011 + 0010 + 0000 = 01010001 + 0011 + 0001 = 0101
Verfahren sehr schwach!Sollte nach Prüfphase durch CRC ersetzt werden
Bis heute nicht geschehen
Rechnernetze 1 Seite 32 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
Paritätsprüfungsehr einfache Methode zur Fehlererkennung
ein Bit Prüfinformation Anzahl aller 1-Bits geradeauch: Summe modulo 2 ist 0auch: gerade Paritätalternativ: ungerade Parität
Prüfbit wird Paritätsbit genannt (parity bit)Redundanz 1/k
erkennt jede ungerade Anzahl von BitfehlernVerbesserungen
jeweils m<k Bits durch Paritätsbit prüfenjeweils jedes m-te Bit durch Paritätsbit prüfen
Rechnernetze 1 Seite 33 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
Paritätsprüfung von DatenblöckenVRC = Vertical Redundancy Check
Vertikale Redundanz-Prüfsumme' LRC = Longitudinal Redundancy Check
'longitudinale Prüfsumme'Redundanz
Jede ungerade Anzahl von BitfehlernZwei BitfehlerDie meisten geraden Bitfehler
VerwendungBlockprüfung bei magnetischen Datenträgern
X X X X X X X X PX X X X X X X X PX E X X E X X X PX X X X X X X X PX X X X X X X X PX E X X E X X X PX X X X X X X X PX X X X X X X X PP P P P P P P P
R= 2k
Rechnernetze 1 Seite 34 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
Zyklische Redundanzprüfung (CRC)
Cyclic Redundancy Check (CRC)Verallgemeinerung der ParitätsprüfungHeute allgemeine AnerkennungVielfache Einsatzmöglichkeiten
HDLC-LAPBLLCATMBluetooth
Rechnernetze 1 Seite 35 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
Zyklische Redundanzprüfung (CRC)
Darstellung einer Bitfolge als Polynom über Körper {+,·, {0,1}}Beispiel: 01611501401311201111009181716051403120110
Polynom: F(X) = X15+X12+X10+X8+X7+X6+X4+X2+1Körper {+,·; {0,1}}: 0+0=1+1=0, 1+0=0+1=1; 0·0=1·0=0·1=0; 1·1=1.Polynom-Rechenregeln ähnlich wie normale Rechenregeln. Jedoch:F(X)+F(X)=0
Rechnernetze 1 Seite 36 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennungZyklische Redundanzprüfung (CRC)
BeispielDivisionbeimSender
Generator 1 0 1 0 1 1 RestDividend 1 0 1 1 1 0 1 0 0 0 1 1 0 1 1 0 0 0 0 0 0
1 0 1 0 1 10 0 0 1 0 1 1 0 0 0 1 1 0 1 1 0 0 0 0 0 0
1 0 1 0 1 10 0 0 1 1 1 0 1 1 0 1 1 0 0 0 0 0 0
1 0 1 0 1 10 1 0 0 0 0 0 1 1 0 0 0 0 0 0
1 0 1 0 1 10 0 1 0 1 1 1 1 0 0 0 0 0 0
1 0 1 0 1 10 0 0 1 0 0 0 0 0 0 0 0
1 0 1 0 1 10 0 1 0 1 1 0 0 0
1 0 1 0 1 10 0 0 1 1 1 0
Sende: 1 0 1 1 1 0 1 0 0 0 1 1 0 1 1 0 0 1 1 1 0
Rechnernetze 1 Seite 37 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennungZyklische Redundanzprüfung (CRC)
BeispielDivision
Generator 1 0 1 0 1 1 RestDividend 1 0 1 1 1 0 1 0 0 0 1 1 0 1 1 0 0 1 1 1 0
1 0 1 0 1 10 0 0 1 0 1 1 0 0 0 1 1 0 1 1 0 0 1 1 1 0
1 0 1 0 1 10 0 0 1 1 1 0 1 1 0 1 1 0 0 1 1 1 0
1 0 1 0 1 10 1 0 0 0 0 0 1 1 0 0 1 1 1 0
1 0 1 0 1 10 0 1 0 1 1 1 1 0 0 1 1 1 0
1 0 1 0 1 10 0 0 1 0 0 0 0 1 1 1 0
1 0 1 0 1 10 0 1 0 1 0 1 1 0
1 0 1 0 1 10 0 0 0 0 0 0
Rechnernetze 1 Seite 38 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
Zyklische Redundanzprüfung (CRC)
Generatorpolynom G(X) vom Grad r.Nachricht U(X)Sender dividiert U(X)*Xr durch G(X) Rest D(X)U(X)*Xr = G(X)·Q(X) + D(X).Sender übermitteltU(X)��D(X)C(X) = U(X)·Xr + D(X) = G(X)·Q(X).Fehlerpolynom E(X): R(X) = C(X) + E(X).Empfänger dividiert R(X) durch G(X)Rest nicht null → Übertragungsfehler
Rechnernetze 1 Seite 39 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
Zyklische Redundanzprüfung (CRC)
Rechnernetze 1 Seite 40 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennung
Zyklische Redundanzprüfung (CRC)
1. Jedes Generatorpolynom erkennt genau ein falsches Bit
2. Jedes Generatorpolynom mit gerader Anzahl von Termen erkennt alle Fehler mit ungerader Anzahl fehlerhafter Bits
3. Jedes Generatorpolynom vom Grad r erkennt jeden Fehlerburst, dessen Länge nicht größer als r ist; bei Fehlerburst mit Länge r+1 alle Fehler bis auf einen
4. Jedes Generatorpolynom vom Grad r erkennt sämtliche 2-Bit-Fehler, die nicht in einem Vielfachen des Perioden-abstands des maximalen Generatorbitfilter zu G(X) liegen
Rechnernetze 1 Seite 41 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennungZyklische Redundanzprüfung (CRC)
Einige Generatorpolynome
CRC-16 und CRC-CCITT im wesentlichen gleich gutBitfilterlänge jeweils maximal (215-1=32767)Vielfach eingesetzt, z.B. HDLC-LAPBBlöcke bis zu 4095 Bytes optimal geschützt
CRC-33Ungerade Anzahl von Termen? Erkennt nicht (einmal) alle ungeraden Bitfehler?
CRC-16 CRC-CCITT
CRC-32 HEC
Bluetooth
X16+X15+X2+1X16+X12+X5+1X32+X26+X23+X22+X16+X12+X11+X10+X8+X7+X5+X4+X2+X+1X8+X2+X+1X5+X4+X2+1
Rechnernetze 1 Seite 42 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennungZyklische Redundanzprüfung (CRC)
FehlerkorrekturVerschiedene 1 Bit-Fehler erzeugen verschiedene Reste1 Bit- und 2 Bit-Fehler erzeugen verschiedene Reste
HEC (Header Error Correction)Im ATM-Standard: Fehlerhafter Header wird korrigiert
Bluetooth: 2/3 rate FEC15 Bit-Hammingverfahren: 10 Datenbits + 5 Bit Prüfsumme Generator = 110101Empfänger kann jeden einzelnen Bitfehler korrigierenEmpfänger kann allen zweifachen Bitfehler erkennen
HEC Bluetooth
X8+X2+X+1X5+X4+X2+1
Rechnernetze 1 Seite 43 Prof. Dr. W. Kowalk
Rechnernetze 1
FehlererkennungFehlererkennungZyklische Redundanzprüfung (CRC)
Schieberegister mit Generator Q(X) = X16 + X15 + X2 + 1Einfaches Verfahren (on-the-fly)Gleiches Verfahren bei Sender und EmpfängerPreiswerte Hardware-Realisierung