DE69121307T2

DE69121307T2 - Mehrfachpegel-Fehlerkorrektursystem

Info

Publication number: DE69121307T2
Application number: DE69121307T
Authority: DE
Inventors: Lih-Jyh Weng
Original assignee: Quantum Corp
Current assignee: Quantum Corp
Priority date: 1990-05-09
Filing date: 1991-04-26
Publication date: 1997-01-23
Anticipated expiration: 2011-04-27
Also published as: US5224106A; EP0458468B1; DE69121307D1; EP0458468A1; CA2041214A1; JPH04230124A

Description

GEBIET DER ERFINDUNG

Die Erfindung bezieht sich allgemein auf eine Fehlerkorrektur von Daten und insbesondere auf verbesserte Techniken zum Mehrfachpegelcodieren und -decodieren.

HINTERGRUND

Die Bedeutung eines Fehlerkorrekturcodierens von Daten in digitalen Computersystemen hat stark zugenommen, da die Dichte der Daten, die auf Massenspeichermedien aufgezeichnet sind, insbesondere auf Magnetplatten, ange wachsen ist. Mit höheren Auf zeichnungsdichten kann ein winziger Fehler in der Aufzeichnungsfläche einer Platte eine große Datenmenge verderben. Um einen Verlust jener Daten zu vermeiden, werden Fehlerkorrekturcodes ("ECC's") verwendet, um, wie der Name zeigt, die fehlerhaften Daten zu korrigieren.
Bevor eine Folge von Datensymbolen auf einer Platte aufgezeichnet wird, wird sie mathematisch codiert, um ECC- oder Redundanz-Symbole zu bilden. Die Redundanzsymbole werden dann der Datenfolge beigefügt, um Codewörter - Datensymbole plus Redundanzsymbole - zu bilden, und die Codewörter werden dann auf der Platte gespeichert. Wenn auf die gespeicherten Daten von der Platte zugegriffen wird, werden die Codewörter, die die Datensymbole enthalten, von der Platte wiedergewonnen und mathematisch decodiert. Während eines Decodierens werden jegliche Fehler in den Daten erfaßt und, falls möglich, durch Manipulation der Redundanzsymbole korrigiert (für eine Detailbeschreibung des Decodierens siehe Peterson und Weldon, Error Correcting Codes, 2. Ausgabe, MIT Press, 1972).
Gespeicherte digitale Codewörter können Mehrfachfehler enthalten. Einer der wirksamsten Typen von ECC, der für die Korrektur von Mehrfachfehlern verwendet wird, ist ein Reed-Solomon-Code (für eine Detailbeschreibung der Reed-Solomon-Codes siehe Peterson und Weldon, Error Correcting Codes). Fehlererfassungs- und Korrekturtechniken für Reed-Solomon-ECC's sind wohlbekannt. Siehe oben. Eine derartige Technik beginnt wieder mit einem Codieren der Codewortdaten, um einen neuen Satz von Redundanzsymbolen zu erzeugen, und dann mit dem Vergleichen dieses Satzes von Redundanzsymbolen mit den Redundanzsymbolen in dem wiedergewonnenen Codewort, d.h. dem Satz von Redundanzsymbolen, die durch das Vorspeichercodieren der Daten erzeugt sind, um jegliche Fehler in dem wiedergewonnenen Codewort zu erfassen (für eine Detaildiskussion dieser Fehlererfassungstechnik siehe US-PS 4 413 339, herausgegeben für Riggle und Weng).
Fehler in gespeicherten Daten treten oft in Mustern auf, wie beispielsweise in Mehrsymbol-Impulsstößen. Derartige Fehler können beispielsweise durch eine Mangelhaftigkeit in dem Aufzeichnungsmedium verursacht sein. Verschiedene Codier- und Decodierschemen wurden entwickelt, um gemeinsame Fehlermuster zu korrigieren. Ein für Impulsstöße bzw. Bursts entwickeltes Schema ist ein Verzahnen. Ein Verzahnen umfaßt ein Trennen der Daten in eine Anzahl von Abschnitten und mittels eines ECC ein getrenntes Codieren jedes Abschnittes, um ein Codewort zu bilden. Jedes Codewort enthält so einen Abschnitt der Daten und einen betreffenden Satz von Redundanzsymbolen. Die verzahnten Daten und die Redundanzsymbole von allen Abschnitten werden dann aufgezeichnet. In typischer Weise werden die verzahnten Datensymbole kontinuierlich aufgezeichnet, woran sich die Redundanzsymbole anschließen. Burstfehler, die eine Anzahl von kontinuierlichen (verzahnten) Datensymbolen beeinträchtigen, verursachen eine kleine Anzahl von Fehlern in jedem von verschiedenen Codewörtern. Wenn die Daten und Redundanzsymbole später wiedergewonnen werden, werden die verschiedenen Sätze von Redundanzsymbolen verwendet, um Fehler in den Datenabschnitten zu korrigieren, die diesen zugeordnet sind. Somit schützt ein gegebener Satz von Redundanzsymbolen einen Teil der Daten und korrigiert vermutlich lediglich einen Teil von jedem beliebigen Fehlerburst. Demgemäß kann ein ECC, der ausgelegt ist, um "x" fehlerhafte Symbole zu korrigieren, Bursts bzw. Impulsstöße korrigieren, die länger als x Symbole sind, indem diese Abschnitt für Abschnitt korrigiert werden. Der für ein solches Schema ausgewählte ECC kann weniger leistungsvoll sein als ein solcher, der Burstfehler korrigieren muß, ohne diese zu teilen. Die Vorteile des Verwendens eines weniger leistungsvollen ECC sind eine einfachere Codier/Decodier- Hardware und (typischerweise) eine raschere Korrektur (für eine Detailbeschreibung des Verzahnungscodierens, siehe Peterson und Weldon, Error Correcting Codes)
Ein anderes Schema, das verwendet wird, um gemeinsame Fehlermuster zu korrigieren, ist ein Mehrfachpegel- Codieren. Ein Mehrfachpegel-Codieren umfaßt ein einmaliges Codieren von Daten unter Verwendung eines ECC und/oder einer Technik, die ausgelegt ist, um die meisten gemeinsamen Fehlermuster zu korrigieren, und dann ein Codieren der Daten zu einer nächsten Zeit, wobei ein anderer ECC und/oder eine Technik verwendet wird, die ausgelegt ist, um die nächsten am meisten gemeinsamen Fehlermuster zu korrigieren, und so weiter. Ein Mehrpegeldecodieren umfaßt ein Codieren der Daten mittels des ersten Pegel-ECC oder einer Technik, und, falls Fehler dann zurückbleiben, ein Korrigieren von diesen mittels des zweiten Pegel-ECC oder einer Technik, und so weiter.
Beispielsweise kann ein erster Pegel des Codierens aus einem Codieren der Daten mit einem relativ schwachen ECC bestehen. Ein zweiter Pegel des Codierens kann aus einem erneuten Codieren der Daten mit einem leistungsvolleren ECC bestehen. Ein derartiges Zweipegel-Schema ist in den US-Patenten 4 706 250 und 4 525 838 für Patel offenbart. Das in den beiden Patenten offenbarte Patel-Schema codiert zuerst die Daten mittels eines ECC, der ea-Fehler korrigiert. Patel trennt einen Block von Daten in "i" Abschnitte oder Unterblöcke von jeweils kl Symbolen und codiert getrennt jeden k-Symbolabschnitt mittels eines ersten ECC. Dieser Pegel des Codierens erzeugt "p" Redundanzsymbole für jeden Datenabschnitt oder eine Gesamtsumme von "ip" Reundanzsymbolen.
Patel addiert sodann die entsprechenden Datensymbole in jedem Unterblock zusammen (exklusive ODER) und behandelt die sich ergebenden k Symbole als einen zusätzlichen "Daten"-Abschnitte. Patel codiert dann diese Symbole mittels eines leistungsvolleren ECC, der bis zu eb Fehler korrigieren kann (eb ≥ ea). Dieses zweite Codieren erzeugt "s" zusätzliche Redundanzsymbole. Patel speichert die Daten und die ip und s Redundanzsymbole, das heißt, die Redundanzsymbole, die während der zwei Pegel des Codierens erzeugt sind. Er speichert nicht die k zusätzlichen "Daten" Symbole. Das Patel-Schema kann bis zu ea Fehler in jedem Unterblock mittels des ersten Pegels oder eines Pegels-1, ECC und bis zu eb Fehler in jeglichem einen Unterblock mittels des Pegels-2 ECC korrigieren. Demgemäß versucht Patel zuerst jeglichen Fehler in den Daten mittels des Pegels-1 ECC zu korrigieren. Wenn alle Fehler mittels dieses ECC korrigiert werden, stoppt er die Fehlerkorrektur-Decodieroperation und verwendet nicht den Pegel-2 ECC. Wenn alle bis auf einen Unterblock korrigiert sind, wird der Pegel-2 Code in einem Versuch, diesen zu korrigieren, verwendet. Patel unterwirft so die entsprechenden Datensymbole einer exklusiven ODER-Verknüpfung in jedem Abschnitt, der die Symbole, die mittels des Pegels-1 ECC korrigiert sind, und die fehlerhaften Symbole, die der Pegel-1 Code nicht korrigierte enthält, um k "Daten" -Symbole zu bilden, die dem k-Symbol-Zusatzdatenabschnitt entsprechen, der während des Codierens erzeugt ist. Patel versucht sodann, die Fehler in diesen k-Symbolen mittels des Pegels-2 Code zu korrigieren.
Wenn dort eb oder weniger Fehler vorliegen, bestimmt der Pegel-2 Code die Stellen der fehlerhaften Symbole innerhalb des k-Symbol-"Daten"-Abschnittes und erzeugt die zugeordneten Fehlerwerte, das heißt, die Symbole, die exklusiv ODER-verknüpft werden müssen mit den fehlerhaften Symbolen, um diese zu korrigieren. Patel übersetzt die Fehlerstellen zu dem Unterblock, der die Fehler enthält, und korrigiert diese mittels der erzeugten Fehlerwert symbole.
Wenn die Daten mehr als eb Fehler je Unterblock oder mehr als einen Unterblock mit mehr als ea Fehler enthalten, kann das Patel-Schema die Fehler nicht korrigieren. Somit ist es wünschenswert, da mehr Fehler infolge gesteigerter Aufzeichnungsdichten auftreten, ein Fehlerkorrekturschema zu verwenden, das fähig ist, eine größere Anzahl von Fehlern zu korrigieren.
Eine Lösung besteht darin, ein leistungsvolleres ECC bei jedem Pegel zu verwenden. Dies ruft drei Probleme hervor. Zunächst erzeugen die leistungsvolleren ECCs zusätzliche Redundanzsymbole. Somit muß mehr Speicherraum den Daten zugeordnet werden, und weniger Daten können in einem gegebenen Speicherraum aufgezeichnet werden. Zweitens erfordern die leistungsvolleren ECCs eine komplexere und somit aufwendigere Codier- und Decodier-Hardware und/oder Software. Drittens erfordern die ECCs mehr Zeit zum Korrigieren der Fehler als die ECCs, die weniger Redundanzsymbole verwenden.
Da Datenübertragungstechnologien verbessert sind und die Geschwindigkeit, mit der Daten von einer Platte wiedergewonnen werden können, zunimmt, wirkt ein langsamerer und mehr komplexer ECC als eine Grenze für die Geschwindigkeit, mit der Daten übertragen werden können. Demgemäß ist das, was benötigt wird, ein leistungsvolleres Codierschema, das rasch Fehler korrigieren kann, das einfach ausgeführt ist und das nicht übermäßige Größen an Speicherraum erfordert.

ZUSAMMENFASSUNG

Die Erfindung ist ein Mehrfachpegel-Codierschema, das höhere Pegel des Codierens der Redundanzsymbole verwendet, die während eines ersten Pegels des Codierens erzeugt sind, so daß alle Pegel zusammen ein leistungsvolles und rasches Fehlerkorrekturschema bilden. Das Mehrfachpegel-Codierschema braucht nicht alle Redundanzsymbole zurückhalten, da diese Symbole aus einer gewählten Anzahl von zurückgehaltenen Symbolen regeneriert werden können, wie dies unten beschrieben ist.
Ein System, das das erfindungsgemäße Mehrfachpegel- Codierschema verwendet, trennt zuerst die Daten in "i" Abschnitte von jeweils "k" Symbolen oder i Unterblöcken und codiert jeden Unterblock mittels eines (n,k) ECC. Die Datensymbole können oder können nicht verzahnt sein. Dieser erste Pegel des Codierens erzeugt für alle k Datensymbole ein "n" Symbolcodewort, das "n-k" oder "r" Redundanzsymbole oder insgesamt "ri" Redundanzsymbole enthält.
Das System segmentiert sodann die ri Redundanzsymbole in m" Mehrfachsymbolabschnitte, insbesondere R(1) R(m), die entsprechende Symbole von jedem der i Codewörter enthalten. Das System codiert sodann jeden dieser Abschnitte mittels entweder des gleichen ECC oder vorzugsweise ECCs einer abnehmenden Stärke. Somit codiert es beispielsweise ein erstes Redundanzsymbole Wj+1 von jedem der i Pegel-1 Codewörter und erzeugt q&sub2; Redundanzsymbole, wobei die Wj+1 Redundanzsymbole und die zu q&sub2; erzeugte Redundanz ein Pegel-2 Codewort bilden. Sodann codiert es ein zweites Redundanzsymbol wj+2 von jedem der i Codewörter und erzeugt andere q&sub2; Redundanzsymbole, die ein zweites Pegel-2 Codewort bilden, und so weiter. Die Pegel-2 Redundanzsymbole entsprechend den verschiedenen Abschnitten R(2) ... R(m) sind jeweils in Abschnitten Q(2), ... Q(m). Das System speichert sodann die Daten, die Redundanzsymbole des Abschnittes R(1) und die Redundanzsymbole der Abschnitte Q(2), ..., Q(m) . Es speichert jedoch nicht die Redundanzsymbole in Abschnitten R(2), ..., R(m), da diese Symbole mittels der aufgezeichneten R(1) und Q(2), ..., Q(m) Redundanzsymbole regeneriert werden können.
Wenn Daten aus der Speicherung wiedergewonnen werden, werden sie Codewort für Codewort mittels des Pegel-1 ECC decodiert. Das System verwendet die wiedergewonnenen Abschnitt R(1) Symbole als Redundanzsymbole und behandelt die "fehlenden" Abschnitt R(2) ... R(m) Symbole als Löschsymbole. Der Pegel-1 ECC wird so verwendet, um die Redundanzsymbole in Abschnitte R(2), ..., R(m) für jedes Pegel-1 Codewort zu füllen, und auch, um, falls möglich, jegliche Fehler in den wiedergewonnenen Daten und den Abschnitt R(1) Redundanzsymbolen zu korrigieren. Wenn das Pegel-1 Decodieren nicht alle die Fehler und Löschungen mittels lediglich der wiedergewonnenen Abschnitt R(1) Symbole als Redundanzsymbole korrigiert, verwendet das System die Abschnitt Q(2) Redundanzsymbole und den Pegel-2 ECC, um die fehlenden Abschnitt R(2) Redundanzsymbole zu füllen. Sodann versucht das System, die entsprechenden Pegel-1 Codewörter mittels des Pegel-1 ECC und der wiedergewonnenen und eingefüllten Redundanzsymbole in Abschnitten R(1) und R(2) zu korrigieren. Falls notwendig füllt das System in jegliche unkorrigierte Redundanzsymbole in dem nächsten Abschnitt, d.h. dem Abschnitt R(3) mittels der Abschnitt Q(3) Symbole und des Pegel-3 ECC. Es verwendet dann den Pegel-1 ECC und die Redundanzsymbole in Abschnitten R(1), R(2) und R(3), um mehr Fehler in den Daten zu korrigieren, und so weiter.

KURZBESCHREIBUNG DER ZEICHNUNGEN

Die obigen und weitere Vorteile der Erfindung können unter Bezugnahme auf die folgende Beschreibung in Zusammenhang mit den begleitenden Zeichnungen besser verstanden werden, in welchen:
Fig. 1 ein Blockdiagramm von verzahnten Codewörtern ist, die gemäß einem ersten Pegel eines Codierens erzeugt sind,
Fig. 2 ein Blockdiagramm der Codewörter von Fig. 1 ist, die weiter mittels eines zweiten und dritten Pegels des Codierens codiert sind,
Fig. 3 ein Blockdiagramm von Teilen der Codewörter von Fig. 2 ist, die in einem Speicher rückgehalten sind,
Fig. 4 ein Blockdiagramm von wiedergewonnenen Codewörtern einschließlich regenerierter Redundanzsymbole ist,
Fig. 5 ein Blockdiagramm eines Codiersystemes ist, das Daten codiert, um Codewörter gemäß einem zweiten Ausführungsbeispiel der vorliegenden Erfindung zu bilden, und
Fig. 6 ein Blockdiagramm der Codewörter ist, die durch den in Fig. 5 gezeigten Codierer erzeugt sind.

DETAILBESCHREIBUNG

In Fig. 1 erzeugt ein (nicht gezeigtes) System eine Folge von "ki" Datensymbolen in "i" Abschnitten oder Unterblöcken von jeweils "k" Symbolen. Das System kann zuerst die ki Datensymbole verzahnen. Diese i Abschnitte sind als Spalten 10 in der Zeichnung angeordnet. Das System führt ein erstes Pegelcodieren mittels eines (n,k) ECC und herkömmlicher Techniken durch und codiert jeden Abschnitt der Daten, um ein Pegel-1 Codewort aus k Datensymbolen und "n-k" oder "r" Redundanzsymbolen zu bilden. Die Codewörter entsprechen Spalten c&sub1;, c&sub2;, ci der Anordnung in der Zeichnung. Das System erzeugt so "ri" Redundanzsymbole in dem ersten Pegel des Codierens.
Das System segmentiert sodann die ri Redundanzsymbole in m Abschnitte 12-16, R(1), R(2), ..., R(m) einer willkürlichen Größe, wobei m=3 beispielhaft ist. Jeder Abschnitt enthält vorzugsweise wenigstens zwei Redundanzsymbole, was die Anzahl von Symbolen ist, die erforderlich ist, um ein fehlerhaftes Datensymbol zu korrigieren. Somit enthält jeder Abschnitt 12-16 wenigstens zwei Reihen in der in der Zeichnung herausgegriffenen Anordnung.
In der Fig. 2 codiert nunmehr das System die Symbole in Abschnitt R(2) mittels eines zweiten Pegels des Codierens. Es codiert so als "Informations"-Symbole die entsprechenden Redundanzsymbole von jedem der i Codewörter, das heißt, jeder Reihe "Wa" des Abschnittes R(2) mittels eines zweiten ECC. Dieser zweite Pegel des Codierens erzeugt für jede Reihe Wj+1 Wp des Abschnittes R(2) "q&sub2;" Redundanzsymbole. Jede Reihe aus i Informationssymbolen und q&sub2; Redundanzsymbolen bildet ein Pegel-2-Codewort. Das System erzeugt so in diesem Pegel des Codierens eine Gesamtsumme von (p-j+1)q&sub2; Redundanzsymbolen. Diese Symbole sind als Abschnitt Q(2) in der Zeichnung angegeben. Im allgemeinen ist die Anzahl der Symbole in Abschnitt Q(2) < als die Anzahl der Symbole in Abschnitt R(2).
Das System führt sodann einen dritten Pegel des Codierens durch, indem die Symbole in ähnlicher Weise in Abschnitt R(3) codiert werden. Es codiert so die entsprechenden Redundanzsymbole von jedem der i Codewörter mittels eines ECC der vorzugsweise weniger leistungsvoll als der Pegel-2 Code ist. Der dritte Pegel des Codierens erzeugt für jede Reihe Wj+1, Wj+2 ... wr des Abschnittes R(3) "q&sub3;" Redundanzsymbole. Jede Reihe, die aus i "Informations"-Symbolen und q&sub3; Redundanzsymbolen besteht, bildet ein Pegel-3 Codewort. Das System erzeugt so in diesem Pegel des Codierens eine Gesamtsumme von (r-p+1)q&sub3; Redundanzsymbolen. Diese Symbole sind als Abschnitt Q(3) in der Zeichnung angegeben. Im allgemeinen ist die Anzahl der Symbole in Abschnitt Q(3) ( als die Anzahl der Symbole in Abschnitt R(3)
In Fig. 3 speichert das System nunmehr in einem (nicht gezeigten) Speicher die ki Datensymbole und die Redundanzsymbole für Abschnitt R(1), Q(2) und Q(3). Es speichert jedoch nicht die Redundanzsymbole für Abschnitt R(2) und R(3), da diese Symbole mittels der gespeicherten Redundanzsymbole für Abschnitt R(1), Q(2) und Q(3) regeneriert werden können, wie dies unten erläutert ist. Die Symbole für Abschnitt R(2) und R(3) werden so absichtlich "gelöscht". Jedes der gelöschten Symbole wird während eines Decodierens als eine Löschung behandelt, das heißt, als ein Fehler mit einer bekannten Stelle.
Bei Bedarf kann das System auch die Redundanzsymbole für die gespeicherten Abschnitte R(1), Q(2) ... Q(m) mittels eines oder mehrerer ECCs codieren, die Redundanzsymbole ECK(1), ECK(2) und ECK(3) erzeugen. Diese Symbole werden dann längs der Daten und der Symbole für den Abschnitt R(1), Q(2) und Q(3) gespeichert. Während eines Decodierens können diese (bedarfsweise) Redundanzsymbole verwendet werden, um jegliche Fehler in den gespeicherten Redundanzsymbolen zu korrigieren, bevor die Redundanzsymbole verwendet werden, um die gelöschten Symbole zu regenerieren. Die bedarfsweisen Symbole sind so eine beigefügte Schutzschicht für die gespeicherten Symbole und die gelöschten Symbole.
Die Datensymbole werden durch m Pegel des Codierens geschützt. Der erforderliche Speicherraum für die m Pegel der Redundanzsymbole ist kleiner als der Raum, der für alle die ri Pegel-1 Redundanzsymbole erforderlich ist. Demgemäß bietet das Schema mehr Schutz als herkömmliche Mehrfachpegel-Codierschemas und verwendet weniger Speicherraum.
Wie für den Fachmann zu ersehen ist, können die Daten und Redundanzsymbole in jeglichem Format gespeichert oder aufgezeichnet werden. Das in den Figuren gezeigte Blockformat dient lediglich für Erläuterungszwecke.
Wenn die gespeicherte Information später wiedergewonnen wird, verwendet das System die wiedergewonnenen Redundanzsymbole für Abschnitt R(1), um für jedes Codewort die Pegel-1 Redundanzsymbole des "gelöschten" Abschnittes R(2) und R(3) mittels herkömmlicher Fehler- und Löschkorrekturtechniken zu regenerieren. Es verwendet auch die Redundanzsymbole für den Abschnitt R(1), um Fehler in den wiedergewonnenen Daten und Redundanzsymbolen zu korrigieren. Fig. 4 veranschaulicht einige regenerierte Spalten, beispielsweise c&sub1;, c&sub2;, usw.
Wenn das System nicht ein gültiges Codewort für einen besonderen Abschnitt von Daten, d.h. eine besondere Spalte, erzeugt, behandelt es die zugeordneten Symbole für Abschnitt R(2) und R(3) als Fehler mit bekannten Stellen, beispielsweise Spalten ce1, ce2 ... cef. Es decodiert dann jede Reihe des Abschnittes R(2) mittels der geeigneten Redundanzsymbole für Abschnitt Q(2) und des Pegel-2 ECC und füllt in den gelöschten Abschnitt R(2) Symbole in den Spalten ce1, ce2 ... cew wie dies geeignet ist. Das System versucht sodann, jegliche verbleibende Fehler in den wiedergewonnenen Daten und Abschnitt R(1) Symbole von diesen Spalten mittels des Pegel-1 ECC und der Redundanzsymbole des geeigneten Abschnittes R(1) und R(2) zu korrigieren.
Wenn das System nicht alle die Fehler korrigieren kann und alle die gelöschten Redundanzsymbole mittels des Pegel-1 ECC und der Redundanzsymbole der Abschnitte R(1) und R(2) regeneriert, verwendet es die Redundanzsymbole des Abschnittes Q(3) und den Pegel-3 ECC, um jegliche fehlende Symbole des Abschnittes R(3) zu füllen. Es verwendet dann diese eingefüllten Symbole und die Redundanzsymbole des Abschnittes R(1) und R(2) mit dem Pegel-1 ECC, um mehr Fehler zu korrigieren. Falls erforderlich und wenn mehr Pegel vorliegen, wiederholt das System die Korrekturprozedur für jeden derartigen Pegel.
Bevor das System die Symbole des gelöschten Abschnittes R(2) und R(3) regeneriert, verwendet es die bedarfsweisen bzw. fakultativen ECC-Symbole, falls welche vorhanden sind, um jegliche Fehler in den Redundanzsymbolen des wiedergewonnenen Abschnittes R(1), Q(2) und Q(3) zu korrigieren. Sodann führt das System die Pegel-1 Fehler- und Löschkorrektur durch, um die gelöschten Redundanzsymbole zu füllen und Fehler der wiedergewonnenen Daten in Redundanzsymbolen des Abschnittes R(1) zu korrigieren. Es folgt dann den Prozeduren, die oben erläutert sind, um die Fehler zu korrigieren.
Wenn das System seine höheren Pegel des Decodierens durchführt, begegnet es schlecht verdorbenen Daten. Das System kann so einem Systemoperator melden, daß die Daten schlecht verdorben sind, und der Systemoperator kann sodann das Aufzeichnungsmedium prüfen und die gespeicherten Daten retten, bevor sie unwiederbringbar verloren sind. Zum Stand der Technik zählende Systeme, die lediglich zwei Pegel des Decodierens verwenden, enthalten keine derartige Warnung vor verdorbenen Daten, und sie können so gegebenenfalls bei verdorbenen Medien Daten verlieren.
Die Fig. 5 und 6 veranschaulichen ein zweites Ausführungsbeispiel der vorliegenden Erfindung, das zusammen mit einem bestehenden Einpegel-Codiersystem verwendet werden kann. Das Einpegel-System codiert die ki Datensymbole, nachdem diese (fakultativ) verzahnt sind. Es codiert diese in k-Symbolabschnitten in einem Codierer 18, um Codewörter gemäß einem ECC zu bilden, der ein aufeinanderfolgendes Wurzelerzeugungspolynom g&sub1; (x) hat:
(x+αa)*(a+α+1)*(x+αa+2)*(x+αa+3)*... *(x+αa+s)
wobei * eine Galois-Feld-Multiplikation bedeutet und α ein primitives Polynom des Galois-Feldes GF(2t) ist, das zum Codieren der Daten verwendet wird.
Die Codewörter bestehen aus k Datensymbolen und s Redundanzsymbolen und sind als Spalten 10 in Fig. 6 angeordnet, wobei die si Redundanzsymbole für alle Codewörter als Abschnitt S(1) in den Zeichnungen eingetragen sind. Diese Codewörter werden sodann auf einen zweiten Codierer 20 für einen zweiten Pegel des Codierens angewandt. Dieser Pegel des Codierens ist einem ECC zugeordnet, der als ein Erzeugungspolynom g&sub2;(x) eine gedehnte Version von g&sub1;(x) hat:
Dieser zweite ECC ist leistungsvoller, das heißt, er korrigiert mehr Fehler in einer gegebenen Menge von Daten als der ECC, der einem g&sub1;(x) zugeordnet ist.
Die Datensymbole wurden bereits g&sub1;(x) durch den Einpegel-Codierer 18 codiert, um die Redundanzsymbole des Abschnittes S(1) zu erzeugen. Demgemäß werden die Codewort-Datensymbole und die S(1) Redundanzsymbole als Informationssymbole behandelt, und der zweite Codierer 20 codiert tatsächlich die Symbole gemäß den Faktoren g&sub2;(x), die nicht Teil von g&sub1;(x) sind. Somit codiert der Codierer 20 die Symbole gemäß einem Polynom g*&sub2;(x), was gleich ist zu g&sub2;(x)/g&sub1;(x). Dieses zweite Codieren erzeugt für jedes Codewort Redundanzsymbole, die als Abschnitt S(2) in Fig. 6 angegeben sind. Die Redundanzsymbole des Abschnittes S(2) allein liefern keinen angemessenen Fehlerschutz für die Daten, da das Polynom g&sub2;*(x), das verwendet wird, um diese zu erzeugen, nicht so viele aufeinanderfolgende Wurzeln in GF(2t) wie g&sub1;(x) zu haben braucht. Jedoch schützen die Symbole des Abschnittes S(2) zusammen mit den Symbolen des entsprechenden Abschnittes S(1) die Datensymbole mit einer relativ leistungsvollen ECC, der als ein Erzeugerpolynom g&sub2;(x) hat.
Dritte, vierte,.. m Pegel des Codierens können in der gleichen Weise durchgeführt werden. Ein dritter Pegel des Codierens verwendet beispielsweise ein Erzeugerpolynom g&sub3;*(x) = g&sub3;(x)/g&sub2;(x), wobei g&sub3;(x) eine gedehnte Version von g&sub2;(x) ist. Somit codieren Codierer für diese Pegel, beispielsweise ein Codierer 22 für ein m- Pegel-Codieren die Datensymbole und die entsprechenden Redundanzsymbole der Abschnitte S(1) ... S(m-1) gemäß einem Polynom g*m(x), das gleich ist zu dem Quotienten von gm(x), der die gedehnte Version von gm&sub1;(x) ist, geteilt durch das Erzeugerpolynom gm-1(x), das dem vorangehenden Pegel zugeordnet ist. Das Pegel-m- Erzeugerpolynom umfaßt so aufeinanderfolgende Wurzeln und schützt auch die Daten mit einem sogar leistungsvolleren ECC.
Die für jeden Pegel des Codierens erzeugten Redundanzsymbole sind in Abschnitten S(1) ... S(m) in Fig. 6 angegeben. Diese Redundanzsymbolabschnitte entsprechen dem Abschnitt R(1), R(2) ... R(m) von Fig. 2. Wieder in Fig. 6 werden die Redundanzsymbole in Abschnitten S(2) S(m), wobei m=3 in diesem Ausführungsbeispiel gilt, dann als Informationssymbole codiert, um das Redundanzsymbol zu erzeugen, das in Abschnitten Q(2) und Q(3) angegeben ist, wie dies oben anhand der Fig. 3 diskutiert ist.
Nachdem die Daten und Redundanzsymbole der Pegel-2 und 3 codiert wurden, um die Symbole zu erzeugen, die in Abschnitten Q(2) und Q(3) angegeben sind, codiert das System weiter die Redundanzsymbole in Abschnitten Q(2) und Q(3), indem ein oder mehrere ECCs verwendet werden, und erzeugt Redundanzsymbole ECK(2) und ECK(3). Das System speichert dann diese Redundanzsymbole zusammen mit den Datensymbolen, den Redundanzsymbolen des Abschnittes S(1) und den Redundanzsymbolen des Abschnittes Q(2) und Q(3). Es speichert jedoch nicht die Redundanzsymbole des Abschnittes S(2) und S(3), da diese Symbole mittels der gespeicherten Redundanzsymbole regeneriert werden können. Dieses zweite Ausführungsbeispiel unterscheidet sich vom ersten dadurch, daß das System Redundanzsymbole des Abschnittes Q(2) ... Q(m) codieren muß. Das System kann (fakultativ) die Symbole des Abschnittes S(1) codieren, um Symbole des Abschnittes ECK(1), wie in dem ersten Ausführungsbeispiel, zu bilden.
Die Datensymbole 10 werden durch alle m Pegel des Codierens geschützt. Der m-te Pegel schützt sie mittels gm(x), was ein viel leistungsvollerer ECC als derjenige ist, der im Pegel-1 verwendet ist, ohne die Speicherung der großen Anzahl von Redundanzsymbolen zu erfordern. Frühere Systeme benötigen für einen derartigen Schutz die Speicherung von allen Redundanzsymbolen von allen Pegeln des Codierens.
Ein Decodieren wird durch das System in Pegeln durchgeführt, wie dies oben anhand des ersten Ausführungsbeispiels diskutiert ist. Das System startet mit dem ECC des Pegels-1 und verwendet bei Bedarf höhere Pegel, um die gelöschten Symbole zu regenerieren und zusätzliche Fehler zu korrigieren. Jeder Pegel liefert einen viel leistungsvolleren Fehlerkorrekturmechanismus aufgrund der Verwendung eines Erzeugerpolynoms, das mehr Terme als der eine Term hat, der in dem früheren Pegel verwendet ist. Auch verwendet jeder Pegel Redundanzsymbole, die durch Codes gefüllt sind, welche einem geeigneten Abschnitt Q(2) ... Q(m) zugeordnet sind, und benutzt so fehlerfreie Redundanzsymbole. Demgemäß kann eine Korrektur relativ rasch durchgeführt werden.
Das erfindungsgemäße Mehrfachpegel-Codierschema schützt Datensymbole mit leistungsvolleren ECCs, ohne, wie bei herkömmlichen Systemen erwartet, die Komplexität der Codierer/Decodierer zu steigern, was einen zusätzlichen Speicherraum erfordert, oder drastisch die Zeit zu erhöhen, die zur Fehlerkorrektur erforderlich ist. Das Schema codiert Redundanzsymbole von den verschiedenen niedrigeren Codierpegeln und behandelt diese als Löschungen. Das Codierschema kann so den Datensymbolen einen leistungsvollen Fehlerschutz ohne die Speicherung der Anzahl von Redundanzsymbolen, die bei herkömmlichen Systemen erforderlich sind, geben.
Das erfindungsgemäße System verwendet die verschiedenen Pegel der Redundanzsymbole während des Mehrfachpegel- Decodierens, um Fehler und Löschungen beide zu korrigieren. Jeder Decodierpegel korrigiert lediglich einen Teil der Löschungen und/oder Fehler in den wiedergewonnenen Symbolen. Demgemäß kann eine Fehlerkorrektur relativ rasch mittels höherer Pegel des Decodierens entweder mit ECCs einer abnehmenden Komplexität wie in dem ersten Ausführungsbeispiel oder mit leistungsvollen ECC's, die benötigt werden, um relativ wenige Fehler zu korrigieren, wie beim zweiten Ausführungsbeispiel, durchgeführt werden.
Die vorstehende Beschreibung ist auf zwei spezifische Ausführungsbeispiele dieser Erfindung begrenzt. Es ist jedoch offenbar, daß Anderungen und Modifikationen an der Erfindung vorgenommen werden können, wobei einige oder alle ihrer Vorteile erreicht werden, welche in den Bereich der beigefügten Patentansprüche fallen.

Claims

1. Verfahren zum Schützen eines Blockes von "ki" Datensymbolen gegen Fehler, wobei das Verfahren die folgenden Schritte umfaßt:

A. Segmentieren des Blockes von ki Datensymbolen in jeweils i Unterblöcke von k Symbolen und Codieren jedes der Unterblöcke gemäß einem ersten Fehlerkorrekturcode, um "i" Pegel-1-Codewörter zu erzeugen, wobei jedes der Pegel-1-Codewörter "k" Datensymbole und "r" Redundanzsymbole enthält, die in einer Gesamtsumme von ri Pegel-1- Redundanzsymbolen resultieren,

B. Sektionieren der ri Redundanzsymbole der Pegel-1-Codewörter in "m" (m(r) Mehrfachsymbolabschnitte R(1), R(2), ..., R(m), die entsprechende Symbole von jedem der i Codewörter enthalten,

C. Codieren der entsprechenden Redundanzsymbole in Abschnitt R(2) von jedem der Pegel-1-Codewörter gemäß einem Fehlerkorrekturcode, um Pegel-2- Codewörter zu erzeugen, wobei jedes der Pegel-2-Codewörter als Informationssymbole "i" Redundanzsymbole, die mittels des ersten Fehlerkorrekturcodes erzeugt sind, und "q&sub2;" weitere Redundanzsymbole enthält, wobei die Symbole so erzeugt sind, daß sie einem Abschnitt Q(2) der Redundanzsymbole zugeordnet sind,

D. Wiederholen des Schrittes C für jeden der verbleibenden R(3), ..., R(m) Redundanzsymbolabschnitte, wobei das Codieren Abschnitte Q(3), ..., Q(m) der Redundanzsymbole erzeugt, und E. Zurückhalten der Datensymbole, des Abschnittes R(1) der Redundanzsymbole und der Abschnitte Q(2), Q(3), ..., Q(m) der Redundanzsymbole.

2. Fehlerschutzverfahren nach Anspruch 1, bei dem jeder der R(2), ..., R(m) Abschnitte der r Redundanzsymbole mittels des gleichen Fehlerkorrekturcodes codiert ist.

3. Fehlerschutzverfahren nach Anspruch 1, bei dem jeder der Redundanzsymbolabschnitte mittels eines verschiedenen Fehlerkorrekturcodes codiert ist, wobei die Fehlerkorrekturcodes, die verwendet sind, um jeweils Redundanzabschnitte R(3), ..., R(m) zu codieren, ausgelegt sind, um weniger Fehler als die Codes zu korrigieren, die verwendet sind, um den vorangehenden Abschnitt R(2), ..., R(m-1) zu codieren.

4. Fehlerschutzverfahren nach Anspruch 1, bei dem das Verfahren weiterhin den Schritt des Verzahnens der ki Datensymbole umfaßt.

5. Fehlerschutzverfahren nach Anspruch 1, bei dem das Verfahren weiterhin die folgenden Schritte umfaßt:

F. Behandeln der Symbole des Abschnittes R(2), R(3), ..., R(m), die nicht in Schritt E zurückgehalten sind, als Löschungen,

G. Einfüllen in jedes Pegel-1-Codewort von so vielen der Löschungen und Korrigieren von so vielen Fehlern in den Codewörtern als möglich mittels des ersten Fehlerkorrekturcodes,

H. Behandeln der Datensymbole als fehlerfrei, falls alle der Redundanzsymbole in dem Pegel-1- Codewort eingefüllt sind,

I. Einfüllen in jedes Pegel-1-Codewort, in welches die Symbole des Abschnittes R(2) nicht eingefüllt sind, der Löschungen in Abschnitt R(2) mittels der Redundanzsymbole des Abschnittes Q(2) und des Fehlerkorrekturcodes, der zum Codieren der Symbole des Abschnittes R(2) verwendet ist,

J. Korrigieren mittels des ersten Fehlerkorrekturcodes und der Redundanzsymbole des Abschnittes R(1) und R(2) von jeglichen Fehlern in den Pegel-1-Codewörtern, in die die Symbole des Abschnittes R(2) durch Schritt I eingefüllt sind,

K. falls irgendwelche Redundanzsymbole in die Pegel-1-Codewörter nicht eingefüllt sind:

i. Einfüllen in den Abschnitt R(3) von Löschungen mittels der Redundanzsymbole des Abschnittes Q(3) und des Fehlerkorrekturcodes, der verwendet ist, um die Symbole des Abschnittes R(3) zu codieren, und

ii. Korrigieren mittels des ersten Fehlerkorrekturcodes und der Symbole des Abschnittes R(1), R(2) und R(3) von jeglichen Fehlern in den Pegel-1-Codewörtern, in die die Symbole des Abschnittes R(3) durch diesen Schritt J eingefüllt sind, und

L. Wiederholen des Schrittes J für jeden verbleibenden Abschnitt der r Redundanzsymbole.

6. Fehlerschutzverfahren nach Anspruch 5, bei dem jeder der R(2), ..., R(m) Abschnitte der r Redundanzsymbole mittels des gleichen Fehlerkorrekturcodes codiert ist.

7. Fehlerschutzverfahren nach Anspruch 5, bei dem jeder der Redundanzsymbolabschnitte mittels eines verschiedenen Fehlerkorrekturcodes codiert wird, und bei dem die Fehlerkorrekturcodes, die verwendet sind, um Redundanzabschnitte R(3), ..., R(m) zu codieren, ausgelegt sind, um weniger Fehler als die Codes zu korrigieren, die verwendet sind, um jeweils die Daten und Abschnitte R(2), ..., R(m-1) zu codieren.

8. Fehlerkorrektursystem zum Codieren eines Blockes von "ki" Datensymbolen zum Schützen der Datensymbole gegen Fehler, wobei das System aufweist:

A. eine erste Codierereinrichtung zum Segmentieren des Blockes von ki Datensymbolen in jeweils "ii" Unterblöcke von k Symbolen und zum Codieren jedes der Unterblöcke gemäß einem ersten Fehlerkorrekturcode, um i Pegel-1-Codewörter zu erzeugen, wobei jedes der Pegel-1-Codewörter "k" Datensymbole und "r" Redundanzsymbole enthält, was in einer Gesamtsumme von ri Pegel-1-Redundanzsymbolen resultiert,

B. eine Einrichtung zum Sektionieren der ri Redundanzsymbole der Pegel-1-Codewörter in "m" (m(r) Mehrfachsymbol-Abschnitte R(1), r(2), ..., R(m), die entsprechende Symbole von jedem der i Codewörter enthalten,

C. eine zweite Codierereinrichtung zum Codieren der entsprechenden Redundanzsymbole in Abschnitt R(2) von jedem der Pegel-1-Codewörter gemäß einem Fehlerkorrekturcode, um Pegel-2- Codewörter zu erzeugen, wobei jedes der Pegel-2-Codewörter als Informationssymbole "i" Redundanzsymbole, die mittels des ersten Fehlerkorrekturcodes erzeugt sind, und "q&sub2;" weitere Redundanzsymbole enthält, wobei die Symbole so erzeugt sind, daß sie einem Abschnitt Q(2) der Redundanzsymbole zugeordnet sind, wobei die zweite Codiereinrichtung jeden der verbleibenden Redundanzsymbolabschnitte codiert, um jeweils Abschnitte Q(3), ..., Q(m) der Redundanzsymbole zu erzeugen, und

D. eine Einrichtung zum Zurückhalten der Datensymbole, des Abschnittes R(1) der Redundanzsymbole und der Abschnitte Q(2), Q(3), ..., Q(m) der Redundanzsymbole.

9. Fehlerkorrektursystem nach Anspruch 8, bei dem die zweite Codiereinrichtung jeden der R(2), ..., R(m) Abschnitte der r Redundanzsymbole mittels des gleichen Fehlerkorrekturcodes codiert.

10. Fehlerkorrektursystem nach Anspruch 8, bei dem die zweite Codiereinrichtung jeden der R(2), ..., R(m) Abschnitte der r Redundanzsymbole codiert, indem für jeden Abschnitt ein Fehlerkorrekturcode verwendet wird, der ausgelegt ist, um weniger Fehler als den Code zu korrigieren, der verwendet ist, um die Symbole des vorangehenden Abschnittes zu codieren.

11. Fehlerkorrektursystem nach Anspruch 8, bei dem die erste Codiereinrichtung die ki Datensymbole verzahnt, bevor diese in die i Abschnitte getrennt werden.

12. Fehlerkorrektursystem nach Anspruch 8, bei dem das System weiterhin aufweist:

E. eine erste Korrektureinrichtung, um:

i. die Redundanzsymbole des Abschnittes R(2) R(m) als Löschungen zu korrigieren und jegliche fehlerhafte zurückgehaltene Daten und Symbole des Abschnittes R(1) mittels des Pegel-1-Fehlerkorrekturcodes zu korrigieren, und

ii. Behandeln der Datensymbole als fehlerfrei, wenn alle Redundanzsymbole in das Pegel-1- Codewort eingefüllt sind, und

F. eine zweite Korrektureinrichtung, um:

i. ihrerseits in die Symbole des Abschnittes R(2), ..., R(m), die nicht durch die erste Korrektureinrichtung eingefüllt sind, mittels des Abschnittes Q(2), ..., Q(m) Redundanzsymbole und den Fehlerkorrekturcode einzufüllen, der verwendet ist, um jeweils die Symbole des Abschnittes R(2), ..., R(m) zu codieren, und

ii. auf die erste Korrektureinrichtung zur weiteren Fehlerkorrektur, nachdem jeder der Abschnitte (R2), ..., R(m) eingefüllt ist, die Pegel-1-Codewörter anzuwenden.

13. Verfahren zum Erzeugen von Fehlerkorrektur-Redundanzsymbolen entsprechend einem Block von "ki" Datensymbolen, wobei das Verfahren die folgenden Schritte aufweist:

A. Segmentieren des Blockes von ki Datensymbolen in i Unterblöcke und Codieren der Unterblöcke über einem Galois-Feld GF(2t) mittels eines ersten Fehlerkorrekturcodes, um "i" Pegel-1- Codewörter zu erzeugen, wobei jedes der Pegel-1-Codewörter "k" Datensymbole und "s" Redundanzsymbole enthält, wobei der erste Fehlerkorrekturcode ein Erzeugerpolynom g&sub1;(x) mit aufeinanderfolgenden Wurzeln in GF(2t) hat:

g&sub1;(x)=(x+αa)*(a+α+1)*(x+αa+2)*(x+αa+3)*... *(x+αa+s)

wobei * eine Galois-Feld-Multiplikation darstellt und α ein Primitiv-Polynom von GF(2t) ist und die Redundanzsymbole einem Abschnitt S(1) der Redundanzsymbole zugeordnet sind,

B. Codieren der Datensymbole zum Erzeugen eines zweiten Satzes von Redundanzsymbolen, die einem Abschnitt S(2) zugeordnet sind, in jedem der i- Pegel-1-Codewörter und der entsprechenden Symbole in Abschnitt S(1) mittels eines zweiten Fehlerkorrekturcodes mit einem Erzeugerpolynom g*&sub2;(x), das gleich zu dem Quotienten eines Erzeugerpolynoms g&sub2;(x), nämlich

ist, geteilt durch das Erzeugerpolynom g&sub1;(x), wobei das Polynom g&sub2;(x) eine Dehnung von g&sub1;(x) ist,

C. Wiederholen des Schrittes B in einer vorbestimmten Anzahl und Erzeugen von Abschnitten S(3) ... S(m) der Redundanzsymbole,

D. weiterhin Codieren der Redundanzsymbole des Abschnittes S(2) ... S(m), um zugeordnete Abschnitte der Redundanzsymbole Q(2) ... Q(m) zu erzeugen,

E. Codieren jedes der Abschnitte Q(2) ... Q(m) der Redundanzsymbole, um Abschnitte ECK(2) ... ECK(m) der Redundanzsymbole zu erzeugen, und

F. Zurückhalten der Datensymbole, der Redundanzsymbole der Abschnitte S(1), der Redundanzsymbole des Abschnittes Q(2) ... Q(m) und der Redundanzsymbole ECK(2) ... ECK(m).

14. Verfahren nach Anspruch 13, bei dem das Verfahren weiterhin ein Verzahnen der ki Datensymbole umfaßt.

15. Verfahren nach Anspruch 13, bei dem das Verfahren weiterhin die folgenden Schritte aufweist:

F. Korrigieren der Datensymbole mittels der Redundanzsymbole des Abschnittes S(1) und des ersten Fehlerkorrekturcodes,

G. falls Fehler in den Datensymbolen verbleiben, Einfüllen in jedes Codewort der Redundanzsymbole des Abschnittes S(2) mittels der Redundanzsymbole des Abschnittes Q(2) und des Fehlerkorrekturcodes, der verwendet ist, um die Redundanzsymbole des Abschnittes Q(2) zu erzeugen,

H. Korrigieren der fehlerhaften Datensymbole mittels der in Abschnitt S(2) eingefüllten Redundanzsymbole und des zweiten Fehlerkorrekturcodes mit dem Erzeugerpolynom g*&sub2;(x),

1. falls Fehler in den Datensymbolen verbleiben, Einfüllen in jedes Codewort des nächsten Abschnittes der Redundanzsymbole S(3), ..., S(m) mittels der Redundanzsymbole des entsprechenden Abschnittes Q(3) ... Q(m) und eines dem Pegel zugeordneten Fehlerkorrekturcodes, und

J. Korrigieren jeglicher Fehler mittels eines Fehlerkorrekturcodes, der dem Pegel des Codierens zugeordnet ist.

16. System zum Erzeugen von Fehlerkorrektur-Redundanzsymbolen entsprechend einem Block von "ki" Datensymbolen, wobei das System aufweist:

A. eine erste Codiereinrichtung zum Segmentieren des Blockes von Datensymbolen in i Unterblöcke und zum Codieren der i Unterblöcke über einem Galois-Feld GF(2t) mittels eines ersten Fehlerkorrekturcodes, um "i" Pegel-1-Codewörter zu erzeugen, wobei jedes der Pegel-1-Codewörter "k" Datensymbole und "s" Redundanzsymbole enthält, wobei der erste Fehlerkorrekturcode ein Erzeugerpolynom g&sub1;(x) mit aufeinanderfolgenden Wurzeln in GF(2t) hat:

g&sub1;(x)(x+αa)*(a+α+1)*(x+αa+2)*(x+αa+3)*... *(x+αa+s)

wobei * eine Galois-Feld-Multiplikation bedeutet und α ein Primitiv-Polynom von GF(2t) ist und die Redundanzsymbole einem Abschnitt S(1) der Redundanzsymbole zugeordnet sind,

B. eine Codiereinrichtung, um zum Erzeugen eines Abschnittes der Redundanzsymbole S(2) die Datensymbole und die Redundanzsymbole des Abschnittes S(1) in jedem der i Pegel-1-Codewörter mittels eines zweiten Fehlerkorrekturcodes mit einem Erzeugerpolynom g*&sub2;(x) zu codieren, das gleich ist zu dem Quotienten von g&sub2;(x), der eine gedehnte Version von g&sub1;(x) ist:

dividiert durch g&sub1;(x),

C. eine Codiereinrichtung zum Codieren der Redundanzsymbole des Abschnittes S(2) zum Erzeugen eines Abschnittes Q(2) der Redundanzsymbole,

D. eine Codiereinrichtung zum Codieren der Redundanzsymbole des Abschnittes Q(2), um einen Abschnitt ECK(2) der Redundanzsymbole zu erzeugen, und

E. eine Einrichtung zum Zurückhalten der Datensymbole, der Redundanzsymbole des Abschnittes S(1) und der Redundanzsymbole des Abschnittes Q(2) und des Abschnittes ECK(2).

17. System nach Anspruch 16, wobei das System weiterhin aufweist:

F. eine Codiereinrichtung, um in Pegeln die Datensymbole und die Abschnitte der Redundanzsymbole S(i), die in vorhergehenden Pegeln des Codie rens erzeugt sind, zu codieren, um einen nächsten Abschnitt S(i+1) der Redundanzsymbole mittels eines Fehlerkorrekturcodes mit einem Erzeugerpolynom g*i+1(x) zu erzeugen, das gleich zu dem Quotientenerzeugerpolynom gi+1(x) ist, das eine Dehnung des Erzeugerpolynoms gi(x) ist, das dem vorhergehenden Pegel zugeordnet ist, geteilt durch das Erzeugerpolynom gi(x),

G. eine Codiereinrichtung zum Codieren jedes der Abschnitte S(i) der Redundanzsymbole, um einen anderen Abschnitt der Redundanzsymbole Q(i) zu erzeugen,

H. eine Codiereinrichtung zum Codieren jedes der Q(i) Abschnitte der Redundanzsymbole zum Erzeugen von ECK(i) Abschnitten der Redundanzsymbole, und

I. eine Einrichtung zum Zurückhalten der Datensymbole, der Redundanzsymbole des Abschnittes S(1), der Redundanzsymbole des Abschnittes Q(i) und von Sätzen der Redundanzsymbole der Abschnitte ECK(2), .., ECK(i)

18. System nach Anspruch 16, bei dem das System weiterhin aufweist:

F. eine Einrichtung zum Korrigieren der Datensymbole mittels der Redundanzsymbole des Abschnittes S(1) und des ersten Fehlerkorrekturcodes,

G. falls Fehler in den Datensymbolen verbleiben, eine Einrichtung zum Einfüllen in jedes Codewort der Redundanzsymbole des Abschnittes S(2) mittels der Redundanzsymbole des Abschnittes Q(2) und des Fehlerkorrekturcodes, der zum Erzeugen der Redundanzsymbole des Abschnittes Q(2) verwendet ist,

H. Korrigieren der fehlerhaften Datensymbole mittels der in Abschnitt S(2) eingefüllten Redundanzsymbole und des zweiten Fehlerkorrekturcodes mit dem Erzeugerpolynom g*&sub2;(x), das gleich zu dem Quotienten eines Erzeugerpolynomes g&sub2;(x) ist, das eine Dehnung des Pegel-1- Erzeugerpolynomes ist, geteilt durch das Pegel- 1-Erzeugerpolynom.

19. System nach Anspruch 17, bei dem das System weiterhin umfaßt:

J. eine Einrichtung zum Korrigieren der Datensymbole mittels der Redundanzsymbole des Abschnittes S(1) und des ersten Fehlerkorrekturcodes,

K. falls Fehler in den Datensymbolen verbleiben, eine Einrichtung, um in jedes Codewort Redundanzsymbole des Abschnittes S(2) einzufüllen, unter Verwendung der Redundanzsymbole des Abschnittes Q(2) und des Fehlerkorrekturcodes, der zum Erzeugen der Q(2) Redundanzsymbole verwendet ist,

L. Korrigieren der fehlerhaften Datensymbole mittels der in Abschnitt S(2) eingefüllten Redundanzsymbole und des zweiten Fehlerkorrekturcodes mit dem Erzeugerpolynom g*&sub2;(x), das gleich zu dem Quotienten des Erzeugerpolynoms g&sub2;(x), das eine Dehnung des Pegel-1-Erzeugerpolynomes ist, geteilt durch das Pegel-1-Erzeugerpolynom, ist,

M. falls Fehler in den Datensymbolen verbleiben, eine Einrichtung, um in jedes Codewort den Abschnitt der Redundanzsymbole S(i) einzufüllen, die durch den nächsten Codierschritt erzeugt sind, mittels des entsprechenden Abschnittes Q(i) der Redundanzsymbole und des entsprechenden Fehlerkorrekturcodes,

N. Korrigieren der fehlerhaften Datensymbole mittels der Redundanzsymbole des eingefüllten Abschnittes S(i) und des entsprechenden Fehlerkorrekturcodes, der als ein Erzeugerpolynom g*i(x) hat, das gleich zu dem Quotienten des Erzeugerpolynomes gi(x), das eine Dehnung des Erzeugerpolynomes des vorhergehenden Pegels ist, geteilt durch das Erzeugerpolynom des vorhergehenden Pegels, ist.