Rechnernetze
Home Nach oben

Fehlerkorrektur mit CRC

 

In mehreren Protokollen wird mittlerweile das CRC-Verfahren verwendet, um neben Fehlererkennung auch Fehlerkorrektur durchzuführen. Die theoretischen Grundlagen zu dieser interessanten Anwendung sollen hier kurz zusammengefasst werden.

HEC X8+X2+X+1
Bluetooth X5+X4+X2+1

HEC ist ein Prüfpolynom, welches von der CCITT in der Empfehlung I.432 für die Prüfung des vier Byte langen Headers einer ATM-Zelle vorgeschlagen wird. Neben der sicheren Erkennung sämtlicher 1, 2 und 3 Bit-Fehler in dem vier Byte langen Header können sogar 1 Bit-Fehler korrigiert werden. Ebenso werden bei Bluetooth synchrone Datenblöcke (10 Bit) mit einem Generatorpolynom vom Grad 5 geschützt und 1 Bit-Fehler korrigiert (2/3 rate FEC).

Damit das Verfahren zur Fehlerkorrektur eingesetzt werden kann, sind die folgenden Eigenschaften zu zeigen:

  1. Verschiedene 1 Bit-Fehler erzeugen verschiedene Reste.
  2. 1 Bit-Fehler und 2 Bit-Fehler erzeugen verschiedene Reste.

Dann lässt sich aus dem Rest auf einen 1 Bit-Fehler schließen, bzw. bei Auftreten eines 2 Bit-Fehlers eine Korrektur ablehnen. 

Um 1. zu zeigen, beweisen wir, dass 1 Bit-Fehler unterschiedliche Reste erzeugen, falls ihr Abstand geringer ist als die Periode eines Bitfilters. Treten an den Stellen r und s zwei 1 Bit-Fehler auf, so gilt jeweils

Xr  =  G(X)*Qr(X) + Rr(X),
Xs  =  G(X)*Qs(X) + Rs(X).

Addiert man diese beiden Gleichungen, so folgt:

Xr  =  G(X)*Qr(X) + Rr(X),
Xs  =  G(X)*Qs(X) + Rs(X).
Xr + Xs  =  G(X)*[Qr(X)+Qs(X)] + Rr(X)+Rs(X).

Sind jetzt die beiden Reste gleich, Rr(X)=Rs(X), so ist deren Summe null. Dazu muss aber der Abstand von r und s gleich oder ein Vielfaches der Periode des größten Bitfilters sein.

Tritt ein 2 Bit-Fehler auf, so wird dieser erkannt, ist aber nicht korrigierbar. 2 Bit-Fehler lassen sich stets von 1 Bit-Fehler unterscheiden. Seien etwa

Xr  =  G(X)*Qr(X) + Rr(X),
Xs + Xt  =  G(X)*Qst(X) + Rst(X).

Man kann jetzt die Summe beider Polynome bilden und erhält

Xr + Xs + Xt = G(X)*Q(X) + Rr(X) + Rst(X).

Ist r von s und t verschieden, so stehen links drei Terme, sonst einer. In beiden Fällen ist jedoch der Rest eines ungeraden Fehlerpolynoms nicht null, also auch

Rr(X) + Rst(X) <> 0,

oder

Rr(X) <> Rst(X).

Wir zeigen jetzt, dass ein 1-Bit-Fehler und gewisse 3-Bit-Fehler nicht alleine anhand des Rests unterschieden werden können. Der 1-Bit-Fehler E(X)=X11 lässt den Rest

Das folgende Fehlerpolynom mit drei Bitfehlern E(X) = X11·HEC+X11 = X19+X13+X12 hat genau den gleichen Rest, nämlich

so dass ein Fehler nicht eindeutig aus dem Rest als 1-Bit-Fehler erkannt werden kann. Dennoch wird das oben beschriebene Verfahren vorgeschlagen, da man auf dem verwendeten Übertragungsmedium (LWL) in der Regel nur von vereinzelten Bitfehlern oder längeren Fehlerbursts ausgeht.

Ein entsprechendes Verfahren zur Fehlerkorrektur wird auch bei Bluetooth verwendet. Dort werden zwei verschiedene Fehlerkorrekturverfahren benutzt (die dort forward error correction: FEC genannt werden). Neben dem dreifachen Senden jedes Bits (1/3 rate FEC) wird auch eine Prüfung mit einem Generatorpolynom durchgeführt; 2/3 rate FEC: Generatorpolynom = 110101. 

Beispiel

Das (für dieses Beispiel angenehm kurze) Generatorpolynom bei Bluetooth hat die Polynomdarstellung X5+X4+X2+1 und die Bitfolge 110101. Bitfilter sind neben 0 und 1 noch 100001010011011 und dessen Komplement. Da die Periode des längstens Bitfilters 15 beträgt, können 1 Bit-Fehler mit einem Abstand bis zu 14 erkannt und eindeutig einem bestimmten Bit zugeordnet werden (der Abstand von Xr und Xs ist |r-s|). 

Im einzelnen erhalten wir

Fehler Rest Fehler Rest Fehler Rest Fehler Rest
1 00001 X4 10000 X8 10110 X12 11100
X 00010 X5 10101 X9 11001 X13 01101
X2 00100 X6 11111 X10 00111 X14 11010
X3 01000 X7 01011 X11 01110 X15 00001

Für einige 2 Bit-Fehler erhalten wir die Werte

Fehler Rest Fehler Rest Fehler Rest Fehler Rest
1+X15 00000 1+ X11 01111 1+ X7 01010 X+X14 11000
1+ X14 11011 1+ X10 00110 1+ X6 11110 X2+X14 11110
1+ X13 01100 1+X9 11000 1+ X5 10100 X3+X13 00101
1+ X12 11101 1+ X8 10111 1+ X4 10001 X4+X10 10111

Man beachte in dieser Tabelle, dass beispielsweise die 2 Bit-Fehler 1+ X8 und X4+ X10 die gleichen Reste lassen, also nicht anhand des Restes unterschieden werden können.

  1 X X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
1 - 3 5 9 17 20 30 10 23 24 6 15 29 12 27
X 00011 - 6 10 18 23 29 9 20 27 5 12 30 15 24
X2 00101 00110 - 12 20 17 27 15 18 29 3 10 24 9 30
X3 01001 01010 01100 - 24 30 23 3 30 17 15 6 20 5 18
X4 10001 10010 10100 11000 - 5 15 27 6 9 23 30 12 30 10
X5 10100 10111 10001 11101 00101 - 10 30 3 12 18 27 9 24 15
X6 11110 11101 11011 10111 01111 01010 - 20 9 6 24 17 3 18 5
X7 01010 01001 01111 00011 11011 11110 10100 - 30 18 12 5 23 6 9
X8 10111 10100 10010 11110 00110 00011 01001 11101 - 15 9 12 10 27 12
X9 11000 11011 11101 10001 01001 01100 00110 10010 01111 - 30 23 5 20 3
X10 00110 00101 00011 01111 10111 10010 11000 01100 10001 11110 - 9 27 10 29
X11 01111 01100 01010 00110 11110 11011 10001 00101 11000 10111 01001 - 18 3 20
X12 11101 11110 11000 10100 01100 01001 00011 10111 01010 00101 11011 10010 - 18 3
X13 01100 01111 01001 00101 11101 11000 10010 00110 11011 10100 01010 00011 10010 - 17
X14 11011 11000 11110 10010 01010 01111 00101 10001 01100 00011 11101 10100 00011 10001 -
X15 00000 00011 00101 01001 10001 10100 11110 01010 10111 11000 00110 01111 11101 01100 10111