DE102022101798B3 - Fehlerverarbeitung - Google Patents

Abstract

Es wird eine Lösung vorgeschlagen zur Fehlerverarbeitung, wobei n Bytefehlerpositionen von n Bytefehlern vorgegeben sind (n als positive ganze Zahl), wobei bestimmt wird, ob es eine weitere Bytefehlerposition gibt anhand der n Bytefehlerpositionen und anhand von n + 1 Fehlersyndromkomponenten eines ersten Fehlercodes.

Description

• Der hier beschriebene Ansatz betrifft Lösungen zur Fehlerverarbeitung, umfassend z.B. die Erkennung oder Korrektur von Fehlern, insbesondere Bytefehlern. Die Erkennung kann auch betreffen eine Erkennung, ob (oder ob nicht) ein Fehler bestimmbar ist bzw. eine Fehlerposition bestimmbar ist. Insbesondere betrifft der hier beschriebene Vorschlag eine effiziente Korrektur eines weiteren Bytefehlers.
• Es ist bekannt, Fehler in Daten, die in Form von Bytes vorliegen, byteweise zu erkennen und byteweise zu korrigieren. Ein Byte kann dabei mindestens zwei Bit umfassen. Mindestens ein Fehler in mindestens einem Bit eines Bytes wird als ein Bytefehler bezeichnet. Ist mindestens ein Bit eines Bytes fehlerhaft, liegt ein Bytefehler vor. Ist nur mindestens ein Bit eines einzelnen Bytes fehlerhaft, entspricht dies einem 1-Bytefehler.
• Aus DE 102021109391 B3 ist bekannt, einen Multibytefehler zu erkennen in einem Codewort eines verkürzten Fehlercodes.
• Aus DE 10 2017 125 617 A1 ist bekannt, parallel Bytefehlerpositionssignale zur Indentifikation von Bytefehlern zu bestimmen.
• Die Korrektur von 1-Bytefehlern ist beispielsweise in [Bossen, D.: b-Adjacent Error Correction, IBM J. Res. Dev, July 1970, Seiten 402 bis 408] beschrieben.
• Sind Bit von zwei unterschiedlichen Bytes fehlerhaft, entspricht dies einem 2-Bytefehler. Demnach gilt, dass ein k-Bytefehler vorliegt, wenn Bit in k Bytes fehlerhaft sind (d.h. mindestens ein Bit in jedem der k Bytes einen Fehler aufweist).
• Es ist eine generelle Motivation, die Fehlerkorrektur eventuell fehlerhafter Bytes schnell durchzuführen. Dies gilt beispielsweise wenn in Bytes vorliegende Daten parallel aus einem Speicher ausgelesen und parallel bereitgestellt werden sollen. In so einem Szenario kann es vorteilhaft sein, auch die Fehlerkorrektur parallel durchzuführen.
• Parallel bedeutet hierbei insbesondere, dass zumindest teilweise zeitgleich (beispielsweise auch zumindest teilweise zeitlich überlappend) eine Fehlerkorrektur oder ein Teil der Fehlerkorrektur für mindestens zwei Bytes durchgeführt wird.
• Die Bytefehler-Korrektur kann beispielsweise mittels eines Reed-Solomon-Codes erfolgen.
• In OKANO [Okano, H., Imai, H.: A Construction Method of High-Speed Decoders Using ROM's for Bose-Chaudhuri-Hocquengiem and Reed-Solomon Codes, IEEE TRANSACTIONS ON COMPUTERS, VOL. C-36, NO. 10, OCTOBER 1987, Seiten 1165 bis 1171] ist eine Schaltungsanordnung zur Korrektur von 2-Bytefehlern unter Verwendung eines Reed-Solomon-Codes beschrieben. Hierbei ist es von Nachteil, dass die in OKANO beschriebene Korrektur von 2-Bytefehlern verhältnismäßig langsam ist.
• Die Aufgabe der Erfindung besteht darin, Nachteile bekannter Lösungen zur Korrektur von Bytefehlern zu vermeiden und insbesondere eine effiziente Korrektur von Bytefehlern zu ermöglichen.
• Diese Aufgabe wird gemäß den Merkmalen der unabhängigen Ansprüche gelöst. Bevorzugte Ausführungsformen sind insbesondere den abhängigen Ansprüchen entnehmbar.
• Diese hierin vorgeschlagenen Beispiele können auf zumindest einer der nachfolgenden Lösungen basieren. Insbesondere können Kombinationen der nachfolgenden Merkmale eingesetzt werden, um ein gewünschtes Ergebnis zu erreichen. Die Merkmale des Verfahrens können mit (einem) beliebigen Merkmal(en) der Vorrichtung oder der Schaltung oder umgekehrt kombiniert werden.
• Zur Lösung der Aufgabe wird ein Verfahren zur Fehlerverarbeitung vorgeschlagen,
• - wobei n Bytefehlerpositionen von n Bytefehlern vorgegeben sind, wobei n eine positive ganze Zahl ist,
• - bei dem bestimmt wird, ob es eine weitere Bytefehlerposition gibt anhand der n Bytefehlerpositionen und anhand von n + 1 Fehlersyndromkomponenten eines ersten Fehlercodes.
• Es ist eine Weiterbildung, dass die weitere Bytefehlerposition durch die n Bytefehlerpositionen und die n + 1 Fehlersyndromkomponenten des ersten Fehlercodes bestimmt wird.
• Es ist eine Weiterbildung, dass der erste Fehlercode ein Bytefehlercode, insbesondere ein Reed-Solomon-Code, ist.
• Es ist eine Weiterbildung, dass erkannt wird, dass kein weiterer Bytefehler vorhanden ist, falls keine weitere Bytefehlerposition bestimmbar ist.
• Es ist eine Weiterbildung, dass die weitere Bytefehlerposition in Abhängigkeit mindestens einer symmetrischen Funktion der n Bytefehlerpositionen bestimmt wird.
• Es ist eine Weiterbildung, dass
• - im fehlerfreien Fall ein Byte des ersten Fehlercodes in ein Codewort eines zweiten Fehlercodes transformiert wird,
• - eine Bytefehlerposition bestimmt wird, falls ein Nicht-Codewort des zweiten Fehlercodes erkannt wird.
• Es ist eine Weiterbildung, dass der zweite Fehlercode ein n₁-aus-n-Code ist, wobei 1 ≤ n₁ < n ≤ 2 gilt.
• Es ist eine Weiterbildung, dass Codewörter des zweiten Fehlercodes in einem Speicher gespeichert werden.
• Es ist eine Weiterbildung, dass im fehlerfreien Fall Codewörter des zweiten Fehlercodes aus dem Speicher ausgelesen und in Bytes des ersten Fehlercodes zurücktransformiert werden.
• Es ist eine Weiterbildung, dass das Auslesen aus dem Speicher unter Berücksichtigung einer zeitlichen Reihenfolge erfolgt.
• Es ist eine Weiterbildung, dass dann, wenn beim Auslesen aus dem Speicher ein Nicht-Codewort des zweiten Fehlercodes erkannt wird, eine Bytefehlerposition für dieses Byte des ersten Fehlercodes bestimmt wird.
• Es ist eine Weiterbildung, dass die weitere Bytefehlerposition α₂ bestimmbar ist, so dass gilt: $${\alpha }_2=\frac{s_3+s_2\cdot {\alpha }_1}{s_1\cdot {\alpha }_1+s_2},$$

  

  wobei α₁ die vorgegebene Bytefehlerposition und s₁, s₂, s₃ Syndromkomponenten bezeichnen.
• Auch wird eine Vorrichtung zur Fehlerverarbeitung vorgeschlagen, die eingerichtet ist zu bestimmen, ob es eine weitere Bytefehlerposition gibt anhand von n Bytefehlerpositionen und anhand von n + 1 Fehlersyndromkomponenten eines ersten Fehlercodes, wobei die n Bytefehlerpositionen von n Bytefehlern vorgegeben sind und wobei n eine positive ganze Zahl ist.
• Es ist eine Weiterbildung, dass die Vorrichtung ferner eingerichtet ist, die weitere Bytefehlerposition durch die n Bytefehlerpositionen und die n + 1 Fehlersyndromkomponenten des ersten Fehlercodes zu bestimmen.
• Ferner wird eine Schaltungsanordnung angegeben, umfassend mindestens eine der hierin beschriebenen Vorrichtungen.
• Die Vorrichtung und/oder Schaltungsanordnung können Teile eines integrierten Schaltkreises oder Speicherbausteins oder separat zu diesem ausgeführt sein.
• 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 den Zeichnungen näher erläutert werden. Dabei können zur Übersichtlichkeit gleiche oder gleichwirkende Elemente mit gleichen Bezugszeichen versehen sein.
• Es zeigen:
• 1 ein Beispiel der Verwendung eines ersten und eines zweiten Fehlercodes, wobei der zweite Fehlercode genutzt wird, um mindestens eine Bytefehlerposition bereitzustellen, die der erste Fehlercode zur Korrektur mindestens eines weiteren Bytefehlers nutzen kann;
• 2 ein symbolisches Schaltbild zur Bestimmung von α₁ + α₂ und α₁ · α₂;
• 3 ein symbolisches Schaltbild zur Bestimmung einer weiteren Bytefehlerposition α₃.
• Zur Fehlerkorrektur und Fehlererkennung von beispielsweise in Speicherzellen gespeicherten Daten können Bytefehler-erkennende und Bytefehler-korrigierende Codes (auch bezeichnet als Fehlercodes) verwendet werden. Ein Beispiel für einen Fehlercode ist der Reed-Solomon-Code (siehe dazu auch nachfolgende Ausführungen).
• Bei einem Bytefehler ist die Position der fehlerhaften Bytes zu bestimmen und, sofern der Bytefehler korrigiert werden soll, ist auch der korrekte Wert des Bytes zu ermitteln.
• Die Position des fehlerhaften Bytes wird anhand der Bytefehlerposition (auch bezeichnet als Bytefehlerpositionswert, der angibt welches Byte bzw. welche Bytes (möglicherweise) fehlerhaft sind) bestimmt. Beispielsweise kann ein Wert 1 für die Bytefehlerposition anzeigen, dass das Byte fehlerhaft ist und ein Wert 0 kann anzeigen, dass das Byte nicht fehlerhaft ist.
• Ein Bytefehlerwert gibt an, um welchen Wert sich ein fehlerhaftes Byte von seinem korrekten Wert unterscheidet. Umfasst jedes Byte m Bits, so umfasst auch der Bytefehlerwert m Bits. Beispielweise kann eine Korrektur durchgeführt werden, indem die Bits des fehlerhaften Bytes komponentenweise mit den zugehörigen Bits des Bytefehlerwerts Exklusiv-Oder-verknüpft (XOR-verknüpft) werden.
• Ein t-Bytefehler besagt, dass eine Anzahl von t Bytes fehlerhaft ist. Um einen t-Bytefehler zu korrigieren, sind t Bytefehlerpositionen und t Bytefehlerwerte erforderlich.
• Für ein Byte mit m Bits kann das Byte als ein Element des Galoisfeldes GF(2^m) beschrieben werden. Allgemein gilt: Bilden m p-wertige Werte mit p > 2 ein Byte und ist p eine Primzahl, kann ein Byte als ein Element des Galoisfeldes GF(p^m) beschrieben werden. Hierbei ist m beispielsweise eine positive ganze Zahl größer als 2.
• Im vorliegenden Beispiel werden Bytes mit m Bits verwendet. Entsprechend gibt es 2^m verschiedene m-Bit Bytes.
• Beispielsweise soll eine erste Anzahl von N Bytefehlern korrigiert werden. Entsprechend wird ein N-Bytefehler (N ≥ 1) korrigiert.
• Für eine zweite Anzahl N₁ von Bytefehlern kann die entsprechende Bytefehlerposition schon bestimmt sein, in denen ein Bytefehler aufgetreten ist. Bei einer Korrektur ist dann nur noch der Bytefehlerwert für diese N₁ Bytefehler an den bekannten Bytefehlerpositionen zu bestimmen.
• Für eine dritte Anzahl N₂ von Bytefehlern kann sowohl der Bytefehlerwert als auch die Bytefehlerposition zu bestimmen sein. Dabei kann N₁ + N₂ = N gelten. Dabei ist N₂ ≥ 1 und es kann N₂ = 1 gelten.
• Beispiel: Zwei Fehlercodes
• Beispielsweise bildet das m-Bit Byte im fehlerfreien Fall ein Codewort des Reed-Solomon-Codes. Der Reed-Solomon-Code dient hier als ein erster Fehlercode.
• Zusätzlich kann das m-Bit-Byte in ein Codewort eines zweiten Fehlercodes transformiert werden, bevor es in einem Speicher abgespeichert wird. Der zweite Fehlercode kann ein n₁-aus-n-Code sein.
• Ist beispielsweise m = 6, bilden eine Merhzahl von 6-Bit Bytes im fehlerfreien Fall das Codewort eines Reed-Solomon-Codes. Beispielsweise kann mindestens ein Byte des Codeworts ein Prüfbyte des Reed-Solomon-Codes sein. Pro Byte gibt es in diesem Beispiel 2^m = 2⁶ = 64 verschiedene Werte.
• In diesem Beispiel ist der zweite Fehlercode ein 4-aus-8-Code mit $\left(\begin{array}{l}8\\ 4\end{array}\right)=70$

  

  Codewörtern. Ein 6-Bit Byte des Reed-Solomon-Codes kann beispielsweise in ein Codewort des zweiten Fehlercodes transformiert und in acht Speicherzellen eines Speichers abgespeichert werden (vergleiche hierzu z.B. US 10,903,859 B2 ). Jedes 6-Bit-Byte des ersten Fehlercodes wird dabei umkehrbar eindeutig in eines der 70 Codewörter des 4-aus-8-Codes des zweiten Fehlercodes transformiert.
• Beim Auslesen aus dem Speicher werden im fehlerfreien Fall Codewörter des 4-aus-8-Codes ausgelesen und in 6-Bit Bytes zurück transformiert. Im fehlerfreien Fall ergeben die nach der Rücktransformation vorliegenden 6-Bit Bytes wieder ein Codewort des ersten Fehlercodes.
• Bereits beim Auslesen aus dem Speicher kann überprüft werden, ob ein Codewort des 4-aus-8-Codes vorliegt: Sind nicht 4 Einsen und 4 Nullen gelesen worden, handelt es sich nicht um ein Codewort des 4-aus-8-Codes. In diesem Fall ist das ausgelesene Byte fehlerhaft, für dieses Byte wurde also eine Bytefehlerposition mittels des 4-aus-8-Codes bestimmt.
• Das ausgelesene Nicht-Codewort des 4-aus-8-Codes wird in ein (fehlerhaftes) m-Bit Byte zurücktransformiert. Hierzu kann ein vorgegebener Wert aus den 64 möglichen Werten (z.B. der Wert 0) genutzt werden. Es ist jedoch von Vorteil, dass mit Erkennen eines Nicht-Codeworts des 4-aus-8-Codes eine Information bereitgestellt wird, dass dieses Byte fehlerhaft ist. Auf den zurücktransformierten 6-Bit Wert kommt es dann nicht mehr an, weil davon ausgegangen werden muss, dass dieses Byte mittels des zweiten Fehlercodes korrigiert werden muss. Gemäß den obigen Ausführungen muss für dieses fehlerhafte Byte nur noch der Bytefehlerwert bestimmt werden.
• Somit kann durch die Überprüfung der aus den Speicherzellen ausgelesenen Werte des zweiten Fehlercodes mindestens eine Bytefehlerposition für die Bytes des ersten Fehlercodes bestimmt werden. Hierbei ist es von Vorteil, dass durch die Transformation und die Rücktransformation die Unterscheidbarkeit der Bytes erhalten bleibt: Jedem 6-Bit Byte ist ein 8-Bit Byte zugeordnet und umgekehrt. Damit identifiziert die Bytefehlerposition eindeutig das Byte, egal ob es 6 Bits oder 8 Bits aufweist.
• Es ist ein Vorteil, dass der erste Fehlercode nicht verwendet werden muss, um diese Bytefehlerposition zu bestimmen. Damit können im ersten Fehlercode Prüfbytes eingespart werden.
• 1 veranschaulicht ein Beispiel der Verwendung eines ersten und eines zweiten Fehlercodes. In diesem Beispiel werden 43 Bytes Nutzdaten um 3 Prüfbytes ergänzt. Jedes Byte umfasst 6 Bits. Die (43 + 3 =) 46 Bytes ergeben (im fehlerfreien Fall) ein Codewort des ersten Codes, hier eines Reed-Solomon-Codes (RS-Codes).
• In einem nächsten Schritt wird jedes der Bytes des Codeworts des RS-Codes in ein Codewort des zweiten Codes transformiert. Im vorliegenden Beispiel ist der zweite Code ein 4-aus-8-Code: Die Codewörter des 4-aus-8-Code weisen 4 Einsen und 4 Nullen auf. Nach der Transformation ergeben sich wieder 46 Bytes. Diese werden in einem Speicher abgelegt.
• Beim Lesen aus dem Speicher werden die 46 Bytes ausgelesen. Hierbei wird geprüft, ob jedes der gelesenen Bytes ein Codewort des 4-aus-8-Codes ist.
• Gemäß einer beispielhaften Implementierung können die einzelnen Bytes aus dem Speicher unter Nutzung einer zeitlichen Domäne gelesen werden. In diesem Fall kann vorteilhaft der Lesevorgang bereits beendet werden, wenn 4 Bits des gleichen Typs, also entweder 4mal der Wert 0 oder 4mal der Wert 1 gelesen wurde. Für die verbleibenden noch nicht eingetroffenen Bits wird dann der jeweils andere Wert angenommen. Dieser Ansatz nutzt die Eigenschaft des 4-aus-8-Codes, bei dem Codewörter 4 Einsen oder 4 Nullen aufweisen. Hierbei kann es zu Fehlern kommen dergestalt, dass fünf statt vier gleicher Werte gelesen werden und somit kein Codewort des zweiten Codes mehr vorliegt. Zu Details hinsichtlich des Auslesens von Speicherzellen in der Zeitdomäne sei beispielsweise auf US 9,805,771 B2 verwiesen: Hierbei wird ein Lesestrom, der beim Auslesen in Abhängigkeit von einem in der Speicherzelle gespeicherten Widerstandswert gebildet wird, in einem Kondensator integriert. Den Speicherzellen, die in der zeitlichen Reihenfolge am schnellsten eine bestimmte Spannung des Kondensators erreichen, kann jeweils der Wert 1 zugeordnet werden und den Zellen, die als langsamsten die bestimmte Spannung erreichen, kann jeweils der Wert 0 zugeordnet werden.
• Handelt es sich bei dem aus dem Speicher gelesenen 8-Bit Byte um ein Codewort des zweiten Fehlercodes, d.h. des 4-aus-8-Codes, dann erfolgt die Rücktransformation dieses Codeworts in einen 6-Bit Wert gemäß der vorstehend erwähnten Zuordnung. Sind alle 46 Bytes Codewörter des zweiten Fehlercodes, erfolgt die Rücktransformation in 46 6-Bit Bytes, die im fehlerfreien Fall ein Codewort des ersten Fehlercodes, d.h. des RS-Codes, sind.
• Ist mindestens eines der gelesenen 8-Bit-Bytes kein Codewort des 4-aus-8-Codes, so gibt es mindestens eine Bytefehlerposition, die dem nachfolgenden Korrekturschritt mitgeteilt wird, um die Korrektur dieses mindestens einen fehlerhaften Bytes mittels des ersten Fehlercodes einzuleiten.
• Der hier beschriebene Ansatz erlaubt auch die Erkennung der weiteren Bytefehlerposition durch den ersten Fehlercode (mit anschließender Korrektur), die mit einem 4-aus-8-Codewort assoziiert ist, das mittels mehrerer Fehler in ein weiteres 4-aus-8-Codewort verfälscht wurde. Zwar ist dieses falsche 4-aus-8-Codewort von dem zweiten Fehlercode nicht erkennbar und damit kann auch die Bytefehlerposition für dieses Codewort durch den zweiten Fehlercode nicht ermittelt werden. Allerdings kann ein zusätzlicher Bytefehler vorliegen, der von dem zweiten Fehlercode erkannt wird. Für diesen zusätzlichen Bytefehler liefert der zweite Fehlercode die Bytefehlerposition. Basierend auf dieser Bytefehlerposition kann nun der erste Fehlercode die weitere Bytefehlerposition (die dem verfälschten 4-aus-8-Codewort entspricht) ermitteln und korrigieren.
• Alternative zweite Fehlercodes
• Die Erfindung ist nicht darauf beschränkt, dass der zweite Fehlercode ein n₁-aus-n-Code ist. Beispielsweise kann ein m-Bit Byte des ersten Fehlercodes auf ein (m + 1)-Bit Byte des zweiten Fehlercodes abgebildet werden, indem zusätzlich ein ParitätsBit aus den m Bits des Bytes des ersten Fehlercodes gebildet wird und an die m Bits des ersten Fehlercodes angehängt wird. Ein Codewort des zweiten Fehlercodes kann ein (m + 1)-Bit-Wort mit einer geraden Anzahl von Einsen sein.
• Gemäß einem weiteren Beispiel können die m Bits eines Bytes des ersten Fehlercodes auch verdoppelt und somit redundant in dem Speicher gespeichert werden. Beim Lesen kann mittels des zweiten Fehlercodes kontrolliert werden, ob zweimal das gleiche m-Bit Byte erhalten wurde.
• Auch können unterschiedliche m-Bit Bytes des ersten Fehlercodes nach unterschiedlichen Vorschriften in Codewörter des zweiten Fehlercodes (z.B. unterschiedliche Fehlercodes) transformiert werden. So kann beispielsweise ein erstes 6-Bit Byte in ein Codewort eines 4-aus-8 Codes transformiert werden und ein zweites 6-Bit Byte wird in ein 7-Bit Byte (6 Bits mit einem zusätzlichen Paritätsbit) transformiert.
• Für den hier beschriebenen Ansatz ist der zweite Fehlercode nicht zwingend erforderlich. Es ist lediglich erforderlich, dass für ein fehlerhaftes Byte eine Bytefehlerposition bestimmbar ist, die bei der Bestimmung einer weiteren Bytefehlerposition durch den ersten Fehlercode verwendet werden kann und nicht von diesem bestimmt werden muss.
• Beispielsweise können pro Nutzdatenbyte Messwerte gespeichert werden, die in einem bestimmten vorbekannten Wertebereich liegen. Bei dem Messwert kann es sich z.B. um Temperatur, Luftdruck, Länge von Bauteilen o.ä. handeln.
• Die Nutzdatenbytes können zusammen mit Prüfbytes in einem Speicher abgespeichert werden, wobei die Nutzdatenbytes und die Prüfbytes (im fehlerfreien Fall) ein Codewort des ersten Fehlercodes bilden. Stellt sich beim Lesen aus dem Speicher heraus, dass ein Nutzdatenbyte nicht in dem bekannten Wertebereich liegt, so kann für dieses Byte eine Bytefehlerposition erkannt werden.
• Die hier beschriebenen Beispiele ermöglichen insbesondere die Verbesserung der Fehlerkorrektur und Fehlererkennung eines ersten Fehlercodes. Dabei soll die weitere Bytefehlerposition effizient und mit geringem Aufwand bestimmt werden.
• Allgemeine Beschreibung von Reed-Solomon-Codes
• Nachfolgend werden einige Begriffe und Eigenschaften von Reed-Solomon-Codes erläutert.
• Beispielsweise werden
• - t-Bytefehler-korrigierende Codes und
• - t-Bytefehler-korrigierende und (t + 1)-Bytefehler-erkennende Codes betrachtet. Insbesondere werden die Fälle t = 2 und t = 1 berücksichtigt.
Beispielsweise können als Bytefehler-korrigierende Codes bekannte Reed-Solomon-Codes verwendet werden. Für Reed-Solomon-Codes sei beispielhaft verwiesen auf [Lin, S., Costello, D.: Error Control Coding, Prentice Hall, 1983, Seiten 170 bis 177] oder [Wicker, S.: Error Control Systems for Digital Communication and Storage, Prentice Hall, 1995, Seiten 214 bis 224].
• Ein 1-Bytefehler-korrigierender und 2-Bytefehler-erkennender Reed-Solomon-Code weist eine H-Matrix $H_{Byte}^{\ast }$

  

  auf wie folgt: $$H_{Byte}^{\ast }=\left(\begin{array}{ccccc}{\alpha }^0& {\alpha }^1& {\alpha }^2& \dots & {\alpha }^{2^m-2}\\ {\alpha }^0& {\alpha }^2& {\alpha }^4& \dots & {\alpha }^{2\left(2^m-2\right)}\\ {\alpha }^0& {\alpha }^3& {\alpha }^6& \dots & {\alpha }^{3\left(2^m-2\right)}\end{array}\right)$$

  
• Hierbei sind αⁱ Elemente des Galoisfelds GF(2^m). Diese liegen beispielsweise in einer Exponentialdarstellung vor. α kann ein primitives Element des Galoisfelds GF(2^m) sein. Die Exponenten j von α^j sind modulo 2^m - 1 zu interpretieren.
• Es ist möglich, aus der H-Matrix gemäß Gleichung (1) eine H-Matrix $$H_{Byte}=\left(\begin{array}{ccccc}{\alpha }^0& {\alpha }^0& {\alpha }^0& \dots & {\alpha }^0\\ {\alpha }^0& {\alpha }^1& {\alpha }^2& \dots & {\alpha }^{2^m-2}\\ {\alpha }^0& {\alpha }^2& {\alpha }^4& \dots & {\alpha }^{2\left(2^m-2\right)}\end{array}\right)$$

  

  abzuleiten, indem für i = 0,..., (2^m - 2) die i-te Spalte mit α^-i multipliziert wird. Hierdurch ändert sich nur die Gestalt der H-Matrix, nicht der Code, da α^-i ≠ 0 ist. Dies ist beispielsweise auch in [Fujiwara, E.: Code Design for Dependable Systems, Wiley, 2006, Seite 65] beschrieben, wobei der Wert „1“ für α⁰ verwendet wird, da α⁰ das Einselement des verwendeten Galoisfelds ist.
• Für einen 2-Bytefehler-korrigierenden und 3-Bytefehler-erkennenden Code wird die folgende H-Matrix verwendet: $$H_{Byte}=\left(\begin{array}{ccccc}{\alpha }^0& {\alpha }^0& {\alpha }^0& \dots & {\alpha }^0\\ {\alpha }^0& {\alpha }^1& {\alpha }^2& \dots & {\alpha }^{2^m-2}\\ {\alpha }^0& {\alpha }^2& {\alpha }^4& \dots & {\alpha }^{2\left(2^m-2\right)}\\ {\alpha }^0& {\alpha }^3& {\alpha }^6& \dots & {\alpha }^{3\left(2^m-2\right)}\\ {\alpha }^0& {\alpha }^4& {\alpha }^8& \dots & {\alpha }^{4\left(2^m-2\right)}\end{array}\right)$$

  
• Jede Spalte der in Gleichung (3) angegebenen H-Matrix entspricht einem Byte.
• Ist die Länge des Codes gleich N Bytes oder m·N-Bit (wobei jedes Byte m-Bit aufweist), werden nur N Spalten der H-Matrizen gemäß Gleichung (1) oder Gleichung (3) verwendet. Beispielsweise können dann die verbleibenden (letzten) 2^m - 2 - N Spalten gestrichen werden.
• Allgemein kann für einen t-Bytefehler-korrigierenden und t + 1-Bytefehler-erkennenden Code die H-Matrix wie folgt angegeben werden: $$H_{Byte}=\left(\begin{array}{ccccc}{\alpha }^0& {\alpha }^0& {\alpha }^0& \dots & {\alpha }^0\\ {\alpha }^0& {\alpha }^1& {\alpha }^2& \dots & {\alpha }^{2^m-2}\\ {\alpha }^0& {\alpha }^2& {\alpha }^4& \dots & {\alpha }^{2\left(2^m-2\right)}\\ {\alpha }^0& {\alpha }^3& {\alpha }^6& \dots & {\alpha }^{3\left(2^m-2\right)}\\ {\alpha }^0& {\alpha }^4& {\alpha }^8& \dots & {\alpha }^{4\left(2^m-2\right)}\\ ⋮& ⋮& ⋮& \dots & ⋮\\ {\alpha }^0& {\alpha }^{2t\cdot 1}& {\alpha }^{2t\cdot 2}& \dots & {\alpha }^{2t\cdot \left(2^m-2\right)}\end{array}\right)$$

  
• Nachfolgend wird beispielhaft ein Code betrachtet, der 2-Bytefehler korrigieren und 3-Bytefehler erkennen kann.
• Tritt ein Fehler auf, wird ein korrekter Vektor v = v⁰, ... , v^N-1 in einen fehlerhaften Vektor v' = v'⁰, ... , v'^N-1 gestört.
• Die Komponenten v⁰,...,v^N-1 des Vektors v sind Bytes, die jeweils m-Bit umfassen, so dass $v^i=v_1^i,\dots ,v_m^i$

  

  für i= 0,..., N - 1 gilt. $v_1^i,\dots ,v_m^i$

  

  sind somit die m-Bit des i-ten Bytes.
• Ein m-Bit-Byte kann auch als ein Element des Galoisfelds GF(2^m) bezeichnet werden.
• Liegt ein 1-Bytefehler vor, ist nur ein einzelnes Byte fehlerhaft, d.h. für ein bestimmtes i ∈ {0,... ,7V — 1} ist das zugehörige i-te Byte fehlerhaft.
• Wird das korrekte i-te Byte mit $v^i=v_1^i,\dots ,v_m^i$

  

  und das fehlerhafte i-te Byte mit $v{\text{'}}^i=v_1^{\text{'}i},\dots ,v_m^{\text{'}i}$

  

  bezeichnet, können sich 1 oder 2 oder bis zu m-Bit des korrekten i-ten Bytes von dem fehlerhaften i-ten Byte unterscheiden.
• Ein Bytefehler im i-ten Byte kann durch
• - die fehlerhafte Byteposition i und
• - einen Bytefehlerwert
$$e^i=v^i\oplus v^{\text{'}i}=v_1^i\oplus v_1^{\text{'}i},\dots ,v_m^i\oplus v_m^{\text{'}i}$$

beschrieben werden. Hierbei sei angemerkt, dass „⊕“ die exklusiv-oder-Operation kennzeichnet.
• Die Position eines i-ten Bytes kann auch mit αⁱ bezeichnet werden.
• Soll ein Bytefehler mit dem Bytefehlerwert eⁱ in der Byteposition i korrigiert werden, so ist für die Byteposition i ein Bytefehlerkorrekturwert zu bestimmen, der gleich dem Bytefehlerwert ist.
• In diesem Beispiel ist für einen zu korrigierenden Bytefehler der Bytefehlerwert gleich dem Bytefehlerkorrekturwert; insoweit können die Begriffe Bytefehlerwert und Bytefehlerkorrekturwert synonym verwendet werden.
• Um eine unübersichtliche Anzahl von Indizes zu vermeiden, werden nachfolgend Bytefehlerwerte mit den alphabetischen Buchstaben a, b, c bezeichnet.
• Ein Bytefehlerkorrekturwert für das i-te Bytes kann auch mit a(i) bezeichnet werden.
• Bytepositionen können mit i, j, k, ... oder mit αⁱ, α^j, α^k, ... bezeichnet werden, wobei α ein erzeugendes Element des Galoisfelds GF(2^m) ist.
• Ein Fehlersyndrom s weist Syndromkomponenten (auch bezeichnet als Komponenten, Fehlersyndromkomponenten, Teilfehlersyndrome oder Teilsyndrome) s₁, s₂, s₃, s₄, s₅ auf, die für die H-Matrix gemäß Gleichung (4) bestimmt sind zu: $$s_1=\left({\alpha }^0,{\alpha }^0,{\alpha }^0,\dots ,{\alpha }^0\right)\cdot {\left(v^{\text{'}0},\dots ,v^{\text{'}M-1}\right)}^T,$$

  

  $$s_2=\left({\alpha }^0,{\alpha }^1,{\alpha }^2,\dots ,{\alpha }^{2^m-2}\right)\cdot {\left(v^{\text{'}0},\dots ,v^{\text{'}M-1}\right)}^T,$$

  

  $$s_3=\left({\alpha }^0,{\alpha }^2,{\alpha }^4,\dots ,{\alpha }^{2\left(2^m-2\right)}\right)\cdot {\left(v^{\text{'}0},\dots ,v^{\text{'}M-1}\right)}^T,$$

  

  $$s_4=\left({\alpha }^0,{\alpha }^3,{\alpha }^6,\dots ,{\alpha }^{3\left(2^m-2\right)}\right)\cdot {\left(v^{\text{'}0},\dots ,v^{\text{'}M-1}\right)}^T,$$

  

  $$\begin{array}{c}{s}_5=\left({\alpha }^0,{\alpha }^4,{\alpha }^8,\dots ,{\alpha }^{4\left(2^m-2\right)}\right)\cdot {\left({\nu }^{\text{'}0},\dots ,{\nu }^{\text{'}M-1}\right)}^T,\\ ⋮\end{array}$$

  

  $$s_{2t+1}=\left({\alpha }^0,{\alpha }^{2t},{\alpha }^{2\cdot \left(2t\right)},\dots ,{\alpha }^{2t\cdot \left(2^m-2\right)}\right)\cdot {\left({\nu }^{\text{'}0},\dots ,{\nu }^{\text{'}M-1}\right)}^T.$$

  
• Dabei ist $$v^{\text{'}}={\left(v^{\text{'}}{}^0,\dots ,v^{\text{'}}{}^{M-1}\right)}^T$$

  

  ein Spaltenvektor mit einer Anzahl von M Komponenten, die jeweils m Bits aufweisen. Dieser Spaltenvektor kann auch als transponierter Vektor des Zeilenvektors (v'⁰, ... ,v'^M-1) bezeichnet werden.
• Die Syndromkomponenten s₁, s₂, ..., s_2t+1 sind jeweils ein Byte mit m Bits.
• Liegt ein 1-Bytefehler vor, so gilt s₁ ≠ 0 und $$Det\left(\begin{array}{cc}{s}_1& s_2\\ s_2& s_3\end{array}\right)=0.$$

  
• Liegt ein 2-Bytefehler vor, so gilt $$Det\left(\begin{array}{cc}{s}_1& s_2\\ s_2& s_3\end{array}\right)\ne 0$$

  

  und $$Det\left(\begin{array}{ccc}{s}_1& s_2& s_3\\ s_2& s_3& s_4\\ s_3& s_4& s_5\end{array}\right)=0.$$

  
• Liegt ein 3-Bytefehler vor, so gilt $$Det\left(\begin{array}{ccc}{s}_1& s_2& s_3\\ s_2& s_3& s_4\\ s_3& s_4& s_5\end{array}\right)\ne 0$$

  

  und $$Det\left(\begin{array}{cccc}{s}_1& s_2& s_3& s_4\\ s_2& s_3& s_4& s_5\\ s_3& s_4& s_5& s_6\end{array}\right)=0.$$

  
• Dies kann entsprechend fortgesetzt werden bis zu einem t-Bytefehler: So liegt ein t-Bytefehler dann vor, wenn gilt: $$Det\left(\begin{array}{ccccc}{s}_1& s_2& s_3& \cdots & s_t\\ s_2& s_3& s_4& \cdots & s_{t+1}\\ ⋮& ⋮& ⋮& \cdots & ⋮\\ s_t& s_{t+1}& s_{t+2}& \cdots & s_{2t-1}\end{array}\right)\ne 0$$

  

  und $$Det\left(\begin{array}{ccccc}{s}_1& s_2& s_3& \cdots & s_{t+1}\\ s_2& s_3& s_4& \cdots & s_{t+2}\\ ⋮& ⋮& ⋮& \cdots & ⋮\\ s_t& s_{t+1}& s_{t+2}& \cdots & s_{2t}\end{array}\right)=0.$$

  
• Die Anzahl der Bytefehler kann durch die Bestimmung der Werte der angegebenen Determinante bestimmt werden. Dies ist mit steigender Anzahl der möglichen Fehler aufwändig: So ist zur Feststellung, ob entsprechend den Gleichungen (10) und (11) ein t-Bytefehler vorliegt, der Wert einer Determinanten zu bestimmen, die 2·t Syndromkomponenten als Elemente aufweist. Diese sind zusätzlich zu den Nutzdatenbytes zu speichern. Jede Syndromkomponente entspricht einem Byte mit m Bits.
• Eine Bytefehlerposition kann beispielsweise als Nullstellen des Lokatorpolynoms bestimmt werden.
• Eine Nullstelle eines Lokatorpolynoms kann als ein Element des entsprechenden Galoisfeldes GF(2^m) beschrieben werden.
• Ein erstes, zweites, drittes Element, etc. des Galoisfeldes wird hierbei mit α₁, α₂, α₃, etc. bezeichnet. Dabei ist nicht festgelegt, um welches Element des Galoisfeldes es sich konkret handelt.
• Ist $$\left\{{\alpha }^0,{\alpha }^1,{\alpha }^2,\dots ,{\alpha }^i,\dots ,{\alpha }^{2^m-2}\right\}$$

  

  beispielsweise die Menge der 2^m - 1 Elemente des Galoisfeldes ungleich 0 in ihrer Exponentialdarstellung, dann sind α₁, α₂, α₃, etc. Elemente dieser Menge. Beispielsweise kann $${\alpha }_1={\alpha }^{10},$$

  

  $${\alpha }_2={\alpha }^3,$$

  

  $${\alpha }_3={\alpha }^0$$

  

  oder eine andere Zuordnung gelten.
• Die Lokatorpolynome ergeben sich für die unterschiedlichen Anzahlen von Bytefehlern zu:
• - für einen 1-Bytefehler: $$L_1\left(x\right)=\left(x+{\alpha }_1\right)=x+\sigma {\left(1\right)}_1;$$
  
• - für einen 2-Bytefehler: $$L_2\left(x\right)=\left(x+{\alpha }_1\right)\left(x+{\alpha }_2\right)=x^2+x\sigma {\left(2\right)}_1+\sigma {\left(2\right)}_2;$$
  
• - für einen 3-Bytefehler: $$\begin{array}{c}{L}_3\left(x\right)=\left(x+{\alpha }_1\right)\left(x+{\alpha }_2\right)\left(x+{\alpha }_3\right)=\\ =x^3+x^2\sigma {\left(3\right)}_1+x^2\sigma {\left(3\right)}_2+\sigma {\left(3\right)}_3;\end{array}$$
  
• - für einen 4-Bytefehler: $$\begin{array}{c}{L}_4\left(x\right)=\left(x+{\alpha }_1\right)\left(x+{\alpha }_2\right)\left(x+{\alpha }_3\right)\left(x+{\alpha }_4\right)=\\ =x^4+x^3\sigma {\left(4\right)}_1+x^2\sigma {\left(4\right)}_2+x\sigma {\left(4\right)}_3+\sigma {\left(4\right)}_4;\end{array}$$
  
• - für einen n-Bytefehler: $$\begin{array}{c}{L}_n\left(x\right)=\left(x+{\alpha }_1\right)\left(x+{\alpha }_2\right)\cdot \dots \cdot \left(x+{\alpha }_n\right)=\\ =x^n+x^{n-1}\sigma {\left(n\right)}_1+x^{n-2}\sigma {\left(n\right)}_2+\dots +\sigma {\left(n\right)}_n.\end{array}$$
  
• Dabei bezeichnet der Koeffizient σ(j)_i eines Lokatorpolynoms für j = 1,...,n und i = 1,...,n eine bekannte elementarsymmetrische Funktion von j Variablen α₁ bis α_j. Dies kann durch Ausmultiplizieren von $$\left(x+{\alpha }_1\right)\left(x+{\alpha }_2\right)\cdot \dots \cdot \left(x+{\alpha }_n\right)$$

  

  verifiziert werden.
• So gilt beispielsweise $$\sigma {\left(1\right)}_1={\alpha }_1$$

  

  $$\sigma {\left(2\right)}_1={\alpha }_1+{\alpha }_2,$$

  

  $$\sigma {\left(2\right)}_2={\alpha }_1\cdot {\alpha }_2,$$

  

  $$\sigma {\left(3\right)}_1={\alpha }_1+{\alpha }_1+{\alpha }_3,$$

  

  $$\sigma {\left(3\right)}_2={\alpha }_1\cdot {\alpha }_2+{\alpha }_1\cdot {\alpha }_3+{\alpha }_2\cdot {\alpha }_3,$$

  

  $$\sigma {\left(3\right)}_3={\alpha }_1\cdot {\alpha }_2\cdot {\alpha }_3,$$

  

  $$\sigma {\left(4\right)}_1={\alpha }_1+{\alpha }_1+{\alpha }_3+{\alpha }_4,$$

  

  $$\sigma {\left(4\right)}_2={\alpha }_1\cdot {\alpha }_2+{\alpha }_1\cdot {\alpha }_3+{\alpha }_1\cdot {\alpha }_4+{\alpha }_2\cdot {\alpha }_3+{\alpha }_2\cdot {\alpha }_4+{\sigma }_3\cdot {\alpha }_4,$$

  

  $$\sigma {\left(4\right)}_3={\alpha }_1\cdot {\alpha }_2\cdot {\alpha }_3+{\alpha }_1\cdot {\alpha }_2\cdot {\alpha }_4+{\alpha }_1\cdot {\alpha }_3\cdot {\alpha }_4+{\alpha }_2\cdot {\alpha }_3\cdot {\alpha }_4,$$

  

  $$\begin{array}{l}\sigma {\left(4\right)}_4={\alpha }_1\cdot {\alpha }_2\cdot {\alpha }_3\cdot {\alpha }_4,\\ ⋮\end{array}$$

  

  $$\begin{array}{l}⋮\\ \sigma {\left(n\right)}_1={\alpha }_1+{\alpha }_1+\dots +{\alpha }_n,\\ ⋮\end{array}$$

  

  $$\sigma {\left(n\right)}_n={\alpha }_1\cdot {\alpha }_2\cdot \dots \cdot {\alpha }_n.$$

  
• Eine symmetrische Funktion σ(k)_i mit 1 ≤ i ≤ k hängt dabei, wie in den Beispielen dargestellt, von k Variablen α₁,...,α_k ab. Sie enthält alle möglichen (7) unterschiedlichen Produkte von ihrer Variablen, die mit der Operation „+“ im Galoisfeld GF(2^m) verknüpft sind. Ist i = 1, bestehen die $\left(\begin{array}{l}k\\ 1\end{array}\right)=k$

  

  Produkte jeweils nur aus einer der Variablen. Die Addition erfolgt im Galoisfeld GF(2^m). Sie entspricht hier der komponentenweisen Addition modulo 2. Als Variablen der symmetrischen Funktionen werden hier die Variablen α₁, α₂, α₃, etc. verwendet.
• Zwischen den Komponenten der Fehlersyndrome und den Komponenten der entsprechenden Lokatorpolynome ist die folgende Beziehung für einen t-Bytefehler bekannt: $$\left(\begin{array}{ccccc}{s}_1& s_2& s_3& \cdots & s_t\\ s_2& s_3& s_4& \cdots & s_{t+1}\\ s_3& s_4& s_5& \cdots & s_{t+1}\\ ⋮& ⋮& ⋮& \cdots & ⋮\\ s_{t-1}& s_t& s_{t+1}& \cdots & s_{2t-2}\\ s_t& s_{t+1}& s_{t+2}& \cdots & s_{2t-1}\end{array}\right)\cdot \left(\begin{array}{c}\mathrm{\sigma }{\left(t\right)}_t\\ \mathrm{\sigma }{\left(t\right)}_{t-1}\\ \mathrm{\sigma }{\left(t\right)}_{t-2}\\ ⋮\\ \mathrm{\sigma }{\left(t\right)}_2\\ \mathrm{\sigma }{\left(t\right)}_1\end{array}\right)=\left(\begin{array}{c}-s_{t+1}\\ -s_{t+2}\\ -s_{t+3}\\ ⋮\\ -s_{2t-1}\\ -s_{2t}\end{array}\right).$$

  
• Dies ist beispielsweise in [Wicker, S.: Error Control Systems for Digital Communication and Storage, Prentice Hall, 1995, Seiten 215] beschrieben, wobei dort für die Syndromkomponente s_i die Bezeichnung S_i und für den Koeffizienten σ(t)_i die Bezeichnung Λ_i verwendet wird.
• Wird beispielhaft ein Galoisfeld GF(q^m) mit q = 2 verwendet, können die negativen Vorzeichen in Gleichung (17) weggelassen werden, da in einem Galoisfeld GF(2^m) Addition und Subtraktion gleich sind. Beispielhaft wird nachfolgend das Galoisfeld GF(2^m) verwendet und die negativen Vorzeichen in Gleichung (17) werden weggelassen.
• Weiterer (zusätzlicher) Bytefehler bei einem Bytefehler an einer gegebenen Bytefehlerposition
• Im Folgenden wird beispielhaft ausgeführt, wie
• - eine weitere Bytefehlerposition bestimmt wird, sofern ein weiterer Bytefehler aufgetreten ist oder
• - bestimmt wird, dass kein weiterer Bytefehler aufgetreten ist, wenn eine Anzahl von N₁ Bytefehlern bekannt ist.
• Dabei ist die Anzahl der Bytefehler N₁ größer oder gleich 1.
• Es wird darauf abgestellt, dass vorab bereits ein Bytefehler oder mehrere Bytefehler aufgetreten ist/sind. Dann kann der mindestens eine weitere Bytefehler gemäß obiger Formulierung auftreten.
• Sind beispielsweise N₁ Bytefehlerpositionen bestimmt, dann kann eine weitere (N₁ + 1)-te Bytefehlerposition bestimmt werden, wenn an dieser Position ein Bytefehler aufgetreten ist. Ist keine weitere Bytefehlerposition fehlerhaft, so ist auch kein weiterer Bytefehler aufgetreten.
• Hierbei sei angemerkt, dass ein aufgetretener Bytefehler ein mittels eines Fehlercodes detektierbarer Bytefehler ist. Es ist denkbar, dass ein nicht erkennbarer Bytefehler vorliegt, der unerkannt bleibt und insofern gemäß den vorliegenden Ausführungen als nicht aufgetreten angesehen wird.
• Beispielsweise ist eine erste Bytefehlerposition α₁ gegeben. Die Bytefehlerposition besagt, dass für dieses Byte, dass mehrere Bits umfasst, ein Fehler detektiert wurde.
• Sofern ein weiterer Bytefehler in einem anderen Byte aufgetreten ist, kann eine zweite Bytefehlerposition α₂ bestimmt werden. Auch kann bestimmt werden, dass keine weitere Bytefehlerposition vorhanden ist, wenn kein zweiter Bytefehler aufgetreten ist.
• Im Falle eines 1-Bytefehlers mit der vorgegebenen Bytefehlerposition α₁ und mit einem Bytefehlerwert a gilt $$s_1=a,$$

  

  $$s_2={\alpha }_1\cdot a=s_1\cdot {\alpha }_1.$$

  
• Es ist nicht erforderlich, dass der Bytefehlerwert a bekannt ist.
• Im Falle eines 2-Bytefehlers mit
• - der bekannten Bytefehlerposition α₁ mit einem Bytefehlerwert a und
• - einer weiteren (noch unbekannten) Bytefehlerposition α₂ mit einem Bytefehlerwert b
gilt $$s_1=a+b,$$

$$s_2={\alpha }_1\cdot a+{\alpha }_2\cdot b,$$

$$s_3={\alpha }_1^2\cdot a+{\alpha }_2^2\cdot b$$

und damit $$s_1\cdot {\alpha }_1=\left(a+b\right)\cdot {\alpha }_1=a\cdot {\alpha }_1+b\cdot {\alpha }_1\ne s_2=a\cdot {\alpha }_1+b\cdot {\alpha }_2.$$

• Es ist nicht erforderlich, dass die Werte α₂, a und b bekannt sind.
• Bei bekannter Bytefehlerposition α₁ kann anhand von $$s_1\cdot {\alpha }_1+s_2=0$$

  

  bestimmt werden, dass kein 2-Bytefehler vorliegt und anhand von $$s_1\cdot {\alpha }_1+s_2\ne 0$$

  

  festgestellt werden, dass kein 1-Bytefehler vorliegt.
• Liegt kein 1-Bytefehler vor, sondern liegt ein 2-Bytefehler mit bekannter Bytefehlerposition α₁ und zu bestimmender Bytefehlerposition α₂ vor, dann gilt $$s_1\mathrm{\sigma }{\left(2\right)}_2+s_2\mathrm{\sigma }{\left(2\right)}_1=s_3$$

  

  mit $$\sigma {\left(2\right)}_2={\alpha }_1\cdot {\alpha }_2=\sigma {\left(1\right)}_1\cdot {\alpha }_2$$

  

  und $$\sigma {\left(2\right)}_1={\alpha }_1+{\alpha }_2=\sigma {\left(1\right)}_1+{\alpha }_2$$

  

  und damit $$s_1\cdot {\alpha }_1\cdot {\alpha }_2+s_2\left({\alpha }_1+{\alpha }_2\right)=s_3=s_1\cdot \sigma {\left(1\right)}_1\cdot {\alpha }_2+s_2\left(\sigma {\left(1\right)}_1+{\alpha }_2\right).$$

  
• Die Gleichung (27) ist nach der zu bestimmenden Bytefehlerposition α₂ auflösbar: $${\alpha }_2=\frac{s_3+s_2\cdot {\alpha }_1}{s_1\cdot {\alpha }_1+s_2}=\frac{s_3+s_2\cdot \sigma {\left(1\right)}_1}{s_1\cdot \sigma {\left(1\right)}_1+s_2}.$$

  
• Die Bytefehlerposition α₂ ist aus den drei Syndromkomponenten s₁, s₂ und s₃ und der symmetrischen Funktionen σ(1)₁ = α₁ bestimmbar. Wie ausgeführt, ist die Bytefehlerposition α₁ vorbekannt. Es ist daher nicht erforderlich, die Lösungen des entsprechenden Lokatorpolynoms zu bestimmen.
• Weiterer (zusätzlicher) Bytefehler bei zwei Bytefehlern an zwei (unterschiedlichen) gegebenen Bytefehlerpositionen
• Alternativ wird beschrieben, wie im Falle von zwei bekannten Bytefehlerpositionen α₁ und α₂ bestimmt wird, ob ein dritter Bytefehler vorliegt und wenn ein dritter Bytefehler vorliegt, wie dann eine dritte Bytefehlerposition bestimmt werden kann. Dabei unterscheiden sich die Bytefehlerpositionen α₁, α₂ und α₃ voneinander.
• Liegt ein 2-Bytefehler vor, gilt $$s_1\cdot \sigma {\left(2\right)}_2+s_2\left(2\right)\cdot \sigma {\left(2\right)}_1+s_3=0.$$

  
• Dies ergibt sich aus: $$s_1=a+b,$$

  

  $$s_2={\alpha }_1\cdot a+{\alpha }_2\cdot b,$$

  

  $$s_3={\alpha }_1^2\cdot a+{\alpha }_2^2\cdot b,$$

  

  $$\sigma {\left(2\right)}_2={\alpha }_1\cdot {\alpha }_2,$$

  

  $$\sigma {\left(2\right)}_1={\alpha }_1+{\alpha }_2.$$

  
• Dabei sind a und b die entsprechenden Bytefehlerwerte und α₁ und α₂ die Bytefehlerpositionen. Gilt die Gleichung (29), dann liegt kein 3-Bytefehler vor.
• Liegt nun ein 3-Bytefehler mit den Bytefehlerwerten a, b und c und den Bytefehlerpositionen α₁, α₂ und α₃ vor, dann gilt: $$s_1=a+b+c,$$

  

  $$s_2={\alpha }_1\cdot a+{\alpha }_2\cdot b+{\alpha }_3\cdot c,$$

  

  $$s_3={\alpha }_1^2\cdot a+{\alpha }_2^2\cdot b+{\alpha }_3^2\cdot c,$$

  

  $$\sigma {\left(2\right)}_2={\alpha }_1\cdot {\alpha }_2,$$

  

  $$\sigma {\left(2\right)}_1={\alpha }_1+{\alpha }_2$$

  
• Hieraus ergibt sich: $$\begin{array}{c}{s}_1\cdot \sigma {\left(2\right)}_2+s_2\cdot \sigma {\left(2\right)}_1+s_3=c\cdot \left({\alpha }_1{\alpha }_2+{\alpha }_1{\alpha }_3+{\alpha }_2{\alpha }_3+{\alpha }_3^2\right)=\\ =c\cdot \left({\alpha }_1+{\alpha }_3\right)\cdot \left({\alpha }_2+{\alpha }_3\right)=D.\end{array}$$

  
• Ein Wert D = 0 ist nur möglich, wenn (mindestens) eine der folgenden Bedingungen erfüllt ist:
• - c = 0;
• - α₃ = α₁ oder α₃ = α₂, was im Widerspruch dazu steht, dass die Bytefehlerpositionen α₁, α₂ und α₃ unterschiedlich sind.
• Somit kann ein 3-Bytefehler an der Gültigkeit der Ungleichung $$s_1=\sigma {\left(2\right)}_2+s_2\sigma {\left(2\right)}_1+s_3\ne 0$$

  

  erkannt werden.
• Liegt nun ein 3-Bytefehler vor, dann kann die dritte Bytefehlerposition α₃ unter Verwendung der bekannten Bytefehlerpositionen α₁, α₂ und aus den Syndromkomponenten s₁, s₂, s₃ und s₄ gemäß der Beziehung $$s_1\cdot \sigma {\left(3\right)}_3+s_2\cdot \sigma {\left(3\right)}_2+s_3\cdot \sigma {\left(3\right)}_1=s_4$$

  

  bestimmt werden, wobei $$\sigma {\left(3\right)}_3={\alpha }_1\cdot {\alpha }_2\cdot {\alpha }_3,$$

  

  $$\sigma {\left(3\right)}_2={\alpha }_1\cdot {\alpha }_2+{\alpha }_1\cdot {\alpha }_3+{\alpha }_2\cdot {\alpha }_3,$$

  

  $$\sigma {\left(3\right)}_1={\alpha }_1+{\alpha }_2+{\alpha }_3$$

  

  gilt. Die Bytefehlerposition α₃ ist die fehlerhafte zu bestimmende weitere (d.h. zusätzliche) Bytefehlerposition. Aus Gleichung (30) ergibt sich $$\begin{array}{c}{s}_4=s_1\cdot {\alpha }_1{\alpha }_2{\alpha }_3+s_2\cdot \left({\alpha }_1{\alpha }_2+{\alpha }_1{\alpha }_3+{\alpha }_2{\alpha }_3\right)+s_3\cdot \left({\alpha }_1+{\alpha }_2+{\alpha }_3\right)=\\ =s_1\cdot \sigma {\left(2\right)}_2{\alpha }_3+s_2\cdot \left[\sigma {\left(2\right)}_1\cdot {\alpha }_3+\sigma {\left(2\right)}_2\right]+s_3\cdot \left[\sigma {\left(2\right)}_1+{\alpha }_3\right]\end{array}$$

  

  und damit für die zu bestimmende Bytefehlerposition α₃: $${\alpha }_3=\frac{s_4+s_3\cdot \sigma {\left(2\right)}_1+s_2\cdot \sigma {\left(2\right)}_2}{s_3+s_2\cdot \sigma {\left(2\right)}_1+s_1\cdot \sigma {\left(2\right)}_2}=\frac{s_4+s_3\cdot \left[{\alpha }_1+{\alpha }_2\right]+s_2\cdot {\alpha }_1{\alpha }_2}{s_3+s_2\cdot \left[{\alpha }_1+{\alpha }_2\right]+s_1\cdot {\alpha }_1{\alpha }_2}$$

  
• Die Bytefehlerposition α₃ ist aus den vier Syndromkomponenten s₁, s₂, s₃, s₄ sowie den symmetrischen Funktionen σ(2)₁, σ(2)₂, die aus den bekannten Bytefehlerwerten α₁ und α₂ hervorgehen, bestimmbar. Es ist nicht erforderlich, die Lösungen des entsprechenden Lokatorpolynoms (hier: dritten Grades) zu ermitteln oder mehr als vier Syndromkomponenten zu verwenden. Dies reduziert den Aufwand in erheblichem Maße.
• Weiterer (zusätzlicher) Bytefehler bei einer Vielzahl von Bytefehlern an unterschiedlichen gegebenen Bytefehlerpositionen
• Entsprechend lässt sich dieser Ansatz erweitern: Es kann eine weitere Bytefehlerposition bestimmt werden, wenn drei oder mehr Bytefehlerpositionen vorbekannt sind. Sind k Bytefehlerpositionen bekannt, so sind k + 2 Fehlersyndromkomponenten bekannt.
• Beispielsweise gelten für die zu bestimmenden Bytefehlerpositionen
• - α₄, wenn drei Bytefehlerpositionen α₁, ... , α₃ bekannt sind: $${\alpha }_4=\frac{s_5+s_4\sigma {\left(3\right)}_1+s_3\sigma {\left(3\right)}_2+s_2\sigma {\left(3\right)}_3}{s_4+s_3\sigma {\left(3\right)}_1+s_2\sigma {\left(3\right)}_2+s_1\sigma {\left(3\right)}_3};$$
  
• - α₅, wenn vier Bytefehlerpositionen α₁,..., α₄ bekannt sind: $${\alpha }_5=\frac{s_6+s_5\sigma {\left(4\right)}_1+s_4\sigma {\left(4\right)}_2+s_3\sigma {\left(4\right)}_3+s_2\sigma {\left(4\right)}_4}{s_5+s_4\sigma {\left(4\right)}_1+s_3\sigma {\left(4\right)}_2+s_2\sigma {\left(4\right)}_3+s_1\sigma {\left(4\right)}_4};$$
  
• - α₆, wenn fünf Bytefehlerpositionen α₁,...,α₅ bekannt sind: $${\alpha }_6=\frac{s_7+s_6\sigma {\left(5\right)}_1+s_5\sigma {\left(5\right)}_2+s_4\sigma {\left(5\right)}_3+s_3\sigma {\left(5\right)}_4+s_2\sigma {\left(5\right)}_5}{s_6+s_5\sigma {\left(5\right)}_1+s_4\sigma {\left(5\right)}_2+s_3\sigma {\left(5\right)}_3+s_2\sigma {\left(5\right)}_4+s_1\sigma {\left(5\right)}_5};$$
  
• - α₇, wenn sechs Bytefehlerpositionen α₁,...,α₆ bekannt sind: $${\alpha }_7=\frac{s_8+s_7\sigma {\left(6\right)}_1+s_6\sigma {\left(6\right)}_2+s_5\sigma {\left(6\right)}_3+s_4\sigma {\left(6\right)}_4+s_3\sigma {\left(6\right)}_5+s_2\sigma {\left(6\right)}_6}{s_7+s_6\sigma {\left(6\right)}_1+s_5\sigma {\left(6\right)}_2+s_4\sigma {\left(6\right)}_3+s_3\sigma {\left(6\right)}_4+s_2\sigma {\left(6\right)}_5+s_1\sigma {\left(6\right)}_6}.$$
  
• Allgemein ergibt sich für N₁ bekannte Bytefehlerpositionen α₁,...,α_N1 die weitere Bytefehlerposition α_N1+1 zu: $${\alpha }_{N_1+1}=\frac{s_{N_1+2}+s_{N_1+1}\sigma {\left(N_1\right)}_1+s_{N_1}\sigma {\left(N_1\right)}_2+\dots +s_2\sigma {\left(N_1\right)}_{N_1}}{s_{N_1+1}+s_{N_1}\sigma {\left(N_1\right)}_1+s_{N_1-1}\sigma {\left(N_1\right)}_2+\dots +s_1\sigma {\left(N_1\right)}_{N_1}}.$$

  
• Hierbei kann es vorteilhaft sein, die nachfolgenden symmetrischen Funktionen σ(j)_i, mit j ≥ 1 und i ≤ j zu verwenden: Die Funktion σ(j)_i ergibt sich für j > 1 aus den Funktionen σ(j - 1)_k mit k ≤ j - 1 und einer weiteren Variablen α_k: $$\sigma {\left(2\right)}_1=\sigma {\left(1\right)}_1+{\alpha }_2$$

  

  $$\sigma {\left(2\right)}_2=\sigma {\left(1\right)}_1\cdot {\alpha }_2$$

  

  $$\sigma {\left(3\right)}_1=\sigma {\left(2\right)}_1+{\alpha }_3$$

  

  $$\sigma {\left(3\right)}_2=\sigma {\left(2\right)}_1\cdot {\alpha }_3+\sigma {\left(2\right)}_2$$

  

  $$\sigma {\left(3\right)}_3=\sigma {\left(2\right)}_2\cdot {\alpha }_3$$

  

  $$\sigma {\left(4\right)}_1=\sigma {\left(3\right)}_1+{\alpha }_4$$

  

  $$\sigma {\left(4\right)}_2=\sigma {\left(3\right)}_1\cdot {\alpha }_4+\sigma {\left(3\right)}_2$$

  

  $$\sigma {\left(4\right)}_3=\sigma {\left(3\right)}_2\cdot {\alpha }_4+\sigma {\left(3\right)}_3$$

  

  $$\begin{array}{c}\sigma {\left(4\right)}_4=\sigma {\left(4\right)}_3\cdot {\alpha }_4\\ ⋮\end{array}$$

  

  $$\sigma {\left(n+1\right)}_1=\sigma {\left(n\right)}_1+{\alpha }_{n+1}$$

  

  $$\sigma {\left(n+1\right)}_2=\sigma {\left(n\right)}_1\cdot {\alpha }_{n+1}+\sigma {\left(n\right)}_2$$

  

  $$\begin{array}{l}\sigma {\left(n+1\right)}_3=\sigma {\left(n\right)}_2\cdot {\alpha }_{n+1}+\sigma {\left(n\right)}_3\\ ⋮\end{array}$$

  

  $$\sigma {\left(n+1\right)}_{n+1}=\sigma {\left(n\right)}_n\cdot {\alpha }_{n+1}$$

  
• Somit können aus bereits ermittelten symmetrischen Funktionen σ(j)_i und einer zusätzlichen Variablen schrittweise weitere symmetrische Funktionen bestimmt und zur Ermittlung der weiteren Bytefehlerposition genutzt werden.
• Beispielhafte Implementierung
• 2 zeigt eine symbolische Anordnung, z.B. als Realisierung einer Schaltung, die es ermöglicht, die symmetrischen Funktionen σ(2)₁ = α₁ + α₂ und σ(2)₂ = α₁ · α₂ anhand der Bytefehlerpositionen α₁ und α₂ zu bestimmen.
• Ein Addierglieder 21 mit zwei m-Bit breiten Eingängen und einem m-Bit breiten Ausgang ermöglicht die komponentenweisen Addition modulo-2 (XOR-Verknüpfung) der an den Eingängen anliegenden Bytefehlerpositionen α₁ und α₂. Ein Galoisfeldmultiplizierer 22 mit zwei m-Bit breiten Eingängen und einem m-Bit breiten Ausgang ermöglicht die Multiplikation α₁ · α₂.
• 3 zeigt eine beispielhafte Schaltungsanordnung zur Bestimmung einer Bytefehlerposition α₃ unter Verwendung der Syndromkomponenten s₁ bis s₄ und zweier bekannter Bytefehlerpositionen α₁, α₂ entsprechend Gleichung (31). Die Bytefehlerpositionen α₁, α₂ wurden hierbei gemäß der in 2 gezeigten Anordnung zu den symmetrischen Funktionen σ(2)₁ und σ(2)₂ verknüpft, die Eingangssignale der in 3 gezeigten Anordnung sind.
• 3 weist Galoisfeldmultiplizierer 11 bis 15 auf, mit zwei m-Bit breiten Eingängen und einem m-Bit breiten Ausgang. Weiterhin sind zwei Addierglieder 16, 17 mit zwei m-Bit breiten Eingängen und einem m-Bit breiten Ausgang zur komponentenweisen Addition modulo-2 (XOR-Verknüpfung) sowie ein Invertierer 18 mit einem m-Bit breiten Eingang und einem m-Bit breiten Ausgang dargestellt. Die Komponenten 11 bis 18 sind derart angeordnet, dass sich aus ihrer Verschaltung im Ergebnis die Bytefehlerposition α₃ ergibt.

Claims (15)

1. Verfahren zur Fehlerverarbeitung, - wobei n Bytefehlerpositionen von n Bytefehlern vorgegeben sind, wobei n eine positive ganze Zahl ist, - bei dem bestimmt wird, ob es eine weitere Bytefehlerposition gibt anhand der n Bytefehlerpositionen und anhand von n + 1 Fehlersyndromkomponenten eines ersten Fehlercodes.
2. Verfahren nach Anspruch 1, bei dem die weitere Bytefehlerposition durch die n Bytefehlerpositionen und die n + 1 Fehlersyndromkomponenten des ersten Fehlercodes bestimmt wird.
3. Verfahren nach einem der vorhergehenden Ansprüche, bei dem der erste Fehlercode ein Bytefehlercode, insbesondere ein Reed-Solomon-Code ist.
4. Verfahren nach einem der vorhergehenden Ansprüche, bei dem erkannt wird, dass kein weiterer Bytefehler vorhanden ist, falls keine weitere Bytefehlerposition bestimmbar ist.
5. Verfahren nach einem der vorhergehenden Ansprüche, bei dem die weitere Bytefehlerposition in Abhängigkeit mindestens einer symmetrischen Funktion der n Bytefehlerpositionen bestimmt wird.
6. Verfahren nach einem der Ansprüche 1 bis 5, bei dem - im fehlerfreien Fall ein Byte des ersten Fehlercodes in ein Codewort eines zweiten Fehlercodes transformiert wird, - eine Bytefehlerposition bestimmt wird, falls ein Nicht-Codewort des zweiten Fehlercodes erkannt wird.
7. Verfahren nach Anspruch 6, bei dem der zweite Fehlercode ein n₁-aus-n-Code ist, wobei 1 ≤ n₁ < n ≤ 2 gilt.
8. Verfahren nach einem der Ansprüche 6 oder 7, bei dem Codewörter des zweiten Fehlercodes in einem Speicher gespeichert werden.
9. Verfahren nach Anspruch 8, bei dem im fehlerfreien Fall Codewörter des zweiten Fehlercodes aus dem Speicher ausgelesen und in Bytes des ersten Fehlercodes zurücktransformiert werden.
10. Verfahren nach Anspruch 9, bei dem das Auslesen aus dem Speicher unter Berücksichtigung einer zeitlichen Reihenfolge erfolgt.
11. Verfahren nach einem der Ansprüche 5 bis 9, bei dem dann, wenn beim Auslesen aus dem Speicher ein Nicht-Codewort des zweiten Fehlercodes erkannt wird, eine Bytefehlerposition für dieses Byte des ersten Fehlercodes bestimmt wird.
12. Verfahren nach einem der vorhergehenden Ansprüche, bei dem die weitere Bytefehlerposition α₂ bestimmbar ist, so dass gilt: $${\alpha }_2=\frac{s_3+s_2\cdot {\alpha }_1}{s_1\cdot {\alpha }_1+s_2},$$

    

    wobei α₁ die vorgegebene Bytefehlerposition und s₁, s₂, s₃ Syndromkomponenten bezeichnen.
13. Vorrichtung zur Fehlerverarbeitung, die eingerichtet ist zu bestimmen, ob es eine weitere Bytefehlerposition gibt anhand von n Bytefehlerpositionen und anhand von n + 1 Fehlersyndromkomponenten eines ersten Fehlercodes, wobei die n Bytefehlerpositionen von n Bytefehlern vorgegeben sind und wobei n eine positive ganze Zahl ist.
14. Vorrichtung nach Anspruch 13, die ferner eingerichtet ist, die weitere Bytefehlerposition durch die n Bytefehlerpositionen und die n + 1 Fehlersyndromkomponenten des ersten Fehlercodes zu bestimmen.
15. Schaltungsanordnung umfassend mindestens eine Vorrichtung nach einem der Ansprüche 13 oder 14.

Images