DE102018126685B3 - Verarbeitung von Daten - Google Patents

Abstract

Verfahren zum Verarbeiten von Daten mittels eines Fehlercodes, wobei der Fehlercode eine H-Matrix mit n Spalten und m Zeilen aufweist,
- wobei die Spalten der H-Matrix unterschiedlich sind,
- wobei komponentenweise XOR-Summen benachbarter Spalten der H-Matrix zueinander und zu allen Spalten der H-Matrix unterschiedlich sind,
- wobei komponentenweise XOR-Summen nicht benachbarter Spalten der H-Matrix unterschiedlich sind zu allen Spalten der H-Matrix und zu allen komponentenweisen XOR-Summen benachbarter Spalten der H-Matrix,
- bei dem mittels des Fehlercodes
- 1-Bit-Fehler korrigiert werden,
- benachbarte 2-Bit-Fehler korrigiert werden und
- nicht benachbarte 2-Bit-Fehler erkannt werden.

Description

• Die hier erwähnte Verarbeitung von Daten betrifft insbesondere die Fehlererkennung bzw. Fehlerkorrektur von in einem Speicher abgelegten Daten.
• Aus [T. R. N. Rao et al.: Error-Control Coding for Computer Systems, Prentice Hall 1989, Seiten 97 bis 99, ISBN 0-13-283953-9] und aus [de.wikipedia.org/wiki/BCH-Code] sind Grundlagen zu BCH-Codes bekannt.
• Die Aufgabe der Erfindung besteht darin, bestehende Ansätze zur Fehlerkorrektur und/oder Fehlererkennung von in einem Speicher gespeicherten Daten zu verbessern.
• Diese Aufgabe wird gemäß den Merkmalen der unabhängigen Ansprüche gelöst. Bevorzugte Ausführungsformen sind insbesondere den abhängigen Ansprüchen entnehmbar.
• Zur Lösung der Aufgabe wird ein Verfahren vorgeschlagen zum Verarbeiten von Daten mittels eines Fehlercodes, wobei der Fehlercode eine H-Matrix mit n Spalten und m Zeilen aufweist,
• - wobei die Spalten der H-Matrix unterschiedlich sind,
• - wobei komponentenweise XOR-Summen benachbarter Spalten der H-Matrix zueinander und zu allen Spalten der H-Matrix unterschiedlich sind,
• - wobei komponentenweise XOR-Summen nicht benachbarter Spalten der H-Matrix unterschiedlich sind zu allen Spalten der H-Matrix und zu allen komponentenweisen XOR-Summen benachbarter Spalten der H-Matrix,
• - wobei mittels des Fehlercodes
  • - 1-Bit-Fehler korrigiert werden,
  • - benachbarte 2-Bit-Fehler korrigiert werden und
  • - nicht benachbarte 2-Bit-Fehler erkannt werden.
• Hierbei ist es insbesondere von Vorteil, dass eine Verarbeitungsgeschwindigkeit zur Korrektur bzw. Erkennung von Fehlern gegenüber bekannten Lösungen deutlich gesteigert werden kann.
• Es ist ein Weiterbildung, dass eine Anzahl aller Komponenten einer Spalte kleiner als die kleinste ganze Zahl ist, die größer als 2 · log₂ n ist.
• Es ist ein Weiterbildung, dass der Fehlercode ein Fehler-erkennender oder ein Fehler-korrigierender und Fehler-erkennender Code ist.
• Es ist ein Weiterbildung, dass mindestens zwei komponentenweise XOR-Summen nicht benachbarter Spalten der H-Matrix nicht unterschiedlich sind.
• Es ist ein Weiterbildung, dass der Fehlercode eine Länge von n Bits mit m Prüfbits und n - m Nutzdatenbits aufweist.
• Es ist ein Weiterbildung, dass entsprechend der H-Matrix ein Syndromgenerator zur Bildung eines m-komponentigen Fehlersyndroms bestimmt ist.
• Es ist ein Weiterbildung, dass der Syndromgenerator als kombinatorische Schaltung mit n Eingängen und m Ausgängen implementiert ist.
• Es ist ein Weiterbildung, dass ein Korrekturwertbildner vorgesehen ist, der aus dem von dem Syndromgenerator bereitgestellten m-komponentigen Fehlersyndrom Korrekturwerte für fehlerhafte Bitpositionen bildet.
• Es ist ein Weiterbildung, dass n ≥ 2^m/2 ist.
• Es ist ein Weiterbildung, dass die H-Matrix Teil einer erweiterten H-Matrix ist.
• Es ist ein Weiterbildung, dass die erweiterte H-Matrix wie folgt bestimmt ist:
• - die H-Matrix wird gedoppelt in eine ursprüngliche H-Matrix und eine gedoppelte H-Matrix, wobei zwischen der ursprünglichen H-Matrix und der gedoppelten H-Matrix eine Zwischenspalte mit m Nullen eingefügt wird,
• - die ursprüngliche H-Matrix wird um zwei Zeilen mit n Nullen ergänzt,
• - die gedoppelte H-Matrix wird um eine Zeile mit n Einsen und um eine weitere Zeile ergänzt, wobei die weitere Zeile bestimmt ist durch
  • - eine Bitkombination aus n Bits gemäß 1010... 10, falls n geradzahlig ist oder
  • - eine Bitkombination aus n Bits gemäß 1010...1, falls n ungeradzahlig ist,
  • - die Zwischenspalte aus m Nullen um eine Spalte [0,1]^T ergänzt wird.
• Es ist ein Weiterbildung, dass die H-Matrix angepasst wird durch Streichen mindestens einer ersten und/oder mindestens einer letzten Spalte.
• Es ist ein Weiterbildung, dass die H-Matrix modifiziert wird durch eine Linearkombination ihrer Zeilen.
• Es ist ein Weiterbildung, dass die Verarbeitung der Daten ein Schreiben in einen Speicher oder ein Lesen aus einem Speicher umfasst.
• Weiterhin wird eine Vorrichtung vorgeschlagen zum Verarbeiten von Daten mittels eines Fehlercodes, wobei der Fehlercode eine H-Matrix mit n Spalten und m Zeilen aufweist, wobei die Vorrichtung eine Verarbeitungseinheit umfasst, die derart eingerichtet ist, den Fehlercode durch die H-Matrix zu bestimmen,
• - wobei die Spalten der H-Matrix unterschiedlich sind,
• - wobei komponentenweise XOR-Summen benachbarter Spalten der H-Matrix zueinander und zu allen Spalten der H-Matrix unterschiedlich sind,
• - wobei komponentenweise XOR-Summen nicht benachbarter Spalten der H-Matrix unterschiedlich sind zu allen Spalten der H-Matrix und zu allen komponentenweisen XOR-Summen benachbarter Spalten der H-Matrix.
• Die hier genannte Verarbeitungseinheit kann insbesondere als eine Prozessoreinheit und/oder eine zumindest teilweise festverdrahtete oder logische Schaltungsanordnung ausgeführt sein, die beispielsweise derart eingerichtet ist, dass das Verfahren wie hierin beschrieben durchführbar ist. Besagte Verarbeitungseinheit kann jede Art von Prozessor oder Rechner oder Computer mit entsprechend notwendiger Peripherie (Speicher, Ein-/Ausgabe-Schnittstellen, Ein-Ausgabe-Geräte, etc.) sein oder umfassen.
• Es ist ein Weiterbildung, dass die Verarbeitungseinheit einen Syndromgenerator umfasst, der Syndrome basierend auf der H-Matrix ausgibt.
• Es ist ein Weiterbildung, dass die Vorrichtung einen Speicher umfasst oder mit einem Speicher koppelbar ist, wobei das Verarbeiten der Daten ein Schreiben in den Speicher oder ein Lesen aus dem Speicher umfasst.
• Es ist ein Weiterbildung, dass eine Anzahl aller Komponenten einer Spalte kleiner als die kleinste ganze Zahl ist, die größer als 2 · log₂ n ist.
• Es ist ein Weiterbildung, dass mindestens zwei komponentenweise XOR-Summen nicht benachbarter Spalten der H-Matrix nicht unterschiedlich sind.
• Die vorstehenden Erläuterungen betreffend das Verfahren gelten für die Vorrichtung entsprechend. Die Vorrichtung kann in einer Komponente oder verteilt in mehreren Komponenten ausgeführt sein.
• Auch wird die oben genannte Aufgabe gelöst mittels eines Systems umfassend mindestens eine der hier beschriebenen Vorrichtungen.
• Weiterhin wird ein Computerprogrammprodukt vorgeschlagen, das direkt in einen Speicher eines digitalen Computers ladbar ist, umfassend Programmcodeteile, die dazu geeignet sind, Schritte des hier beschriebenen Verfahrens durchzuführen.
• Auch wird ein computerlesbares Speichermedium angegeben umfassend von einem Computer ausführbare Anweisungen, die dazu geeignet sind, dass der Computer Schritte des hier beschriebenen Verfahrens durchführt.
• Die oben beschriebenen Eigenschaften, Merkmale und Vorteile dieser Erfindung sowie die Art und Weise, wie diese erreicht werden, werden nachfolgend beschrieben im Zusammenhang mit einer schematischen Beschreibung von Ausführungsbeispielen, die im Zusammenhang mit der Zeichnung näher erläutert werden.
• Es zeigt:
• 1 eine beispielhafte Anordnung zur Veranschaulichung der Verarbeitung von Daten mittels Fehlercodes.
• Beim Speichern von Daten in Speicherzellen eines Speichers sowie beim Lesen aus dem Speicher können Fehler auftreten. Auch können die in dem Speicher gespeicherten Daten verfälscht werden. Beispielsweise kann der Speicher einer Strahlung (z.B. aus dem Weltraum oder einer terrestrischen Strahlung) ausgesetzt sein, die den Inhalt von Speicherzellen, insbesondere den Inhalt benachbarter Speicherzellen, verfälscht.
• So kann als Fehler ein 1-Bit-Fehler auftreten, der ein Bit in einer Speicherzelle verfälscht. Entsprechend verfälscht ein 2-Bit-Fehler zwei Speicherzellen.
• Speicherzellenfehler in zwei benachbarten Speicherzellen können dabei häufiger auftreten als Speicherzellenfehler in zwei Speicherzellen, die nicht benachbart sind.
• Um eine möglichst zuverlässige Speicherung von Daten in einem Speicher bei zugleich geringem Aufwand zu erreichen, ist es beispielsweise ein Ziel,
• - Speicherzellenfehler in einer Speicherzelle zu korrigieren,
• - Speicherzellenfehler in zwei benachbarten Speicherzellen zu korrigieren und
• - Speicherzellenfehler in zwei nicht benachbarten Speicherzellen sicher zu erkennen
und hierfür möglichst wenige Speicherzellen mit Prüfbits zu benötigen.
• Werden Daten aus dem Speicher gelesen und ist ein gelesenes Datum aus einer Speicherzelle fehlerhaft, so handelt es sich um einen 1-Bit-Fehler. Liegen zwei Fehler in zwei benachbarten Speicherzellen vor, so handelt es sich um einen benachbarten 2-Bit-Fehler. Liegen zwei Fehler in zwei nicht benachbarten Speicherzellen vor, entspricht dies einem nicht benachbarten 2-Bit-Fehler.
• Unter Verwendung eines Fehlercodes wird eine Lösung geschaffen, anhand derer 1-Bit-Fehler und benachbarte 2-Bit-Fehler korrigiert werden und nicht benachbarte 2-Bit-Fehler erkannt werden. Es ist insbesondere eine Option, dass korrigierbare Fehler (vor der Korrektur) erkannt werden.
• Es kann von Vorteil sein, dass selten auftretende nicht benachbarte 2-Bit-Fehler erkannt (und nicht korrigiert), jedoch öfter auftretende benachbarte 2-Bit-Fehler erkannt und korrigiert werden, da in so einem Szenario weniger Prüfbits benötigt werden als für eine Korrektur aller (auch nicht benachbarter) 2-Bit-Fehler.
• Als Fehlercode kann ein Fehler-korrigierender und/oder Fehler-erkennender Code bezeichnet werden.
• Die zu speichernden Daten können als Codewörter des Fehlercodes codiert in dem Speicher gespeichert werden. Beispielsweise können die zu speichernden Daten Datenbits umfassen, die durch Prüfbits ergänzt werden, so dass die Datenbits und die Prüfbits ein Codewort des Fehlercodes bilden bzw. Teil eines solche Codeworts sind.
• Im Folgenden werden beispielhaft lineare Codes als Fehlercodes betrachtet. Ein Fehlercode kann als linearer Code beispielsweise durch eine H-Matrix beschrieben werden, wobei für einen Fehlercode der Länge n mit m Prüfbits als H-Matrix eine (m, n)-Matrix verwendet werden kann.
• Die H-Matrix bestimmt beispielsweise einen Syndromgenerator, der Fehlersyndrome für auftretende Fehler bestimmt.
• Aufgrund der Fehlersyndrome können die entsprechenden Fehler beispielsweise unter Verwendung einer kombinatorischen Schaltung korrigiert und/oder erkannt werden. Beispielsweise können den Fehlersyndromen zu korrigierende Bitpositionen anhand einer kombinatorischen Schaltung zugeordnet sein.
• Mittels der H-Matrix kann ein Verfahren zur Korrektur von 1-Bit-Fehlern und von benachbarten 2-Bit-Fehlern und zum Erkennen nicht benachbarter 2-Bit-Fehler bestimmt sein.
• Weist die H-Matrix m Zeilen und n Spalten auf, ist hierdurch ein Fehlercode mit m Prüfbits bestimmt. Die Länge des Fehlercodes ist gleich der Anzahl n der Spalten der H-Matrix.
• Die H-Matrix des Fehlercodes ist eine (m, n)-Matrix und kann als $$H=\left(h^1,h^2,\dots ,h^n\right)=\left(\begin{array}{cccc}{h}_1^1& h_1^2& \dots & h_1^n\\ ⋮& ⋮& \dots & ⋮\\ h_m^1& h_m^2& \dots & h_m^n\end{array}\right)$$

  

  beschrieben werden, wobei h¹,h²,...,hⁿ die n Spalten der H-Matrix bezeichnen, die jeweils m binäre Komponenten aufweisen.
• Ist v = v₁, ... , v_n ein Codevektor (auch bezeichnet als Codewort) des betrachteten Fehlercodes, gilt $$H\cdot v=0.$$

  
• Ist v' ein Vektor mit $$v\text{'}=v+e=v_1+e_1,v_2+e_2,\dots ,v_n+e_n$$

  

  dann gilt $$H\cdot v\text{'}=H\cdot \left(v+e\right)=H\cdot e=s.$$

  
• Hierbei bezeichnet der Vektor e = e₁,..., e_n einen Fehlervektor, der eine eventuelle Abweichung des fehlerhaften Vektors v' von dem korrekten Vektor v beschreibt. Bei dem Vektor v' handelt es sich somit um den gestörten oder fehlerhaften (Code) Vektor.
• Der Vektor v' unterscheidet sich von dem Vektor v in den Komponenten, in denen die entsprechenden Komponenten des Fehlervektors e gleich 1 sind, und der Vektor v' unterscheidet sich nicht von dem Vektor v in den Komponenten, in denen die Komponenten des Fehlervektors e gleich 0 sind.
• Ist beispielsweise für i ∈ {1, ... , n} die i-te Komponente e_i des Fehlervektors e gleich 1, so ist das i-te Bit v_i des Vektors v durch einen Fehler in das i-te Bit $$v_i^{\text{'}}=v_i+1$$

  

  des Vektors v' gestört worden. Ist beispielsweise die j-te Komponente e_j des Fehlervektors e gleich 0, so ist das j-te Bit des Vektors v nicht durch einen Fehler des Vektors v' gestört worden und es gilt: v'_j=v_j.
• Ist genau eine Komponente des Fehlervektors e gleich 1, dann liegt ein 1-Bit-Fehler vor. Sind genau zwei Komponenten des Fehlervektors e gleich 1, dann liegt ein 2-Bit-Fehler vor. Sind genau zwei Komponenten des Fehlervektors, die gleich 1 sind, benachbart, dann liegt ein benachbarter 2-Bit-Fehler vor. Sind genau zwei Komponenten des Fehlervektors gleich 1, die nicht benachbart sind, dann liegt ein nicht benachbarter 2-Bit-Fehler vor.
• Die Operation „+“ bezeichnet die Addition modulo 2 oder die logische XOR-Operation (XOR steht hierbei für Exklusiv-Oder).
• Ist ein Vektor rechts von einer Matrix angeordnet, so ist er als Spaltenvektor zu interpretieren. Soll hervorgehoben werden, dass der Vektor v als Spaltenvektor dargestellt ist, so kann dies mit v^T ausgedrückt werden.
• Durch die Gleichung (3) ist ein Fehlersyndrom s definiert. Das Fehlersyndrom s ist in der Gleichung (3) als Spaltenvektor s^T = [s₁,... ,s_m]^T mit m Komponenten s₁, ... , s_m dargestellt.
• Entsprechend den Elementen der H-Matrix sind die Komponenten s₁,..., s_n des Fehlersyndroms s bestimmt durch $$\begin{array}{cc}{s}_1=h_1^1\cdot v_1^{\text{'}}+h_1^2\cdot v_2^{\text{'}}+\dots +h_1^n\cdot v_n^{\text{'}},& \left(4\right)\\ s_2=h_2^1\cdot v_1^{\text{'}}+h_2^2\cdot v_2^{\text{'}}+\dots +h_2^n\cdot v_n^{\text{'}},& \left(5\right)\\ ⋮& \\ s_m=h_m^1\cdot v_1^{\text{'}}+h_m^2\cdot v_2^{\text{'}}+\dots +h_m^n\cdot v_n^{\text{'}},& \left(6\right)\end{array}$$

  
• Eine Implementierung der Gleichungen (4) bis (6) zur Bestimmung der Komponenten s_n bis s_m des Fehlersyndroms s kann auch als Syndromgenerator bezeichnet werden. Eine Implementierung dieser Gleichungen kann beispielsweise mittels eines üblichen Synthesetools erreicht werden.
• Werden alle 1-Bit-Fehler unter Verwendung eines Fehlersyndroms eines Fehlercodes korrigiert, sind alle 1-Bit-Fehler anhand des Fehlersyndroms unterscheidbar und die Fehlersyndrome der verschiedenen 1-Bit-Fehler sind paarweise unterschiedlich. Die verschiedenen Fehlersyndrome der n möglichen 1-Bit-Fehler sind dann gleich den n Spalten h₁ bis h_n der H-Matrix gemäß der Gleichung (1). Dabei ist die H-Matrix so bestimmt, dass alle n Spalten paarweise verschieden sind.
• Werden alle 1-Bit-Fehler und alle, auch nicht benachbarte 2-Bit-Fehler, unter Verwendung eines Fehlersyndroms eines Fehlercodes korrigiert, dann sind alle Fehlersyndrome der n verschiedenen 1-Bit-Fehler und alle Fehlersyndrome der $\left(\begin{array}{c}n\\ 2\end{array}\right)$

  

  verschiedenen 2-Bit-Fehler paarweise unterschiedlich. Die verschiedenen Fehlersyndrome der n möglichen 1-Bit-Fehler sind dann gleich den n Spalten h₁ bis h_n der H-Matrix gemäß der Gleichung (1) und die Fehlersyndrome der $\left(\begin{array}{c}n\\ 2\end{array}\right)$

  

  verschiedenen 2-Bit-Fehler sind dann gleich den komponentenweisen XOR-Summen der $\left(\begin{array}{c}n\\ 2\end{array}\right)$

  

  verschiedenen Kombinationen von 2 Spalten dieser H-Matrix.
• Ein bekannter 2-Bit-Fehler korrigierender Code ist ein 2-Bit-Fehler korrigierender BCH-Code, der es erlaubt, alle 1-Bit Fehler und alle 2-Bit-Fehler zu korrigieren. Ein 2-Bit-Fehler korrigierender BCH-Code zur Korrektur beliebiger 1-Bit-Fehler und beliebiger 2-Bit-Fehler ist beispielsweise in [Rao, T.; Fujiwara, E.: „Error Control codes for Computer Systems“, Prentice Hall 1989, Seiten 97 bis 99] beschrieben.
• Für einen 2-Bit-Fehler korrigierenden BCH-Code müssen alle Spalten der entsprechenden H-Matrix und alle komponentenweisen XOR-Summen aller Paare von Spalten der H-Matrix paarweise unterschiedlich sein. Die Anzahl m der Komponenten des Fehlersyndroms, die gleich der Anzahl der Prüfbits des Fehlercodes ist, muss dann mindestens so groß sein, dass gilt $$2^m\ge n+\left(\begin{array}{c}n\\ 2\end{array}\right).$$

  
• Das ist erforderlich, damit alle zu korrigierenden Fehler verschiedenen Fehlersyndromen entsprechen und anhand ihrer Fehlersyndrome unterschieden werden können. Die Anzahl m der Komponenten des Fehlersyndroms ist hier gleich der Anzahl der Prüfbits des Fehlercodes.
• Für einen bekannten 2-Bit-Fehler korrigierenden BCH-Code der Länge n ist die Anzahl m der mindestens erforderlichen Prüfbits gleich der kleinsten positiven ganzen Zahl, die größer als 2 · log₂ n ist, es gilt in diesem Fall also $$m>2\cdot lo{g}_{2}n.$$

  
• Sollen nur die 1-Bit-Fehler und die benachbarten 2-Bit-Fehler unter Verwendung eines Fehlercodes korrigiert werden, dann kann es nachteilig sein, wenn alle n + $\left(\begin{array}{c}n\\ 2\end{array}\right)$

  

  Fehlersyndrome für 1-Bit-Fehler und für beliebige 2-Bit-Fehler paarweise unterschiedlich sind, wie dies für den 2-Bit-Fehler korrigierenden BCH-Code der Fall ist, weil hierfür mehr Prüfbits erforderlich sein könnten als zur Korrektur der 1-Bit-Fehler, zur Korrektur benachbarter 2-Bit-Fehler und zum Erkennen nicht benachbarter 2-Bit-Fehler.
• Durch die Einschränkung, dass nicht benachbarte 2-Bit-Fehler lediglich erkannt werden sollen aber nicht korrigiert werden müssen, kann die Anzahl der benötigten Prüfbits reduziert werden.
• Dies ist insbesondere deshalb von Vorteil, weil für die Prüfbits auch Speicherzellen benötigt werden.
• Insbesondere wird vorgeschlagen, dass die n + n - 1 Fehlersyndrome für die n möglichen 1-Bit-Fehler und für n - 1 benachbarte 2-Bit-Fehler paarweise unterschiedlich sind und dass die Fehlersyndrome aller nicht benachbarter 2-Bit-Fehler nur unterschiedlich von den Fehlersyndromen der 1-Bit-Fehler und von den Fehlersyndromen der benachbarten 2-Bit-Fehler sind.
• Es gibt also eine erste Gruppe von Fehlersyndromen für 1-Bit-Fehler und eine zweite Gruppe von Fehlersyndromen für benachbarte 2-Bit-Fehler. Die Fehlersyndrome der ersten Gruppe müssen sich voneinander unterscheiden und die Fehlersyndrome der zweiten Gruppe müssen sich voneinander und von den Fehlersyndromen der ersten Gruppe unterscheiden. Weiterhin gibt es ein dritte Gruppe von Fehlersyndromen für nicht benachbarte 2-Bit-Fehler; die in der dritten Gruppe enthaltenen Fehlersyndrome müssen lediglich von den Fehlersyndromen der ersten Gruppe und der zweiten Gruppe unterschiedlich sein, allerdings müssen die Fehlersyndrome der dritten Gruppe nicht untereinander unterschiedlich sein.
• Fehlersyndrome von Paaren unterschiedlicher nicht benachbarter 2-Bit-Fehler können in diesem Beispiel untereinander gleich sein. Sind Fehlersyndrome von verschiedenen Paaren nicht benachbarter 2-Bit-Fehler untereinander gleich, so kann sich dadurch die Anzahl der zu unterscheidenden Fehlersyndrome so verkleinern, dass weniger Prüfbits als für einen 2-Bit-Fehler korrigierenden BCH-Code erforderlich sind.
• Somit ist es insbesondere ein Vorteil des hier beschriebenen Ansatzes, eine Korrektur von 1-Bit-Fehlern und von benachbarten 2-Bit-Fehlern zu ermöglichen und Fehler in nicht benachbarten 2-Bit-Fehlern zu erkennen, wobei hierfür möglichst wenige Prüfbits eingesetzt werden sollen.
• Die Anzahl der Prüfbits für eine H-Matrix ist dann geringer als die Anzahl der Prüfbits für eine H-Matrix eines 2-Bit-Fehler korrigierenden BCH-Codes mit der gleichen Anzahl von Spalten. Entsprechend weist ein daraus resultierender Syndromgenerator weniger Ausgänge auf als ein entsprechender Syndromgenerator für den 2-Bit-Fehler korrigierenden BCH-Code.
• Es wird insbesondere ein Verfahren vorgeschlagen zur Korrektur von 1-Bit-Fehlern und von benachbarten 2-Bit-Fehlern und zum Erkennen von nicht benachbarten 2-Bit-Fehlern insbesondere beim Lesen von in Speicherzellen gespeicherten Bits. Das Verfahren verwendet einen Fehlercode, der durch eine H-Matrix bestimmt ist. Diese H-Matrix wird nachfolgend beispielhaft beschrieben.
• Hierbei sei erwähnt, dass die H-Matrix als beispielhafte Notation zur Beschreibung eines beliebigen linearen Fehlercodes herangezogen wird. Dabei dient die H-Matrix zur Veranschaulichung der Eigenschaften, die der Fehlercode aufweisen muss, um für die vorstehend genannte Korrektur und Erkennung genutzt werden zu können. Theoretisch sind andere Beschreibungsformen anstelle der H-Matrix möglich. Mit anderen Worten: Es kann jeder lineare Fehlercode, der die hier geforderten Eigenschaften aufweist, nämlich 1-Bit-Fehler und benachbarte 2-Bit-Fehler korrigieren und nicht benachbarte 2-Bit-Fehler erkennen zu können, auf eine H-Matrix mit den hier beschriebenen Eigenschaften abgebildet werden. Damit ist die H-Matrix eine eindeutige Referenz für die hierin vorgeschlagenen Fehlercodes.
• Die H-Matrix kann mehrere H-Matrizen aufweisen. Beispielsweise kann eine H-Matrix derart bestimmt sein, dass für bestimmte Anzahlen von Zeilen und Spalten spezielle H-Matrizen bereitgestellt werden und dass für weitere Anzahlen von Zeilen und Spalten aus den bereitgestellten H-Matrizen weitere H-Matrizen abgeleitet werden. Weitere H-Matrizen können auch durch Streichen von Spalten, beispielsweise von letzten oder ersten Spalten, aus bereits vorhanden H-Matrizen abgeleitet werden.
• Nachfolgend werden beispielhaft H-Matrizen angegeben für
• - m = 6 und n = 11,
• - m = 7 und n = 14 und
• - m = 8 und n = 26,
wobei n die Anzahl der Spalten und m die Anzahl der Zeilen der H-Matrix angibt.
• Beispiel einer H-Matrix H^6,11
• Ist m = 6 und n = 11 dann zeigt die Gleichung (7) ein Beispiel einer speziellen H-Matrix H^6,11 $$H^{\mathrm{6,11}}=\left(\begin{array}{ccccccccccc}1& 0& 0& 0& 0& 0& 1& 1& 1& 1& 0\\ 0& 1& 0& 0& 0& 0& 1& 1& 1& 0& 1\\ 0& 0& 1& 0& 0& 0& 1& 1& 0& 1& 1\\ 0& 0& 0& 1& 0& 0& 1& 0& 1& 1& 1\\ 0& 0& 0& 0& 1& 0& 0& 1& 1& 1& 1\\ 0& 0& 0& 0& 0& 1& 1& 0& 1& 0& 1\end{array}\right)=\left(h_1,h_2,\dots ,h_{11}\right)$$

  

  eines Fehlercodes C^6,11 mit 6 Zeilen, d.h. m = 6 Prüfbits, und n = 11 Spalten (und damit n - m = 5 Datenbits). Die Länge des Fehlercodes C^6,11 ist n = 11.
• Die kleinste ganze Zahl, die größer ist als $$lo{g}_{2}n=lo{g}_{2}11$$

  

  ist 4, da $$2^3=8<11<2^4=16$$

  

  gilt. Die Anzahl der Zeilen m = 6 der H-Matrix H^6,11 ist kleiner als die Anzahl 2 · 4 = 8 der Zeilen eines 2-Bit-Fehler korrigierenden BCH-Codes der Länge 11.
• Durch Nachrechnen lässt sich überprüfen, dass die H-Matrix H^6,11 so bestimmt ist, dass alle 11 Spalten h₁ bis h₁₁ und alle komponentenweisen XOR-Summen der n - 1 = 10 Paare benachbarter Spalten $$\begin{array}{c}{h}_1+h_2={\left[110000\right]}^T,\\ h_2+h_3={\left[011000\right]}^T,\\ ⋮\\ h_{10}+h_{11}={\left[110001\right]}^T\end{array}$$

  

  paarweise unterschiedlich sind. Sie sind auch unterschiedlich von den komponentenweise XOR-Summen der $\left(\begin{array}{c}11\\ 2\end{array}\right)-10=45$

  

  Paare nicht benachbarter Spalten $$\begin{array}{c}{h}_1+h_3={\left[101000\right]}^T,\\ h_1+h_4={\left[100010\right]}^T,\\ ⋮\\ h_9+h_{11}={\left[101000\right]}^T.\end{array}$$

  
• [110000]^T bezeichnet dabei einen Spaltenvektor mit den Komponenten 1,1,0,0,0, 0. Für die anderen Spaltenvektoren gilt dies entsprechend.
• XOR-Summen zweier verschiedener Paare nicht benachbarter Spalten können dabei gleich sein. So gilt beispielsweise $$h_1+h_3=h_9+h_{11}={\left[101000\right]}^T.$$

  
• Die 11 Spalten h₁ bis h₁₁ sind gleich den Syndromen entsprechender 1-Bit-Fehler und die 10 XOR-Summen der benachbarten Spalten $$\begin{array}{c}{h}_1+h_2,\\ h_2+h_3,\\ h_3+h_4,\\ h_4+h_5,\\ h_5+h_6,\\ h_6+h_7,\\ h_7+h_8,\\ h_8+h_9,\\ h_9+h_{10},\\ h_{10}+h_{11}\end{array}$$

  

  sind gleich den Syndromen der 10 möglichen benachbarten 2-Bit-Fehler.
• Die H-Matrix H^6,11 ist dabei so bestimmt, dass die 10 Fehlersyndrome der 10 benachbarten 2-Bit-Fehler paarweise unterschiedlich sind, dass sie unterschiedlich zu allen 11 Fehlersyndromen der 1-Bit-Fehler und unterschiedlich zu allen $\left(\begin{array}{c}11\\ 2\end{array}\right)-10=45$

  

  nicht benachbarten 2-Bit-Fehlern sind.
• Jeder 1-Bit-Fehler und jeder benachbarte 2-Bit-Fehler kann anhand seines Fehlersyndroms dann eindeutig identifiziert und korrigiert werden.
• Die Fehlersyndrome nicht benachbarter 2-Bit-Fehler unterschieden sich von den Fehlersyndromen benachbarter 2-Bit-Fehler und von den Fehlersyndromen der 1-Bit-Fehler.
• Da Fehlersyndrome verschiedener nicht benachbarter 2-Bit-Fehler gleich sein können, können nicht benachbarte 2-Bit-Fehler nicht eindeutig korrigiert werden. Dies ist im vorliegenden Beispiel auch nicht erforderlich und führt vorteilhaft dazu, dass weniger Prüfbits benötigt werden als bei einem 2-Bit-Fehler korrigierenden BCH-Code.
• Der Fehlercode C^6,11 ist damit ein Code der Länge 11, der 6 Prüfbits und 5 Datenbits aufweist, der 1-Bit-Fehler und benachbarte 2-Bit-Fehler korrigieren sowie nicht benachbarte 2-Bit-Fehler erkennen kann.
• Im Unterschied dazu ist ein bekannter 2-Bit-Fehler korrigierender BCH-Code mit 6 Prüfbits ein Code mit der maximalen Länge 7 und weist nur 1 Datenbit auf. Somit ist bei gleicher Anzahl von Prüfbits die Länge des BCH-Codes geringer. Mit einer Länge von 11 erfordert der 2-Bit-Fehler korrigierende BCH-Code eine Anzahl von 8 Prüfbits. Damit verbleiben nur 3 Datenbits.
• Die H-Matrix H^6,11 kann genutzt werden, um einen Syndromgenerator zu bestimmen.
• Als ein fehlerfreies Codewort (Codevektor) wird $$v=\left[v_1,\dots ,v_{11}\right],$$

  

  und als fehlerhaftes, gestörtes Codewort (fehlerhafter Codevektor) wird $$v\text{'}=\left[v_1^{\text{'}},\dots ,v_{11}^{\text{'}}\right]$$

  

  mit $$v\text{'}=v+e=v_1+e_1,\dots ,v_{11}+e_{11}$$

  

  bezeichnet. Dabei ist e = e₁, ... , e₁₁, der Fehlervektor. Mit + ist die Addition modulo 2 oder die logische XOR-Operation bezeichnet.
• Ist eine Komponente des Fehlervektors e gleich 1, dann ist die entsprechende Komponente des Vektors v' fehlerhaft; ist eine Komponente des Fehlervektors e gleich 0, dann ist die entsprechende Komponente des Vektors v' nicht fehlerhaft.
• Das Fehlersyndrom s ist bestimmt gemäß $$s=\left[s_1,\dots ,s_{11}\right]=H^{\mathrm{6,11}}\cdot v\text{'}.$$

  
• Dies ergibt sich durch Multiplikation der H-Matrix H^6,11 mit dem Spaltenvektor v'. Der Vektor v' in der Gleichung (8) ist ein Spaltenvektor.
• Die Komponenten des Fehlersyndroms s können wie folgt angegeben werden $$s_1=v_1^{\text{'}}+v_7^{\text{'}}+v_8^{\text{'}}+v_9^{\text{'}}+v_{10}^{\text{'}},$$

  

  $$s_2=v_2^{\text{'}}+v_7^{\text{'}}+v_8^{\text{'}}+v_9^{\text{'}}+v_{11}^{\text{'}},$$

  

  $$s_3=v_3^{\text{'}}+v_7^{\text{'}}+v_8^{\text{'}}+v_{10}^{\text{'}}+v_{11}^{\text{'}},$$

  

  $$s_4=v_4^{\text{'}}+v_7^{\text{'}}+v_9^{\text{'}}+v_{10}^{\text{'}}+v_{11}^{\text{'}},$$

  

  $$s_5=v_5^{\text{'}}+v_8^{\text{'}}+v_9^{\text{'}}+v_{10}^{\text{'}}+v_{11}^{\text{'}},$$

  

  $$s_6=v_6^{\text{'}}+v_7^{\text{'}}+v_9^{\text{'}}+v_{11}^{\text{'}}.$$

  
• Die Fehlererkennung und Fehlerkorrektur unter Verwendung eines Fehlersyndroms ist dem Fachmann bekannt. So kann die Fehlerkorrektur beispielsweise unter Verwendung einer Syndromtabelle (auch bezeichnet als „Syndrom Decoding Table“) erfolgen. Die Syndromtabelle ist eine Tabelle, die eine umkehrbar eindeutige Zuordnung der Fehlervektoren der zu korrigierenden Fehler und der ihnen umkehrbar eindeutig entsprechenden Fehlersyndrome beschreibt. Die durch die Syndromtabelle beschriebene Zuordnung zwischen Fehlersyndromen und Fehlervektoren kann beispielsweise durch eine kombinatorische Schaltung realisiert sein. Die Komponenten des Fehlersyndromes liegen dann an den Eingängen der kombinatorischen Schaltung an, die an ihren Ausgängen die Komponenten des entsprechenden Fehlervektors ausgibt. Die von der kombinatorischen Schaltung bereitgestellten Komponenten e₁ bis e_n des Fehlervektors e können beispielsweise mit den entsprechenden Komponenten v'₁ bis v'_n des zu korrigierenden eventuell fehlerhaften Codevektors v' XOR-verknüpft werden, um die korrigierten Werte zu bilden.
• Ein Beispiel einer Syndromtabelle ist beispielsweise in [Wickert, S.B.: „Error Control for Digital Communication and Storage“, Prentice Hall 1995, Seite 89] dargestellt.
• Beispiel einer H-Matrix H^7,14
• Für m = 7 und n = 14 zeigt die Gleichung (15) ein weiteres Beispiel für eine H-Matrix H^7,14 $$H^{\mathrm{7,14}}=\left(\begin{array}{llllllllllllll}1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill \\ 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill \\ 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill \\ 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill \end{array}\right)=\left(h_1,h_2,\dots ,h_{14}\right)$$

  

  eines Fehlercodes C^7,14 mit 7 Zeilen, d.h. m = 7 Prüfbits, und n = 14 Spalten (und damit n - m = 7 Datenbits). Die Länge des Fehlercodes C^7,14 ist n = 14.
• Die H-Matrix H^7,14 ist beispielsweise so bestimmt, dass alle 14 Spalten h₁ bis h₁₄ und alle komponentenweisen XOR-Summen von den 13 Paaren benachbarten Spalten $$\begin{array}{c}{h}_1+h_2,\\ ⋮\\ h_{13}+h_{14}\end{array}$$

  

  paarweise unterschiedlich sind. Sie sind so bestimmt, dass sie auch unterschiedlich von den komponentenweise XOR-Summen der $\left({}_2^{14}-13=78\right)$

  

  Paare der nicht benachbarten Spalten $$\begin{array}{c}{h}_1+h_3,\\ h_1+h_4,\\ ⋮\\ h_{12}+h_{14}\end{array}$$

  

  sind. XOR-Summen zweier verschiedener Paare nicht benachbarter Spalten können dabei gleich sein.
• Die 14 Spalten h₁ bis h₁₄ sind gleich den Syndromen entsprechender 1-Bit-Fehler und die 13 XOR-Summen der benachbarten Spalten $$\begin{array}{l}{h}_1+h_2,\hfill \\ h_2+h_3,\hfill \\ h_3+h_4,\hfill \\ h_4+h_5,\hfill \\ h_5+h_6,\hfill \\ h_6+h_7,\hfill \\ h_7+h_8,\hfill \\ h_8+h_9,\hfill \\ h_9+h_{10},\hfill \\ h_{10}+h_{11},\hfill \\ h_{11}+h_{12},\hfill \\ h_{12}+h_{13},\hfill \\ h_{13}+h_{14},\hfill \end{array}$$

  

  sind gleich den Syndromen der 13 möglichen benachbarten 2-Bit-Fehler. Die H-Matrix H^7,14 ist so bestimmt, dass Fehlersyndrome paarweise unterschiedlich sind. Jeder 1-Bit-Fehler und jeder benachbarte 2-Bit-Fehler kann anhand seines Fehlersyndroms eindeutig identifiziert und korrigiert werden.
• Die Fehlersyndrome nicht benachbarter 2-Bit-Fehler unterscheiden sich von den Fehlersyndromen benachbarter 2-Bit-Fehler und von den Fehlersyndromen der 1-Bit-Fehler.
• Da Fehlersyndrome verschiedener nicht benachbarter 2-Bit-Fehler gleich sein können, können nicht benachbarte 2-Bit Fehler nicht eindeutig korrigiert werden.
• So gilt beispielsweise: $$\begin{array}{l}{h}_8+h_{12}={\left[1111101\right]}^T+{\left[1011111\right]}^T={\left[0100010\right]}^T=\\ h_2+h_6={\left[0100000\right]}^T+{\left[0000010\right]}^T.\end{array}$$

  
• Damit ist ein 2-Bit-Fehler in dem 8-ten und dem 12-ten Bit nicht unterscheidbar von einem 2-Bit-Fehler in dem 2-ten und dem 6-ten Bit.
• Der Fehlercode C^7,14 ist damit ein Code der Länge 14, der 7 Prüfbits und 7 Datenbits aufweist, der 1-Bit-Fehler und benachbarte 2-Bit-Fehler korrigieren und nicht benachbarte 2-Bit-Fehler erkennen kann.
• Im Unterschied dazu hat ein bekannter 2-Bit-Fehler korrigierender BCH-Code, wenn er eine Länge von 14 aufweist, 8 Prüfbits und nur 6 Datenbits. Ein gleich langer 2-Bit-Fehler korrigierender BCH-Code benötigt also mehr Prüfbits.
• Die kleinste ganze Zahl, die größer ist als $$lo{g}_{2}n=lo{g}_{2}14$$

  

  ist wieder 4 (siehe obige Ausführungen). Die Anzahl der m = 7 Zeilen der H-Matrix H^7,14 ist kleiner als die Anzahl der 2-4 = 8 Zeilen eines 2-Bit-Fehler korrigierenden BCH-Codes der Länge 14.
• Aus der H-Matrix H^7,17 nach der Gleichung (15) sind analog wie das für die Syndromkomponenten s₁,... ,s₆ der H-Matrix H^6,11 vorstehend ausgeführt wurde, die Syndromgleichungen für die Syndromkomponenten s₁,..., s₇ bestimmt.
• Beispiel einer H-Matrix H^8,26
• Für m = 8 und n = 26 zeigt die Gleichung (16) ein weiteres Beispiel für eine H-Matrix H^8,26 $$H^{\mathrm{8,26}}=\left(h_1,h_2,\dots ,h_{25},h_{26}\right)=\left(\begin{array}{llllllllllllllllllllllllll}1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill \\ 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill \\ 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill \\ 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill \end{array}\right)$$

  

  eines Fehlercodes C^8,26 mit 8 Zeilen, d.h. m = 8 Prüfbits, und n = 26 Spalten. Die Länge des Fehlercodes C^8,26 ist n = 26. Der Fehlercode C^8,26 weist (26 - 8 =) 18 Datenbits auf.
• Werden nur 16 Datenbits benötigt, so können beispielsweise die letzten beiden Spalten h₂₅ und h₂₆ der H-Matrix H^8,26 gestrichen werden, um so eine H-Matrix H^8,24 $$H^{\mathrm{8,24}}=\left(h_1,h_2,\dots ,h_{23},h_{24}\right)$$

  

  mit 24 Spalten zu erhalten.
• Durch Nachrechnen lässt sich überprüfen, dass die H-Matrix H^8,26 so bestimmt ist, dass alle 26 Spalten h₁ bis h₂₆ und alle komponentenweisen XOR-Summen der 25 Paare benachbarter Spalten $$\begin{array}{c}{h}_1+h_2,\\ h_2+h_3,\\ ⋮\\ h_{25}+h_{26}\end{array}$$

  

  paarweise unterschiedlich sind.
• Weiterhin sind die $\left({}_2^{26}\right)-25=300$

  

  XOR-Summen aller Paare nicht benachbarter Spalten ungleich allen Spalten und ungleich allen komponentenweisen XOR-Summen der benachbarten Spalten.
• Die komponentenweise XOR-Summen nicht benachbarter Spalten können hingegen identisch sein. Beispielsweise gilt: $$\begin{array}{l}{h}_5+h_7={\left[00001000\right]}^T+{\left[00000010\right]}^T={\left[00001010\right]}^T=\\ h_9+h_{11}={\left[11111101\right]}^T+{\left[0000010\right]}^T.\end{array}$$

  
• Damit ist ein 2-Bit-Fehler in dem 5-ten und dem 7-ten Bit nicht unterscheidbar von einem 2-Bit-Fehler in dem 9-ten und 11-ten Bit.
• Die kleinste ganze Zahl, die ist größer als $$lo{g}_{2}n=lo{g}_{2}26$$

  

  ist 5, da $$2^4=16<26<2^5=32$$

  

  gilt. Die Anzahl der m = 8 Zeilen der H-Matrix H^8,26 ist kleiner als die Anzahl der 2 · 5= 10 Zeilen eines 2-Bit-Fehler korrigierenden BCH-Codes der Länge 26.
• Ein fehlerfreies Codewort der Länge n = 26 wird mit $$v=\left[v_1,\dots ,v_{26}\right]$$

  

  und ein fehlerhaftes, gestörtes Codewort wird mit $$v\text{'}=\left[v_1^{\text{'}},\dots ,v_{26}^{\text{'}}\right]=v+e=v_1+e_1,\dots ,v_{26}+e_{26}$$

  

  bezeichnet, wobei e = e₁, ... , e₂₆ der Fehlervektor ist.
• Das Fehlersyndrom s ist bestimmt gemäß $$s=\left[s_1,\dots ,s_{26}\right]=H^{\mathrm{8,26}}\cdot v^{\text{'}}.$$

  
• Die Komponenten des Fehlersyndrom s ergeben sich aus den Zeilen der H-Matrix H^8,26 und den Komponenten des gestörten Codeworts v' = v'₁,..., v'₂₆. So gilt beispielsweise für die erste Komponente s₁ des Fehlersyndroms entsprechend der ersten Zeile [10000000111111011011100011] der H-Matrix H^8,26 $$s_1=v_1^{\text{'}}+v_9^{\text{'}}+v_{10}^{\text{'}}+v_{11}^{\text{'}}+v_{12}^{\text{'}}+v_{13}^{\text{'}}+v_{14}^{\text{'}}+v_{16}^{\text{'}}+v_{17}^{\text{'}}+v_{19}^{\text{'}}+v_{20}^{\text{'}}+v_{21}^{\text{'}}+v_{25}^{\text{'}}+v_{26}^{\text{'}}.$$

  
• Die Komponenten s₂ bis s₈ des Fehlersyndroms resultieren in analoger Weise basierend auf der zweiten bis achten Zeile der H-Matrix H^8,26 und den Komponenten des gestörten Codeworts v'.
• Durch eine Implementierung der Komponenten s₁ bis s₈ des Fehlersyndroms s kann ein Syndromgenerator des Fehlercodes bestimmt werden.
• Ausführungsbeispiel: Erzeugung weiterer H-Matrizen
• Es soll im Folgenden ein Ausführungsbeispiel beschrieben werden, wie basierend auf einer ersten H-Matrix H^m,n mit m Zeilen und n Spalten, eine zweite H-Matrix H^m+2,2·n+1 mit m + 2 Zeilen und 2 · n + 1 Spalten bestimmt werden kann. Der entsprechende Fehlercode C^m+2,2·n+1 weist dann m + 2 Prüfbits auf. Die Länge des Codes ist 2 · n + 1 und es sind 2 · n - m - 1 Datenbits vorhanden.
• Als Beispiel werden m = 8 und n = 26 und die H-Matrix $$H^{\mathrm{8,26}}=\left(h_1,h_2,\dots ,h_{25},h_{26}\right),$$

  

  gemäß der Gleichung (16) gewählt.
• Aus der ersten H-Matrix H^8,26 nach Gleichung (16) kann eine zweite H-Matrix H^10,53 gemäß $$H^{\mathrm{10,53}}=\left(\begin{array}{lllllllllll}{h}_1\hfill & h_2\hfill & \dots \hfill & h_{25}\hfill & h_{26}\hfill & h_{zw}\hfill & h_1\hfill & h_2\hfill & \dots \hfill & h_{25}\hfill & h_{26}\hfill \\ 0\hfill & 0\hfill & \dots \hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & \dots \hfill & 1\hfill & 1\hfill \\ 0\hfill & 0\hfill & \dots \hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & \dots \hfill & 1\hfill & 0\hfill \end{array}\right)$$

  

  bestimmt werden. Dabei ist eine Spalte h_zw als ein Spaltenvektor $$h_{zw}={\underset{8}{\underbrace{\left[\mathrm{0,}\dots \mathrm{,0}\right]}}}^T$$

  

  mit acht Komponenten eingefügt. Der Spaltenvektor h_zw kann auch als Zwischenspalte bezeichnet werden, die zwischen die beiden H-Matrizen H^8,26 eingefügt wird.
• Allgemein kann die zweite Matrix wie folgt bestimmt werden:
1. 1. Die ursprüngliche Matrix H^m,n wird gedoppelt, wobei zwischen die ursprüngliche Matrix und die gedoppelte Matrix die Zwischenspalte h_zw mit m Nullen eingefügt wird.
2. 2. Die ursprüngliche Matrix kann um zwei Zeilen aus jeweils n Nullen ergänzt werden.
3. 3. Die gedoppelte Matrix kann um eine Zeile aus n Einsen und um eine weitere Zeile ergänzt werden. Die weitere Zeile ist bestimmt durch $$\underset{n}{\underbrace{1010\dots \mathrm{10,}}}$$
   
   falls n gerade ist bzw. ist die weitere Zeile bestimmt durch $$\underset{n}{\underbrace{1010\dots \mathrm{1,}}}$$
   
   falls n ungerade ist.
4. 4. Die Zwischenspalte h_zw aus m Nullen wird um eine Spalte [0,1]^T ergänzt.
• Im obigem Beispiel wurde m = 8 und n = 26 gewählt.
• Basierend auf der H-Matrix H^m,n kann somit die H-Matrix H^m+2,2·n+1 bestimmt werden. Entsprechend kann aus der H-Matrix H^m+2,2·n+1 eine H-Matrix H^m+4,4·n+3 bestimmt werden. Dieser Ansatz kann für weitere H-Matrizen entsprechend fortgesetzt werden.
• Für eine Anzahl von beispielsweise 6, 7 oder 8 Prüfbits können H-Matrizen zur Bestimmung eines Syndromgenerators direkt ermittelt werden. Für eine größere Anzahl von Prüfbits, beispielsweise für 10, 12, 14 oder mehr Prüfbits, können H-Matrizen zur Bestimmung von Syndromgeneratoren aus bereits vorab bestimmten H-Matrizen mit einer geringeren Anzahl von Prüfbits bestimmt werden. Zur Anpassung an eine andere Länge von Codewörtern können erste Spalten und/oder letzte Spalten einer so ermittelten H-Matrix gestrichen werden.
• Modifikationen von H-Matrizen können beispielsweise auch durch Linearkombinationen ihrer Zeilen erfolgen.
• H-Matrizen können beispielsweise auch durch Vertauschen ihrer Spalten modifiziert werden.
• Eine Option ist es, dass der hierin beschriebene Fehlercode mit anderen (z.B. auch bereits bekannten) Fehlercodes kombinierten werden kann. Beispielsweise kann insbesondere eine H-Matrix eines BCH-Codes Teil der hier beschriebenen H-Matrix sein.
• Fehlerverarbeitung
• 1 zeigt eine beispielhafte Anordnung zur Veranschaulichung der Verarbeitung von Daten mittels Fehlercodes.
• Zunächst werden Nutzdaten 101 einer Kodiereinheit 102 zugeführt. Die Kodiereinheit 102 nutzt einen Fehlercode um die Nutzdaten 101 in Form von Codewörtern 103 in einem Speicher 104 zu speichern. Jedes Codewort 103 umfasst Datenbits und Prüfbits.
• Beispielhaft wird nun auf den Speicher 104 lesend zugegriffen. Eine Dekodiereinheit 106 erhält dadurch ein möglicherweise fehlerhaftes Codewort 105. Die Dekodiereinheit 106 führt die Korrektur eines 1-Bit-Fehlers oder eines 2-Bit-Fehlers benachbarter gelesener Speicherzellen (und damit benachbarter Bitpositionen) durch oder sie erkennt einen 2-Bit-Fehler an nicht benachbarten Speicherzellen.
• Somit werden fehlerfreie, ggf. korrigierte, Nutzdaten 107 ausgegeben, die identisch sind mit den Nutzdaten 101, falls kein Fehler oder ein 1-Bit-Fehler oder ein benachbarter 2-Bit-Fehler erkannt wurde. Auch kann von der Dekodiereinheit 106 ein Fehler ausgegeben werden, der anzeigt, dass ein 2-Bit-Fehler in nicht benachbarten Speicherzellen erkannt wurde.

Claims (19)

1. Verfahren zum Verarbeiten von Daten mittels eines Fehlercodes, wobei der Fehlercode eine H-Matrix mit n Spalten und m Zeilen aufweist, - wobei die Spalten der H-Matrix unterschiedlich sind, - wobei komponentenweise XOR-Summen benachbarter Spalten der H-Matrix zueinander und zu allen Spalten der H-Matrix unterschiedlich sind, - wobei komponentenweise XOR-Summen nicht benachbarter Spalten der H-Matrix unterschiedlich sind zu allen Spalten der H-Matrix und zu allen komponentenweisen XOR-Summen benachbarter Spalten der H-Matrix, - bei dem mittels des Fehlercodes - 1-Bit-Fehler korrigiert werden, - benachbarte 2-Bit-Fehler korrigiert werden und - nicht benachbarte 2-Bit-Fehler erkannt werden.
2. Verfahren nach Anspruch 1, bei dem eine Anzahl aller Komponenten einer Spalte kleiner als die kleinste ganze Zahl ist, die größer als 2 · log₂ n ist.
3. Verfahren nach einem der vorhergehenden Ansprüche, bei dem der Fehlercode ein Fehler-erkennender oder ein Fehler-korrigierender und Fehler-erkennender Code ist.
4. Verfahren nach einem der vorhergehenden Ansprüche, bei dem mindestens zwei komponentenweise XOR-Summen nicht benachbarter Spalten der H-Matrix nicht unterschiedlich sind.
5. Verfahren nach einem der vorhergehenden Ansprüche, bei dem der Fehlercode eine Länge von n Bits mit m Prüfbits und n - m Nutzdatenbits aufweist.
6. Verfahren nach einem der vorhergehenden Ansprüche, bei dem entsprechend der H-Matrix ein Syndromgenerator zur Bildung eines m-komponentigen Fehlersyndroms bestimmt ist.
7. Verfahren nach Anspruch 6, bei dem der Syndromgenerator als kombinatorische Schaltung mit n Eingängen und m Ausgängen implementiert ist.
8. Verfahren nach einem der Ansprüche 6 oder 7, bei dem ein Korrekturwertbildner vorgesehen ist, der aus dem von dem Syndromgenerator bereitgestellten m-komponentigen Fehlersyndrom Korrekturwerte für fehlerhafte Bitpositionen bildet.
9. Verfahren nach einem der vorhergehenden Ansprüche, bei dem n ≥ 2^m/2 ist.
10. Verfahren nach einem der vorhergehenden Ansprüche, bei dem die H-Matrix Teil einer erweiterten H-Matrix ist.
11. Verfahren nach Anspruch 10, bei dem die erweiterte H-Matrix wie folgt bestimmt ist: - die H-Matrix wird gedoppelt in eine ursprüngliche H-Matrix und eine gedoppelte H-Matrix, wobei zwischen der ursprünglichen H-Matrix und der gedoppelten H-Matrix eine Zwischenspalte mit m Nullen eingefügt wird, - die ursprüngliche H-Matrix wird um zwei Zeilen mit n Nullen ergänzt, - die gedoppelte H-Matrix wird um eine Zeile mit n Einsen und um eine weitere Zeile ergänzt, wobei die weitere Zeile bestimmt ist durch - eine Bitkombination aus n Bits gemäß 1010...10, falls n geradzahlig ist oder - eine Bitkombination aus n Bits gemäß 1010...1, falls n ungeradzahlig ist, - die Zwischenspalte aus m Nullen um eine Spalte [0,1]^T ergänzt wird.
12. Verfahren nach einem der vorherigen Ansprüche, bei dem die H-Matrix angepasst wird durch Streichen mindestens einer ersten und/oder mindestens einer letzten Spalte.
13. Verfahren nach einem der vorherigen Ansprüche, bei dem die H-Matrix modifiziert wird durch eine Linearkombination ihrer Zeilen.
14. Verfahren nach einem der vorherigen Ansprüche, bei dem die Verarbeitung der Daten ein Schreiben in einen Speicher oder ein Lesen aus einem Speicher umfasst.
15. Vorrichtung zum Verarbeiten von Daten mittels eines Fehlercodes, wobei der Fehlercode eine H-Matrix mit n Spalten und m Zeilen aufweist, wobei die Vorrichtung eine Verarbeitungseinheit umfasst, die derart eingerichtet ist, den Fehlercode entsprechend der H-Matrix zu bestimmen, - wobei die Spalten der H-Matrix unterschiedlich sind, - wobei komponentenweise XOR-Summen benachbarter Spalten der H-Matrix zueinander und zu allen Spalten der H-Matrix unterschiedlich sind, - wobei komponentenweise XOR-Summen nicht benachbarter Spalten der H-Matrix unterschiedlich sind zu allen Spalten der H-Matrix und zu allen komponentenweisen XOR-Summen benachbarter Spalten der H-Matrix.
16. Vorrichtung nach Anspruch 15, wobei die Verarbeitungseinheit einen Syndromgenerator umfasst, der Syndrome basierend auf der H-Matrix ausgibt.
17. Vorrichtung nach einem der Ansprüche 15 oder 16, wobei die Vorrichtung einen Speicher umfasst oder mit einem Speicher koppelbar ist, wobei das Verarbeiten der Daten ein Schreiben in den Speicher oder ein Lesen aus dem Speicher umfasst.
18. Vorrichtung nach einem der Ansprüche 15 bis 17, bei der eine Anzahl aller Komponenten einer Spalte kleiner als die kleinste ganze Zahl ist, die größer als 2 · log₂ n ist.
19. Vorrichtung nach einem der Ansprüche 15 bis 18, bei der mindestens zwei komponentenweise XOR-Summen nicht benachbarter Spalten der H-Matrix nicht unterschiedlich sind.

Images