Erkennbare und nicht erkennbare Fehler

Erkennbare und nicht erkennbare Fehler

Ein Fehler ist nicht erkennbar genau dann wenn:

· →

Single‐Bitfehler ist immer erkennbar, wenn P(X) mindestens zwei Terme enthält

Bitfehler‐Burst < Anzahl Check‐Bits ist immer erkennbar, wenn P(X) den Term 1 enthält

Erkennbare und nicht erkennbare Fehler

Ein Fehler ist nicht erkennbar genau dann wenn:

· →

Single‐Bitfehler ist immer erkennbar, wenn P(X) mindestens zwei Terme enthält

; ∄ ·

Bitfehler‐Burst < Anzahl Check‐Bits ist immer erkennbar, wenn P(X) den Term 1 enthält

Erkennbare und nicht erkennbare Fehler

Ein Fehler ist nicht erkennbar genau dann wenn:

· →

Single‐Bitfehler ist immer erkennbar, wenn P(X) mindestens zwei Terme enthält

; ∄ ·

Bitfehler‐Burst < Anzahl Check‐Bits ist immer erkennbar, wenn P(X) den Term 1 enthält

· ⋯ 1

Weitere CRC‐Fakten

Double‐Bitfehler immer erkennbar, wenn P(X) einen Faktor mit drei Termen  besitzt (ohne Beweis)

·

Ungeradzahlige Bitfehler immer erkennbar, solange P(X) einen Faktor (X+1)  enthält  (ohne Beweis)

·

Beliebte Polynome

CRC‐12 =  X

+ X

+ X

+ X

+ 1 CRC‐16 =  X

+ X

+ X

+ 1

CRC‐CCITT =  X

+ X

+ X

+ 1

CRC‐32 =  X

+ X

+ X

+ X

+ X

+ X

+ X

+ X

+ X

+ X

+ X

+ X

+ X

+ X + 1

Fehlerkorrektur

Ablauf der Fehlerkorrektur

Beispiel Two‐Dimensional‐Parity

0 1 0 1

1 1 1 0

0 1 1 0

1 0 0 1

Beispiel Two‐Dimensional‐Parity

0 1 0 1 0

1 1 1 0 1

0 1 1 0 0

1 0 0 1 0

0 1 0 0 1

Erkenn‐ und Korrigierbarkeit von Fehlern

0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1

0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1

Ein‐Bit‐Fehler immer korrigierbar

0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1

Zwei‐Bit‐Fehler nicht immer korrigierbar

0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1

Zwei‐Bit‐Fehler immer erkennbar Nicht‐erkennbarer Fehler

Erkenn‐ und Korrigierbarkeit von Fehlern

0 1 0 1 0 1 0 1 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1

0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1

Ein‐Bit‐Fehler immer korrigierbar

0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1

Zwei‐Bit‐Fehler nicht immer korrigierbar

0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1

Zwei‐Bit‐Fehler immer erkennbar Nicht‐erkennbarer Fehler

Erkenn‐ und Korrigierbarkeit von Fehlern

0 1 0 1 0 1 0 1 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1

0 1 0 1 0 1 0 1 0 1 0 1 0 0 0 1 0 0 1 0 0 1 0 0 1

Ein‐Bit‐Fehler immer korrigierbar

0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1

Zwei‐Bit‐Fehler nicht immer korrigierbar

0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1

Zwei‐Bit‐Fehler immer erkennbar Nicht‐erkennbarer Fehler

Erkenn‐ und Korrigierbarkeit von Fehlern

0 1 0 1 0 1 0 1 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1

0 1 0 1 0 1 0 1 0 1 0 1 0 0 0 1 0 0 1 0 0 1 0 0 1

Ein‐Bit‐Fehler immer korrigierbar

0 1 0 1 0 1 0 0 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1

Zwei‐Bit‐Fehler nicht immer korrigierbar

0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1

Zwei‐Bit‐Fehler immer erkennbar Nicht‐erkennbarer Fehler

Erkenn‐ und Korrigierbarkeit von Fehlern

0 1 0 1 0 1 0 1 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1

0 1 0 1 0 1 0 1 0 1 0 1 0 0 0 1 0 0 1 0 0 1 0 0 1

Ein‐Bit‐Fehler immer korrigierbar

0 1 0 1 0 1 0 0 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1

Zwei‐Bit‐Fehler nicht immer korrigierbar

0 1 0 1 0 1 0 0 0 1 0 0 0 0 0 1 0 0 1 0 0 1 0 0 1

Zwei‐Bit‐Fehler immer erkennbar Nicht‐erkennbarer Fehler

Hamming‐Distanz

Hamming‐Distanz d(v₁, v₂) zwischen zwei n‐Bit‐Sequenzen v₁ und v₂

Beispiel: vier 4‐Bit‐Sequenzen mit einer  paarweisen Hamming‐Distanz von 

mindestens 2

Wieviele Bit‐Fehler können erkannt  werden?

Hamming‐Distanz

Hamming‐Distanz d(v₁, v₂) zwischen zwei n‐Bit‐Sequenzen v₁ und v₂

Beispiel: vier 4‐Bit‐Sequenzen mit einer  paarweisen Hamming‐Distanz von 

mindestens 2

Wie viele Bit‐Fehler können erkannt  werden?

Hamming‐Distanz

Hamming‐Distanz d(v₁, v₂) zwischen zwei n‐Bit‐Sequenzen v₁ und v₂

Beispiel: vier 4‐Bit‐Sequenzen mit einer  paarweisen Hamming‐Distanz von 

mindestens 2

Wie viele Bit‐Fehler können erkannt  werden?

Allgemein:

Ablauf der Übertragung im Falle keiner Bitfehler

Block‐Codes

Datenblock Codewort 00 -> 00000 01 -> 00111 10 -> 11001 11 -> 11110

Erkennen von Bit‐Fehlern: Es sei Code = {b₁,...,b_k} und es werde b empfangen: 

Sender

Empfänger

f : Datenblock 

Codewort

Allgemein:

Ablauf der Übertragung im Falle keiner Bitfehler

Block‐Codes

Datenblock Codewort 00 -> 00000 01 -> 00111 10 -> 11001 11 -> 11110

Erkennen von Bit‐Fehlern: Es sei Code = {b₁,...,b_k} und es werde b empfangen: 

(1)  ∃ : , 0 ⇒

(2)   ∀ : , 0 ⇒ !

Sender

Empfänger

f : Datenblock 

Codewort

Korrigieren von Bit‐Fehlern: Es sei Code = {b

,...,b

} und es werde b empfangen: 

Korrigieren von Bitfehlern

Empfangen        Nächstes gültiges CW       Daten

00000 00000 00

00011 00111 01

01010 ??? ??

Datenblock Codewort

00 -> 00000

01 -> 00111

10 -> 11001

11 -> 11110

Korrigieren von Bit‐Fehlern: Es sei Code = {b

,...,b

} und es werde b empfangen:

(1) 

(2)  otherwise Error

Korrigieren von Bitfehlern

Empfangen        Nächstes gültiges CW       Daten

00000 00000 00

00011 00111 01

01010 ??? ??

Datenblock Codewort

00 -> 00000

01 -> 00111

10 -> 11001

11 -> 11110

Für k Daten‐Bits und n‐Bit Code‐Wörter gilt

Eindeutiges C‐Wort für jeden D‐Block, also

Benötigte Anzahl gültiger Code‐Wörter

Redundante Bits und Code‐Redundanz

Code‐Rate

Code‐Distanz für Code {b₁,...,b_k} ,

Benötigtes Verhältnis zwischen k und r=n‐

k zum Korrigieren von allen 1‐Bit‐Fehlern?

Für k Daten‐Bits und n‐Bit Code‐Wörter gilt

Eindeutiges C‐Wort für jeden D‐Block, also

Benötigte Anzahl gültiger Code‐Wörter

Redundante Bits und Code‐Redundanz

Code‐Rate

Code‐Distanz für Code {b₁,...,b_k} ,

Benötigtes Verhältnis zwischen k und r=n‐

k zum Korrigieren von allen 1‐Bit‐Fehlern?

For every code word b (CW) exists n possible code words with Hamming distace 1

For every data block we need bit patterns

So we need for that in total:

· bit patterns From this we have:

·

Für k Daten‐Bits und n‐Bit Code‐Wörter gilt

Eindeutiges C‐Wort für jeden D‐Block, also

Benötigte Anzahl gültiger Code‐Wörter

Redundante Bits und Code‐Redundanz

Code‐Rate

Code‐Distanz für Code {b₁,...,b_k} ,

Benötigtes Verhältnis zwischen k und r=n‐

k zum Korrigieren von allen 1‐Bit‐Fehlern?

And total number of redundant bits is:

Hamming‐Code

•

If we have 7 bits of data, how many check bits do we need?

•

k = 7, r = ?

Hamming‐Code

•

If we have 7 bits of data, how many check bits do we need?

•

k = 7, r = ?

•

=> r = 0 => 8 <= 1 => False

•

=> r = 1 => 9 <= 2 => False

•

=> r = 2 => 10 <= 4 => False

•

=> r = 3 => 11 <= 8 => False

•

=> r = 4 => 12 <= 16 => True!!!

• => r = 4

Hamming‐Code

•

If we have 7 bits of data, how many check bits do we need?

•

k = 7, r = ?

•

=> r = 0 => 8 <= 1 => False

•

=> r = 1 => 9 <= 2 => False

•

=> r = 2 => 10 <= 4 => False

•

=> r = 3 => 11 <= 8 => False

•

=> r = 4 => 12 <= 16 => True!!!

• => r = 4

• How do we calculate check bits and how do we 

organize data?

Hamming‐Code

1       2        3       4       5       6        7       8       9       10     11

Daten‐Bits Check‐Bits

3 = 0 0 1 1 5 = 0 1 0 1 6 = 0 1 1 0 7 = 0 1 1 1 9 = 1 0 0 1 10 = 1 0 1 0 11 = 1 0 1 1

Beispiel‐Daten‐Bits:

1 0 0 1 0 0 0

Hamming‐Code

1       2        3       4       5       6        7       8       9       10     11

Daten‐Bits Check‐Bits

3 = 0 0 1 1 5 = 0 1 0 1 6 = 0 1 1 0 7 = 0 1 1 1 9 = 1 0 0 1 10 = 1 0 1 0 11 = 1 0 1 1

Beispiel‐Daten‐Bits:

1 0 0 1 0 0 0

Hamming‐Code

1       2        3       4       5       6        7       8       9       10     11

Daten‐Bits Check‐Bits

3 = 0 0 1 1 5 = 0 1 0 1 6 = 0 1 1 0 7 = 0 1 1 1 9 = 1 0 0 1 10 = 1 0 1 0 11 = 1 0 1 1

Beispiel‐Daten‐Bits:

1 0 0 1 0 0 0

Hamming‐Code

1       2        3       4       5       6        7       8       9       10     11

Daten‐Bits Check‐Bits

3 = 0 0 1 1 5 = 0 1 0 1 6 = 0 1 1 0 7 = 0 1 1 1 9 = 1 0 0 1 10 = 1 0 1 0 11 = 1 0 1 1

Beispiel‐Daten‐Bits:

1 0 0 1 0 0 0

Hamming‐Code

1       2        3       4       5       6        7       8       9       10     11

Daten‐Bits Check‐Bits

3 = 0 0 1 1 5 = 0 1 0 1 6 = 0 1 1 0 7 = 0 1 1 1 9 = 1 0 0 1 10 = 1 0 1 0 11 = 1 0 1 1

Beispiel‐Daten‐Bits:

1 0 0 1 0 0 0

Hamming‐Code

1       2        3       4       5       6        7       8       9       10     11

Daten‐Bits Check‐Bits

3 = 0 0 1 1 5 = 0 1 0 1 6 = 0 1 1 0 7 = 0 1 1 1 9 = 1 0 0 1 10 = 1 0 1 0 11 = 1 0 1 1

Beispiel‐Daten‐Bits:

1 0 0 1 0 0 0

Hamming‐Code

0 0 1 1 0 0 1

1       2        3       4       5       6        7       8       9       10     11

0 0 0 0

3 = 0 0 1 1 5 = 0 1 0 1 6 = 0 1 1 0 7 = 0 1 1 1 9 = 1 0 0 1 10 = 1 0 1 0 11 = 1 0 1 1

Beispiel‐Daten‐Bits:

1 0 0 1 0 0 0

Erkennen eines Ein‐Bit‐Fehlers

0 0 1 1 0 0 1

1       2        3       4       5       6        7       8       9       10     11

0 0 0 0

0 0 1 1 0 1 1 0 0 0 0

Original Code‐Wort

Ein‐Bit‐Fehler

3 = 0 0 1 1 5 = 0 1 0 1 6 = 0 1 1 0 7 = 0 1 1 1 9 = 1 0 0 1 10 = 1 0 1 0 11 = 1 0 1 1

Check Ergebnis

Daten‐Bits Check‐Bits

Erkennen eines Ein‐Bit‐Fehlers

0 0 1 1 0 0 1

1       2        3       4       5       6        7       8       9       10     11

0 0 0 0

0 0 1 1 0 1 1 0 0 0 0

Original Code‐Wort

Ein‐Bit‐Fehler

3 = 0 0 1 1 5 = 0 1 0 1 6 = 0 1 1 0 7 = 0 1 1 1 9 = 1 0 0 1 10 = 1 0 1 0 11 = 1 0 1 1

0 1 1 0

Check Ergebnis

Daten‐Bits Check‐Bits

=6

Hamming‐Code erreicht die Schranke

Wie eben für k Daten‐Bits und n‐Bit Code‐Wörter ausgerechnet:

Benötigtes Verhältnis zwischen k und r=n‐k zum Korrigieren von allen 1‐Bit‐

Fehlern:

r+k+1  ^≤ 2 ^r

Beispiel für unten abgebildeten Hamming‐Code:

1       2        3       4       5       6        7       8       9       10     11     12     13     14     15

Daten‐Bits Check‐Bits Was wenn Daten nur bis 11?

n = 15

k = 11

r = 4

Hamming‐Code erreicht die Schranke

Wie eben für k Daten‐Bits und n‐Bit Code‐Wörter ausgerechnet:

Benötigtes Verhältnis zwischen k und r=n‐k zum Korrigieren von allen 1‐Bit‐

Fehlern:

r+k+1  ^≤ 2 ^r

Beispiel für unten abgebildeten Hamming‐Code:

1       2        3       4       5       6        7       8       9       10     11     12     13     14     15

Daten‐Bits Check‐Bits Was wenn Daten nur bis 11?

n = 15 k = 11 r = 4

n = 11

k = 7

r = 4

Umgang mit Bit‐Fehler‐Bursts

Also:

Fakten zu allgemeinen Block‐Codes

Code‐Distanz von d_min >= 2t+1 kann bis zu  wie viele c‐Bit‐Fehler korrigieren?

Und wie viele d‐Bit‐Fehler erkennen?

Also: Code‐Distanz von d_minerlaubt  Korrektur von bis zu wie vielen Fehlern?

Und Erkennen von wie vielen Fehlern?

Fakten zu allgemeinen Block‐Codes

Code‐Distanz von d_min >= 2t+1 kann bis zu  wie viele c‐Bit‐Fehler korrigieren?

Und wie viele d‐Bit‐Fehler erkennen?

Also: Code‐Distanz von d_minerlaubt  Korrektur von bis zu wie vielen Fehlern?

Und Erkennen von wie vielen Fehlern?

Coding‐Gain

coding gain

Extended Hamming code

R^G 1       2        3       4       5       6        7       8       9       10     11

Daten‐Bits Check‐Bits

3 = 0 0 1 1 5 = 0 1 0 1 6 = 0 1 1 0 7 = 0 1 1 1 9 = 1 0 0 1 10 = 1 0 1 0 11 = 1 0 1 1

RG – parity bit for the whole  code word;

RG = 0 when number of 1 is even

RG = 1 when number of 1 is odd

Extended Hamming code

0 0 1 1 0 0 1

R^G 1       2        3       4       5       6        7       8       9       10     11

0 0 0 0

3 = 0 0 1 1 5 = 0 1 0 1 6 = 0 1 1 0 7 = 0 1 1 1 9 = 1 0 0 1 10 = 1 0 1 0 11 = 1 0 1 1

Beispiel‐Daten‐Bits:

1 0 0 1 0 0 0

1

RG – parity bit for the whole code word;

RG = 0 when number of 1 is even

RG = 1 when number of 1 is odd