Informationstheorie und Codierung

Transkript

1 Informationstheorie und Codierung 5. Fehlerkorrigierende Codierung Grundlagen Fehlererkennung, Fehlerkorrektur Linearcodes, Hamming-Codes Zyklische Codes und technische Realisierung Burstfehlerkorrektur Faltungscodierung und Viterbi- Algorithmus Galoisfeld, BCH-Codes, RS-Codes Turbocodes 79

2 Aufgabe der Kanalcodierung Störungen (additiv) Informationsquelle Quellencodierer Kanalcodierer Leitungscodierer Kanaldecodierer Leitungsdecodierer Quellendecodierer Informationssenke 80 Kanalcodierung: Hinzufügen redundanter Informationen zur Fehlererkennung und -korrektur

3 Fehlerwahrscheinlichkeit I Übertragungsfehler durch: Dämpfungsverzerrungen Phasenverzerrungen Interferenzen Nebensprechen Rauschen Fremdstörungen Für gaußverteilte Störungen gilt: f(x) f(x) 1 2π 1 F(x) 2π e x² 2 x e 2 z² 2 2 dz 81 Unterscheidung: stationäre Störungen additives weißes gaußverteiltes Rauschen (AWGN: additive white gaussian noise) Beschreibung über Fehlerrate nichtstationäre Störungen z.b. Gewitter σ σ σ = Standardabweichung x

4 Fehlerwahrscheinlichkeit II Annahmen: binäre Übertragung Gleichwahrscheinliche Symbole (p 0 = p 1 = 0,5) Störungen durch AWGN U X - Nutzsignalspannung u N Störsignalspannung (U N = Effektivwert) U 0 - (ursprünglicher) Spannungspegel für Symbol x 0 = 0 U 1 - (ursprünglicher) Spannungspegel für Symbol x 1 = 1 p(u y U 0 ) P(U 0 U 1 ) p(u y U x ) U S = U 0 +U 1 2 (Entscheidungsschwelle) u y = U x + u N (Spannung am Kanalausgang) p(u y U 1 ) U 0 U S U 1 P(U 1 U 0 ) u y 82

5 Fehlerwahrscheinlichkeit III Berechnung über Gaußsche Fehlerfunktion: erf(x) x x 1 π e η 2 dη x 0 2 π e η dη Komplementäre Fehlerfunktion: 2 erfc(x) p(η) Darstellung für μ = 0 erf(x) erfc(x) 1 erf ( x) x 2 π e 2 η dη -x μ x η wird die Bitfehlerwahrscheinlichkeit (bipolares Signal): P e 1 2 erfc PS 2P N 83

6 Bitfehlerwahrscheinlichkeit und Signal-Rausch-Verhältnis Beispiel für binäre bipolare Übertragung Anmerkung: 3dB Gewinn gegenüber unipolarer Übertragung P e SNR 84 SNR db

7 Fehlerbehandlung Fehlerkorrektur Rekonstruktion Forward Error Correction (FEC) Wiederholung Automatic Repeat Request (ARQ) Zufügen von Redundanz zur Fehlererkennung und -lokalisierung Auswahl des Verfahrens nach: vorgegebener Restfehlerwahrscheinlichkeit Aufwand der Realisierung Zeit für die Fehlerkorrektur Rückmeldung an Sender Wiederholung fester Anzahl von Codewörtern oder selektive Wiederholung einzelner, fehlerhafter Codewörter 85

8 Hammingdistanz Definition Hammingdistanz d: Anzahl der Stellen in denen sich zwei Codewörter unterscheiden Hilfsmittel zur Bestimmung: Gittermodell Definition minimale Hammingdistanz d min : kleinste sich zwischen den Kanalcodewörtern ergebende Hammingdistanz Treppenmodell für d = 3 Anzahl (sicher) erkennbarer Fehler = d min 1 Anzahl (sicher) korrigierbarer Fehler = d min korrigierbar Fehler: erkennbar erzeugt anderes Codewort

9 Blockcodes Kennzeichen feste Länge der Kanalcodewörter möglicher Aufbau eines Codewortes: i Informationsbits (i 1, i 2,, i i ) k Kontrollbits (k 1, k 2,, k k ) n Blocklänge (n 1, n 2,, n n ) Hinweis: Angaben ohne Index = Gesamtzahl von Bits Angaben mit Index = Einzelbit mit Index als Position i n k weitere Charakterisierungsmöglichkeiten: Gruppencode systematischer Code Codeworte bilden eine Gruppe bzgl. Mod-2-Addition siehe Linear-Codes Trennung von Informations- und Redundanzzeichen im Codewort Quellencodewort = Kanalcodewort ohne redundante Stellen k 87

10 Hamming-Schranke und -Gewicht 88 Hamming-Schranke (zur Bestimmung von k): 2 k d min 1 2 l=0 i + k l dichtgepackter oder perfekter Code: 2 k = d min 1 2 l=0 i + k l Hamming-Gewicht w: - ist die Anzahl der von 0 verschiedenen Stellen im Codewort Beispiele für d min =3 n k i k -1 k 2 k -k-1

11 Redundanz und Blockfehlerwahrscheinlichkeit Redundanz: R =k relative Redundanz: r = k n Blockfehlerwahrscheinlichkeit: P ν,n = n ν P e ν (1 P e ) n ν P e : Bitfehlerwahrscheinlichkeit ν: Anzahl der Fehler im Block Restfehlerwahrscheinlichkeit: P Rest = Wiederholungscode einfachster fehlerkorrigierender Blockcode n-maliges Wiederholen der Informationen d = d min = n beliebige Reduzierung der Restfehlerwahrscheinlichkeit n ν=µ+1 n ν P e ν (1 P e ) n ν µ: Anzahl der der korrigierbaren Fehler im Block 89

12 Iterierte Codes Summe der Einsen ggf. erweitern auf: gerade Anzahl (gerade Parität bzw. even parity) oder ungerade Anzahl (ungerade Parität bzw. odd parity) Eindimensionale Paritätskontrolle Zweidimensionale Paritätskontrolle (Kreuzsicherungscode) Paritätselemente für die Zeilen Paritätselemente für die Paritätselemente Paritätselemente für die Spalten auch weitere Dimensionen möglich 90

13 Lineare Blockcodes Definition (verkürzte Form): Transformation von Quellencodewörtern in Kanalcodewörter nur mit Operationen, die in der algebraischen Struktur einer Gruppe definiert sind 91 Gruppencode (Kanalcodewörter = Elemente einer Gruppe) Gruppenaxiome: Abgeschlossenheit a i a j = a k ; i, j; ; a i, a j, a k G Assoziatives Gesetz (a i a j ) a k = a i (a j a k ); i, j, k Neutrales Element a i 0 = 0 a i = a i ; i Inverses Element a i a i = 0; i zusätzlich kommutatives Gesetz (abelsche Gruppe) a i a j = a j a i ; i, j stellenweise Modulo-2-Addition

14 Eigenschaften und Codegenerierung I Kanalcodewort Cw i 1 i 2 i 3 i i k 1 k 2 k k 92 n Bildung der Generatormatrix aus i unabhängigen Kanalcodewörtern insgesamt 2 i Kanalcodewörter sichere Erkennung aller Fehler mit w < d min Anzahl der Korrekturbits k ergibt sich durch d min w min der Cw = d min (außer Null-Cw) Syndrom ( Symptome der Fehler ) nur vom Fehler und nicht vom Codewort abhängig Codegenerierung: 1. Bestimmen der Anzahl k für die benötigten Korrekturbits Codewortlänge n = i + k 2. Festlegen/Bestimmen von i linear unabhängigen Codewörtern 3. Erstellen einer (i x n)-generatormatrix mit i linear unabhängigen Codewörtern Generatormatrix G = Cw 1 Cw 2 Cw i

15 Codegenerierung II 4. Bestimmen der übrigen Codewörter Kanalcodewort = Quellencodewort Generatormatrix bzw. Cw = (j 1 j 2 j i ) G (Hinweis: Länge i des Quellencodewortes j entspricht der Anzahl i der Informationsbits im Kanalcodewort) 5. Umstellen der Generatormatrix in eine kanonische Form durch Modulo-2-Additionen und Vertauschen der Zeilen G = x 11 x 12 x 1k x 21 x 22 x 2k x 31 x 32 x 3k x i1 x i2 x ik 93 E i Matrix über die Informationsstellen (Einheitsmatrix der Dimension i) P (i x k)-matrix über die Kontrollstellen

16 Codegenerierung III 6. Erstellen der Prüfmatrix H durch Konkatenation der transponierten Matrix P (über die Kontrollstellen aus G * ) und der Einheitsmatrix in der Dimension k H = (P T E k ) Spalten: i 1 i 2 i i k 1 k 2 k k 94 x 11 x 21 x i H = x 12 x 22 x i x 13 x 23 x i H ermöglicht: x 1k x 2k x ik die Berechnung der Korrekturbits der einzelnen Codewörter die Ermittlung der Syndrome und damit die Fehlererkennung und -korrektur Außerdem gilt: G * H T = G H T = 0

17 Fehlererkennung und -korrektur Syndrome der Fehler e: S = H e T Erstellen der Syndrome der erkennbaren und korrigierbaren Fehler Überprüfung des empfangenen Codewortes auf Fehler: S = H Cw T Fehler bei: Achtung: S 0 S = 0 ein Codewort wurde erkannt aber Fehlermöglichkeit besteht weiterhin 95 Position korrigierbarer Fehler: S entspricht einer einzelnen Spalte von H Position dieser Spalte = Position des Fehlers im Codewort

18 Hammingcode I Eigenschaften: linearer dichtgepackter Blockcode d min = 3 (Einfachfehler korrigierbar) Codewortlänge n=2 k -1 eindeutige Bezeichnung durch H(n,i) spezielle Zuordnung von k zur Absicherung Ermittlung der Kontrollelemente k j : Anordnung in einem Block an den Stellen n x mit x = 2 j-1 und j = 1, 2, alle anderen Stellen sind Informationsbits in aufsteigender Wertigkeit k j zur Absicherung bestimmter Bitstellen über gerade Parität Verschiedene erlaubte Kombinationen i k n Bildung von Bitgruppen der Länge 2 j-1 im Abstand von 2 j-1 - Beginn der ersten Gruppe bei der Position von k j Achtung: Festlegung der Position von k und i im Codewort ist beliebig wählbar

19 Hammingcode II Anordnung der Spalten in H, wenn sich die Korrekturbits im Cw an den Stellen n x mit x = 2 j-1 (j = 1, 2, ) befinden: H = k 1 k 2 i 1 i n-k n 1 n 2 n 3 n n Wert einer Spalte entspricht der Dualdarstellung der Position bzw. von x bei n x direkte Angabe der Fehlerposition in S 97

20 Bsp. eines H(7,4)-Codes k 1 k 2 i 1 k 3 i 2 i 3 i 4 Raster n Cw Cw Cw Cw Cw Cw Cw Cw Cw Cw Cw Cw Cw Cw Cw Cw

21 Bsp. eines H(7,4)-Codes (Fortsetzung) Cw-Struktur: n 1 n 2 n 3 n 4 n 5 n 6 n 7 k 1 k 2 i 1 k 3 i 2 i 3 i 4 Bildungsvorschrift für die Korrekturbits*: k 1 = i 1 i 2 i 4 k 2 = i 1 i 3 i 4 k 3 = i 2 i 3 i 4 Syndrom S = H e T * Cw-Struktur entspricht der Vorschrift zur Bildung der Korrekturbits auf Folie 96) Vorteil dieser Cw-Struktur*: Binärwert von S entspricht dem Dezimalwert der Fehlerposition im Cw 99 Siehe auch bei linearen Blockcodes: S=0 fehlerfrei oder Fehlerfolge entspricht einem Codewort Korrektur durch Negation der erkannten fehlerhaften Elemente 2 k -1 verschiedene Fehlermuster korrigierbar

22 Zyklische Codes I Lineare Blockcodes Eigenschaft: zyklische Verschiebung eines Codewortes (Cw) führt wieder zu einem Codewort Cw-Bildung über Generatorpolynom g(x) oder Generatormatrix Cw mod g(x) = 0 Anzahl k k=grad g(x) Anzahl i i=n grad g(x) einfache schaltungstechnische Realisierung (Schieberegister) Einsatzgebiete: digitale Mobilfunksysteme (z.b. D-Netz), CD, 100

23 Zyklische Codes II Ergänzung zur allgemeinen Charakterisierung von Polynomen: Irreduzibilität (nicht als Produkt von Polynomen darstellbar) Primitives Polynom (Zyklus der Polynomreste erreicht den maximalen Wert für eine Periode) Weitere Eigenschaften zyklischer Codes: theoretisch maximale Größe für eine Periode: p max = 2 Polynomgrad 1 Syndrom innerhalb einer Periode p eindeutig Fehlerkorrektur über Prüfmatrix oder Polynomdivision 101

24 Technische Realisierung I 1. Multiplikation am Sender Division am Empfänger Sender Empfänger y(x) = i(x) g(x) y(x) + e(x) = y (x) y (x) g(x) = y(x) g(x) + e(x) g(x) Rest r(x) = y (x) mod g(x) r(x) = 0 kein (erkennbarer) Fehler r(x) 0 Fehler erkannt Division mit Rest??? Position korrigierbarer Fehler mittels Syndromtabelle 102

25 Technische Realisierung II 2. Division am Sender Division am Empfänger Sender Empfänger r(x) = (x k i(x)) mod g(x) y(x) = x k i(x) + r(x) y(x) mod g(x) = 0 y(x) + e(x) = y (x) y (x) g(x) = y(x) g(x) + e(x) g(x) Rest r(x) = y (x) mod g(x) Rest r(x) = 0 kein (erkennbarer) Fehler Rest r(x) 0 Fehler erkannt Division mit Rest??? 103 Position korrigierbarer Fehler mittels Syndromtabelle nach der Korrektur: Extraktion der Informationsbits i(x)

26 Schaltungstechnische Umsetzung - Addition und Verzögerung - Addition mod 2 (siehe auch XOR) Parallele Verarbeitung Serielle Verarbeitung x 1 x 2 y x 1 & & y x y 2, x 1 & x J-K-Flipflop Verzögerung um ein Raster J K Q Q 0 0 unverändert Zustandswechsel Takt J(T n ) Q(T n+1 ) J Q J Q K Q K Q (Flipflops flankengesteuert)

27 Schaltungstechnische Umsetzung - Multiplikation - i(t j ) T i(z) z -1 i(t j T) Z-Transformation i(t j ) y(t j ) i(z) i(z) z -1 y(z) t j mit j = 0, 1, 2, 3, und t j+1 t j = T y(t j ) = i(t j )+i(t j T ) y(z) = i(z)+i(z) z -1 entspricht auch einer Multiplikation mit 11 y z = i z z (z + 1) z+1 = z 1 +z 0 105

28 Allgemeine Schaltung zur Multiplikation Einlesevorgang beginnt mit dem höchstwertigen Bit i(z) i(z) z -1 i(z) z -2 i(z) z -(k-1) i(z) z -k z -1 z -1 z -1 z -1 g k (=1) g k-1 (=0) g k-2 (=0) g 1 (=0) g 0 (=1) y(z) y(z) = i(z) g k + i(z) z -1 g k-1 + i(z) z -2 g k i(z) z -(k-1) g 1 +i(z) z -k g 0 y(z) = i(z) (g k + z -1 g k-1 + z -2 g k z -(k-1) g 1 +z -k g 0 ) y(z) = i(z) z k (g k z k + g k-1 z k-1 + g k-2 z k z g 1 + g 0 ) y(z) = i(z) g(z) z k y(x) = i(x) g(x) 106

29 Schaltungstechnische Umsetzung - Division I - Addition mod 2 i(z) y(z) z -1 z -1 y(z) y(z) = i(z) + y(z) z -1 y z = i z 1 + z 1 y z = z i z z + 1 g 0 (=1) g 1 (=0) g 2 (=0) g k-1 (=0) g k (=1) z -1 z -1 z -1 z -1 immer y(z) i(z) Einlesevorgang beginnt mit dem höchstwertigen Bit 107

30 Schaltungstechnische Umsetzung - Division II - y(z) = i(z) + y(z) g 0 z -k + y(z) g 1 z -(k-1) + y(z) g 2 z -(k-2) + + y(z) g k-1 z -1 i z y(z) = 1+g k 1 z g 2 z (k 2) + g 1 z (k 1) +g 0 z k Verschiebung um k Stellen (siehe Division Folie 109) 108 z k i z y(z) = z k +g k 1 z k g 2 z 2 + g 1 z+g 0 Achtung!!! gewünschtes Übertragungsformat: y(x) = i(x) + r(x) y(x) = xk i(x) g(x) r(x) im Speicher (Zustand der Verzögerungsglieder nachdem i(x) vollständig eingelesen wurde)

31 Schaltungstechnische Umsetzung - Division III - (Codierer) g 0 (=1) g 1 (=0) g 2 (=0) g k-1 (=0) T T T T y 1 2 Zu codierende Informationsfolge: i 0, i 1, i 2, i n-k 1 2 Übertragung: i 0, i 1, i 2, i n-k, r 1, r 2,, r k Schalterstellung:

32 Schaltungstechnische Umsetzung - Division IV - (Decodierer) y Pufferspeicher T T T T g k-1 (=0) g k-2 (=0) g 1 (=0) g 0 (=1) Logik (Syndromtabelle) Korrektor (Addition mod 2) y 110

33 Spezielle zyklische Codes I zyklischer Hamming-Code: d min = 3 n = 2 k -1 Generatorpolynom ist irreduzibel und primitiv (p = p max = n = 2 k -1) Beispiele: 111

34 Spezielle zyklische Codes II Abramson-Code: Erweiterung des Hammingcodes Erkennung von Einzelfehlern und benachbarten Doppelfehlern d min = 4 g(x) = g p (x) (x+1) (g p primtives Generatorpolynom) Polynomgrad bzw. Korrekturbits k = k p + 1 (k p Polynomgrad von g p ) n = 2 k p 1 = 2 k 1 1 Beispiel: (x 3 +x+1) (x+1) = x 4 +x 3 +x

35 Spezielle zyklische Codes III Fire-Code: Korrektur von Fehlerbündeln der Länge l (Auftreten bei kurzzeitig stark gestörten Übertragungskanälen) g(x) = g p (x) (x k f+1) (k f : Polynomgrad des Faktors) Polynomgrad bzw. Korrekturbits k = k p +k f n = kgv (n p, k f ) o kgv: kleinstes gemeinsames Vielfaches o n p = 2 k p-1; Codewortlänge des primitiven Generatorpolynoms d min = 4 l k p und l < k f 2 +1 Beispiel: g p (x) = x 3 +x 2 +1, n p =7, k f =3 n = 21, k = 6, i = 15, l = 2, g(x) = x 6 +x 5 +x 2 +x 113

36 Maßnahmen beim Auftreten von Burstfehlern Burstfehler oder Bündelfehler Ursache: blockweise Störung Auswirkung: Verfälschung einer ganzen Folge von Bits (Fehlerbündel der Länge l) Gegenmaßnahmen 1. Interleaving (Codespreizung): Verschachtelung ursprünglich in einem Block zusammengefasster (benachbarter) Bits 2. Einsatz spezieller Generatorpolynome (z.b. Fire-Codes) zur Korrektur mehrerer benachbarter Fehler Korrektur durch Trennung in Fehlerort x k (k = 0, 1,, n-1) Fehlermuster e (x) (l = grad(e (x))) Fehler: e(x) = (x k e (x)) mod (x n +1) Verschiebung an die Position des ersten falschen Bits Fehler ist kein Codewort (siehe Abramson-, Fire-Code) 114

37 Algorithmus zur Korrektur von Burstfehlern gesendet: y(x) empfangen: y (x) = y(x)+e(x) Algorithmus: 1. Berechnung des Syndroms S(x) = y (x) mod g(x) 2. Berechnung des wahrscheinlichsten Fehlermusters S i (x) = (x i S(x)) mod g(x) 3. Bestimmung des Fehlers e(x) = (x n-i S i (x)) mod (x n +1) für jedes i>0 bis (grad S i (x))< l 115

38 Einlesen in den Puffer Codespreizung (Interleaving) I Idee: Verringerung des Einflusses eines Fehlerbursts auf ein einzelnes Codewort Verbesserung der Korrekturmöglichkeiten Lösung: Verschachtelung der Codeworte Umsetzung: spaltenweises Einlesen der Codeworte mit Länge n in einen Puffer zeilenweises Auslesen aus dem Puffer und Absenden Anzahl der Spalten entspricht der Interleavingtiefe (Abstand ursprünglich benachbarter Symbole) Auslesen aus dem Puffer 116 (n x m)-blockinterleaver: Cw 1,1 Cw 2,1 Cw 3,1 Cw m, 1 Cw 1,2 Cw 2,2 Cw 3,2 Cw m, 2 Cw 1,3 Cw 2,3 Cw 3,3 Cw m, 3 Cw 1, n Cw 2, n Cw 3, n Cw m, n Hinweis: Realisierung auch als (m x n)-blockinterleaver möglich

39 Codespreizung (Interleaving) II 117 Folge: Schutz der Codeworte gegen ein bis zwei Einzelfehler ausreichend Fehlerburst verfälscht nur einzelne Bits verschiedener Codewörter Interleavingtiefe beeinflusst Verzögerung und Verarbeitungsdauer diskontinuierliche blockweise Verarbeitung Verbesserung durch delayed Interleaving : vertikale Anordnung der Codewörter mit einer zeilenweise Verschiebung um r Raster bzw. Spalten (r=1 entspricht einer diagonalen Anordnung) kontinuierliche Übertragung spaltenweises Auslesen Frame Spreizungs-/Interleavingtiefe: s = n r+1 Bsp. für r=2: Cw 1,1 Cw 2,1 Cw 3,1 Cw 4,1 Cw 5,1 Cw 6,1 Cw 1,2 Cw 2,2 Cw 3,2 Cw 4,2 Cw 1,3 Cw 2,3 Cw 3, n 1 Cw 4, n 1 Cw 1, n Cw 2, n

40 Fehlerkorrektur in mehrstufigen Codes Parameter: Anzahl der Symbolstufen s Anzahl korrigierbarer Stellen im Codewort f Fehlerhöhe t (Betrag des korrigierbaren Abstandes zum ursprünglichen Wert) Blocklänge n Korrekturstellen k Vorgehensweise Sender: Ermittlung der Werte für k Modulo-Operation entsprechend s Vorgehensweise Empfänger: Syndrom S der Empfangsfolge ermitteln (Anzahl der Syndrome s k ) sofern S 0 Vergleich mit Syndromtabelle Korrektur des Fehlers 118

41 Beispiel eines mehrstufigen Codes Anzahl der Syndrome: Parameter: 5 k = 25 s = 5 zulässige Signalwerte -2, -1, 0, 1, 2 f = 1 t = 2 n = 6 k = 2 Fehlerhöhe Raster S 1 S 2 S 1 S 2 S 1 S 2 S 1 S 2 i i i i k k Ermittlung der Korrekturbits k 1 und k 2, sodass gilt: k 1 ergänzt (2i 1 + i 2 + i 3 + 2i 4 ) auf 0 mod 5 k 2 ergänzt (i 1 + i 2 - i 3 - i 4 ) auf 0 mod 5 Hinweis: Beachtung der zulässigen Werte von k (siehe Signal) 119 Syndromberechnung: S 1 = (2i 1 + i 2 + i 3 + 2i 4 + k 1 ) mod 5 S 2 = (i 1 + i 2 i 3 i 4 + k 2 ) mod 5 S = (S 1 S 2 ) Hinweis: S 1 und S 2 können hierbei nur die Restklassenelemente -2, -1, 0, 1 oder 2 sein