DE69414631T2

DE69414631T2 - Schaltung zur Durchführung des Euclidschen Algorithmus bei der Dekodierung Arithmetischer Kodes

Info

Publication number: DE69414631T2
Application number: DE69414631T
Authority: DE
Inventors: Minoru C/O Intellectual Property Division Minato-Ku Tokyo Yoneda
Original assignee: Toshiba Corp
Current assignee: Toshiba Corp
Priority date: 1993-03-31
Filing date: 1994-03-31
Publication date: 1999-04-08
Anticipated expiration: 2014-04-01
Also published as: DE69414631D1; EP0620654A3; US5517509A; EP0620654B1; EP0620654A2

Description

Die Erfindung betrifft allgemein einen Decoder. Sie betrifft insbesondere einen Decoder, der zum Decodieren von Fehlerkorrekturcodes von Goppa-Codes einschließlich des Reed-Solomon(RS)-Codes und des Bose-Chaudhuru-Hocgenghem(BCH)-Codes geeignet ist.
Um die Zuverlässigkeit verschiedener digitaler Systeme zu fördern, ist es in den letzten Jahren üblich geworden, Fehlerkorrekturcodes zu verwenden. Entsprechend den unterschiedlichen Systemen wurden unterschiedliche Arten von Fehlerkorrekturcodes eingesetzt.
Ein wichtiger Code, dessen Redundanz gering ist, und den man in den Gebieten CD (Compact Disk), DAT (Digital Audio Tape) und Satellitenkommunikation häufig verwendet, ist insbesondere der Reed-Solomon-Code (im weiteren als RS-Code bezeichnet).
Zum Decodieren des RS-Codes wurden verschiedene Verfahren vorgeschlagen. Zum Korrigieren einiger weniger Symbole, beispielsweise von zwei oder drei Symbolen, kann man die Fehlerorte und die Fehlerwerte mit einer algebraisohen Funktion erhalten, die den RS-Code verwendet. Ein Decoder für diesen Zweck ist einfach zu entwerfen. In einem System mit hohen Zuverlässigkeitsanforderungen ist es jedoch nötig, die Korrigierbarkeit von Fehlern zu erhöhen. In diesen Fall verwendet man den Peterson-Algorithmus, den Berlekamp-Massey-Algorithmus oder den Euklidalgorithmus. Bei diesen Algorithmen erfolgt das Decodieren durch das Aufstellen von Fehlerortungspolynomen und Fehlerwertpolynomen, und man erhält die Fehlerorte und die Fehlerwerte mit dem Chien-Sucher. Schaltungen, die diese Decodierungsart ermöglichen, sind außerordentlich groß und erfordern zudem lange Rechenzeiten.
Der RS-Code wird nun kurz beschrieben.
Der RS-Code enthält Galoisfeldelemente GF. Beträgt die Codelängen n, der kleinste Abstand (Hammingabstand) d, und sind k Symbole eines RS-Codes auf dem Galoisfeld GF(2 ), das 2 Elemente umfaßt, informationstragend, so erfüllt der RS-Code die Gleichungen (1) und (2):
n ≤ 2 - 1 , ... (1)
n = k + (d - 1). ... (2)
Die Fehlerkorrekturfähigkeit t dieses RS-Codes kann man mit der Gleichung (3) ausdrücken:
t = (d - 1)/2. ... (3)
Ein Generatorpolynom G(X) hat Grade gleich den Codeprüfsymbolen (n - k) (= d - 1 = 2t) und ist durch Xn-1 teilbar. Ist das Grundelement von GF(2 ) α, so kann man das Generatorpolynom G(X) des RS-Codes durch die Gleichung (4) ausdrücken:
G(X) = (X - α) · (X - α²)... (X - α2t). ...(4)
G(X) kann man zudem wahlweise durch die Gleichung (5) ersetzen:
G(X) = (X - 1) · (X - α)... (X - α2t-1). ... (5)
Es wird nun der Codiervorgang beschrieben.
Ein Codierpolynom C(X) muß nach dem Codieren durch ein Generatorpolynom G(X) teilbar sein. Wünscht man, das Informationssymbol I aus k Stücken zu codieren, und wird diese Information durch ein Polynom ausgedrückt, so erhält man das informationstragende Symbolpolynom I durch die Gleichung (6):
I (X) = Cn-1 · Xn-1 + Cn-2 · Xn-2 + Cn-k · Xn-k . ... (6)
Ein Restpolynom P(X), das man durch das Teilen des informationstragenden Symbolpolynoms G(X) durch das Generatorpolynom P(X) erhält, wird durch die Gleichung (7) ausgedrückt:
P(X) = I(X) · mod G(X)
= Cn - k - 1 · Xn-k-1 + Cn - k - 2 · Xn-k-2 + ... + C0, ... (7)
und ein Codierpolynom C(X) liefert die Gleichung (8):
C(X) = I(X) + P(X). ... (8)
Offensichtlich ist das Codierpolynom C(X) aus Gleichung (8) durch G(X) teilbar.
Es wird nun der Decodiervorgang beschrieben.
Fig. 1 zeigt einen Schaltplan eines herkömmlichen Decoders, der zum Decodieren eines derartigen Fehlerkorrekturcodes dient. Der Decoder in Fig. 1 ist in der Japanese Patent Official Gazette (TOKU-KO-HEI) 4-7847 offenbart.
Der Decoder nach Fig. 1 beruht auf dem Systolen-Algorithmus. Betrachtet man keine Löschung, so erfolgt das Decodieren gemäß der folgenden Prozeduren (1) bis (5):
(1) Berechnen der Syndrome.
(2) Sind alle Syndrome null, so wird geschlossen, daß kein Fehler vorliegt.
(3) Bestimmen eines Fehlerortungspolynoms σ(X) und eines Fehlerwertpolynoms ω(X) mit dem Peterson-Algorithmus oder dem Euklidalgorithmus.
(4) Bestimmen einer Wurzel von σ(X), d. h. eines Fehlerorts, mit dem Chien-Sucher.
(5) Ermitteln einer Wurzel von ω(X), d. h. eines Fehlerwerts.
Das Codierpolynom C(X) aus Gleichung (8) ist auf einer Übertragungsleitung der Einwirkung von Rauschen ausgesetzt und verwandelt sich in ein Empfangspolynom Y(X). Dieses Empfangspolynom Y(X) ist die Summe aus den Codierpolynom C(X) und dem Fehlerbestimmungspolynom σ(X).
Zuerst werden im obigen Schritt (1) die Syndrome S1, S2, ..., S2t aus dem Empfangspolynom Y(X) berechnet. In einem BCH-Code mit den Wurzeln α, α², ..., α2t, sind die Syndrome durch die Gleichung (9) definiert:
Si = Y(αi), (i = 1, 2, ..., 2t) .... (9) Da C(αi) = 0 gilt, (i = 1, 2, ..., 2t), ergibt sich ein Syndrom zu:
Si = E(αi), (i = 1, 2, ..., 2t) .... (10)
Liegt kein Fehler vor, so sind alle Syndrome null.
Es sei nun angenommen, daß die Fehler e1, e2, ..., eL an den Orten j1, j2, ..., jL auf treten, wobei gilt L ≤ t. Da auch die Gleichung (11) gilt:
E(X) = e1 · Xj1 + e2 · Xj2 + ... + eL · XjL, ... (11)
erhält man die Gleichung (12) aus der Gleichung (10):
Si = e1 · αij1 + e2 · αij2 + ... + eL · αijL
(i = 1, 2, ..., 2t) .... (12)
Damit kann man die Fehlerorte j1, j2, ..., jL und die Fehlerwerte e1, e2, ..., eL aus S1, S2, ..., S2t erhalten.
Da es jedoch schwierig ist, sie direkt aus den Syndromen zu gewinnen, bestimmt man zuerst ein Polynom vom Grad L auf dem Galoisfeld GF(2 ), das in Gleichung (13) dargestellt ist:
σ(Z) = (1 - αj1 · Z) · (1 - αj2 · Z) ... (1 - αjL · Z). ...(13)
Die Gleichung (13) wird als Fehlerortungspolynom bezeichnet, und die Wurzeln entsprechen den Fehlerorten.
Nimmt man nun an, daß das Syndrom S(Z) gemäß Gleichung (14) aufgebaut ist, und beachtet man Gleichung (15), so erhält man Gleichung (16):
S(Z) = S1 + S2 · Z + ... + S2t · Z2t-1 ... (14)
ei · αj1/(1 - αj1 · Z) = = e1 · αj1 + ei · α2ji · Z + ei · α3ji · Z² + ... , ...(15)
Wendet man σ(Z) auf beide Seiten der Gleichung (16) an, so erhält man die Gleichung (17):
σ(Z) · S(Z) = ω(Z) · mod Z2t . ... (17)
Die Gleichung (17) kann man mit einem geeigneten Polynom A(Z) durch die Gleichung (18) ersetzen:
A(Z) · Z2t + a(Z) · S(Z) = ω(Z). ... (18)
Der Ausdruck ω(Z) in Gleichung (18) heißt Fehlerbestimmungspolynom und ist durch die Gleichung (19) definiert:
Dabei gelten die Beziehungen [deg σ(Z) ≤ t] und [deg ω(Z) ≤ t-1] (deg bezeichnet den Grad). Da weiterhin gilt [ω(α-i1) ungleich null] (i = 1, ..., L) sind ω(Z) und σ(Z) voneinander unabhängig, und es ist möglich, ω(Z) und σ(Z) im Verlauf des Euklidalgorithmus zu bestimmen, um das größte gemeinsame Teilerpolynom (GCD, GCD = Greatest Common Divisor) von Z2t und S(Z) zu erhalten.
Es wird nun der in der Prozedur (3) eingesetzte Euklidalgorithmus beschrieben.
Sind zwei Polynome r-1(Z) und r0 (Z) gegeben und gilt deg r0 ≤ deg r-1, so werden die folgenden Divisionen (20) bis (23) wiederholt:
r-1(Z) = q1(Z) · r0(Z) + r1(Z), deg ≤ r1 deg r0, ... (20)
r0(Z) = q2(Z) · r1(Z) + r2(Z), deg r2 ≤ deg r1, ... (21)
rj-2(Z) = qj(Z) · rj-1(Z) + r1(Z), deg rj ≤ deg rj-1, ... (23)
rj-1(Z) = qj+1(Z) · rj(Z). ... (24)
Das letzte dividierte und von null verschiedene rj(Z) wird der größte gemeinsame Teiler (GCD) von r-1(Z) und r0(Z).
Dazu verwendet man das folgende Theorem.
Sind zwei Polynome r-1(Z) und r0(Z) mit deg r0 ≤ deg r-1 und GCD = h(Z) gegeben, so existieren die Polynome U(Z) und V(Z), die die Gleichung (24) erfüllen, wobei deg U und deg V kleiner sind als deg r-1:
U(Z) · r-1(Z) + v(Z) · r0(Z) = h(Z). ... (24)
Nimmt man an, daß r-1(Z) = Z2t und r0(Z) = S(Z) gilt, so werden mit Hilfe des obigen Theorems nacheinander Ai(Z) und Bi(Z) berechnet, die die Gleichung (25) erfüllen:
A(Z) · r-1(Z) + Bi(Z) · r0(Z) = ri (Z). ... (25)
Nimmt Bi(Z) einen kleineren Grad als t an und der Rest ri(Z) einen kleineren Grad als (t-1), so werden Bi(Z) und ri(Z) zu möglichen Ersetzungen für &epsi;(Z) und ω(Z). Nimmt man daher zuerst an, daß gilt: A-1(Z) = 1, A0(Z) = 0, B-1(Z) = 0 und B0(Z) = 1, so berechnen sich ri(Z), Ai(Z) und Bi(Z) wie folgt:
ri(Z) = ri-2(Z) - qi(Z) · ri-1 (Z), ... (26)
Ai(Z) = Ai-2(Z) - qi(Z) · Ai-1 (Z), ... (27)
Bi(Z) = Bi-2(Z) - qi(Z) · Bi-1 (Z).... (28)
Nur dann, wenn der Grad von ri(Z) durch die obigen Rechenvorgänge kleiner als (t-1) wird, erhält man die Gleichungen (29) und (30):
σ1(Z) = Bi(Z), ... (29)
ω1(Z) = ri(Z).... (30)
Man erhält einen Fehlerwert ei gemäß der Gleichung (31), wobei die mit dem Euklidalgorithmus ermittelten Wurzeln von σ(X) und ω(X) verwendet werden,
ei = -ω(α-ji)/σ'(αji), (i = 1, ..., L), ... (31)
und σ'(Z) eine Ableitung von σ(Z) ist, die durch formales Ableiten von σ(Z) gebildet wird. σ'(Z) wird durch die Gleichungen (32) und (33) ausgedrückt, die nur aus den ungeradzahlig numerierten Termen von σ(Z) aufgebaut sind:
s'(Z) = σ1 + σ3 · Z² + σ5 · Z&sup4; + ... + σL · ZL-1 (L: ungerade Zahl), ... (32)
σ'(Z) = σ1 + σ3 · Z² + σ5 · Z&sup4; + ... + σL · ZL-2 (L: gerade Zahl).... (33)
Das Codieren und Decodieren des RS-Codes sind damit abgeschlossen.
Der Decoder nach Fig. 1 besitzt nicht nur die Löschkorrekturfunktion, sondern auch die Löschkorrekturfunktion, die ein Löschortungsflag-Signal verwendet. Ein Löschortungsflag zeigt an, daß ein Symbol vermutlich fehlerhaft ist. Eine Flagausgabeschaltung 201 gibt das Löschortungsflag synchron mit einem empfangenen Codewort aus, das am Eingangsanschluß r.in eingegeben wird. Ein Löschortungsgenerator 202 erzeugt einen Löschortungskoeffizienten αi, der anzeigt, daß ein Löschort erzeugt ist.
Ein empfangenes Codewort, das am Eingangsanschluß r.in eingegeben wird, gelangt auch an eine Syndromzellenschaltung 203, die ein Syndrom S(X) erzeugt. Der Löschortungskoeffizient αi und das Syndrom S(X) werden über eine Schnittstelle 204 (im weiteren mit I/F bezeichnet) an ein Löschortungskoeffizienten-Latch 205 und eine Zellenschaltung 206 für abgewandelte Syndrome angelegt. Die Zellenschaltung 206 für abgewandelte Syndrome erzeugt ein abgewandeltes Syndrom S&epsi;(X), wobei die Fehlerortinformation aus der Information des Syndroms S(X) entfernt ist. Fig. 2 zeigt ein Blockdiagramm, das eine festgelegte Anordnung der Zellenschaltung 206 für abgewandelte Syndrome darstellt.
Die Zellenschaltung 206 für abgewandelte Syndrome wird durch das Verbinden von 2t Stück der Zelle aufgebaut, siehe Fig. 2. Das Syndrom S(X) wird als Eingabesignal Yin in ein Latch 221 eingegeben, siehe Fig. 2. Beim Aufnehmen des Syn droms S(X) im Latch 221 wird der Löschortungskoeffizient αi in ein Latch 222 eingegeben. Eine Steuerschaltung 224 steuert die Latches 225 und 226, einen Addierer 227 und einen Multiplizierer 228 abhängig von einem Befehl aus einem Latch 223 und ermittelt das modifizierte Syndrom S&epsi;(X), indem sie die Gleichung (34) auswertet:
S&epsi;(X) = (X - αi) · S(X) mod X2t . ... (34)
Das Ergebnis der Berechnung wird über einen Multiplizierer (MUX) 229 in das Latch 230 eingegeben und anschließend daraus ausgegeben. Ferner sind 2t Schritte zum Auswerten der Gleichung (34) erforderlich. Nach dem Abschluß der Berechnung wird der modifizierte Syndromkoeffizient in dem Register einer jeden Zelle gehalten, und das modifizierte Syndrom S&epsi;(X) wird ausgegeben, wenn der Decoder in den 2t-Schritt-Ausgabemodus geschaltet wird.
Das modifizierte Syndrom S&epsi;(X), das die Zellenschaltung 206 für abgewandelte Syndrome ermittelt hat, wird über ein I/F 207 an eine GCD(größter gemeinsamer Teiler)-Zellenschaltung 208 und ein Löschortungskoeffizienten-Latch 209 angelegt. Die Ausgangssignale des Löschortungskoeffizienten-Latchs 209 und der GCD-Zelle 208 werden über ein I/F 210 an eine Multiplizierer-Zellenschaltung 211 und ein Fehler-Löschwertpolynom-Latch 212 angelegt. Die GCD-Zellenschaltung 208 ermittelt Datenreihen von Koeffizienten sowohl für ein Fehlerortungspolynom σe(X) als auch ein Fehler-Löschwertpolynom n(X) aus der Datenreihe des modifizierten Syndroms. Zudem ermittelt die Multiplizierer-Zellenschaltung 211 Koeffizientendaten eines Fehler-Löschwertpolynoms n(X) aus dem Fehlerortungspolynom σe(X) und aus den Fehlerort-Datenreihen. Zusätzlich bestimmt die I/F-Schaltung 213 eine Ableitung σ'(X) eines Fehler-Löschortungspolynoms σ(X) und gibt sie zusammen mit dem Fehler-Löschwertpolynom n(X) an eine Berechnungszellenschaltung 214 aus.
Die Berechnungszellenschaltung 214 bestimmt einen Fehlerwert durch eine Berechnung gemäß der Gleichung (35) an einem Ort i, an dem das Fehlerortungspolynom σ(αi) null wird,
n(αi)/σ'(αi). ... (35)
Ein mit der Berechnungszellenschaltung 214 ermittelter Fehlerwert wird über eine Gatterschaltung 215 an einen Addierer 216 angelegt. Die Gatterschaltung 215 erkennt, ob am Ort i ein Fehler erzeugt wird, wenn das Fehlerortungspolynom σ(αi) null ist, und legt den Fehlerwert an einen Addierer 216 an. Der Addierer 216, dem ein empfangenes Codewort aus einem Pufferspeicher 217 zugeführt wird, korrigiert einen Fehler durch das Addieren der Galoisfelder eines Datums am empfangenen Codewort i mit einem Fehlerwert am Ort i und gibt das Ergebnis am Ausgangsanschluß 218 aus. COMin, siehe Fig. 1, bezeichnet einen Befehlseingang einer jeden Schaltung.
Der Decoder nach Fig. 1 kann eine Pipeline-Verarbeitung ausführen und eignet sich sehr gut für die Hochgeschwindigkeitsverarbeitung. Er weist jedoch die Fehler auf, daß sein Schaltungsumfang sehr groß ist, und daß er zum Entwickeln eines hohen Integrationsgrads unwirtschaftlich ist.
Die längste Rechenzeit in der Decodierverarbeitungszeit ist für den Bestimmungsvorgang des Fehlerortungspolynoms σ(Z) und des Fehlerwertpolynoms ω(Z) aus den Syndromen erforderlich, und der Schaltungsumfang, der diesem Vorgang entspricht, ist am größten. Ein Vorschlag zum Verkleinern des Schaltungsumfangs dieses Abschnitts wurde in der japanischen Patentschrift (TOKU-KAI-SHO) 63-157528 offenbart. Fig. 3 bzw. 4 zeigen jeweils Blockdiagramme zu diesem Vorschlag. Fig. 3 zeigt Verarbeitungselemente zum Erzeugen eines GCD. Fig. 4 zeigt die gesamte Schaltungsanordnung, in der die Verarbeitungselemente nach Fig. 3 verwendet werden.
In diesem Vorschlag wird ein systolischer Algorithmus eingesetzt. Der systolische Algorithmus dient zum Bestimmen von σ(X) und ω(X) während des Ablaufs zum Ermitteln eines GCD mit Hilfe des Euklidalgorithmus. Der Grad wird durch das abwechselnde Multiplizieren der Koeffizienten des höchsten Grads von zwei Polynomen reduziert. Zum Bestimmen von σ(X) und ω(X) in der tatsächlichen Schaltung ist es zudem erforderlich, die Schaltung zweifach zu verwenden, siehe Fig. 4, oder zwei Schaltungssysteme bereitzustellen.
In einer herkömmlichen Euklidalgorithmus-Verarbeitungsschaltung ist eine grundlegende Verarbeitungsschaltung aus zwei Multiplizierern, einem Addierer, einem Multiplexer mit drei Eingängen und zwei Ausgängen und sieben Registern aufgebaut, siehe Fig. 3, so daß sein Schaltungsumfang äußerst groß ist. Besteht ein Symbol aus 8 Bit, wie beispielsweise bei einem RS-Code auf einem Galoisfeld GF(2&sup8;), und nimmt man die Gatteranzahl aus einer NAND-Gatter-Einheit, so muß man ungefähr 1,2 K Gatter anordnen.
Tatsächlich werden (2t + 2) dieser Grundschaltungen verwendet. Gilt 2t = 10, so muß man 14,4 K Gatter anordnen. Um ein schnelles Decodieren sicherzustellen, ist es zudem erforderlich, die Schaltung zweimal bereitzustellen, siehe Fig. 4, da die Schaltung nicht zweifach verwendbar ist. Wird in diesem Fall ein LDC (LDC Long Distance Code, Langstreckencode) eingesetzt und nimmt man an, daß gilt [2t = 16], so sind 21600 Gatter erforderlich, die einen außerordentlich großen Schaltungsumfang ergeben.
Bei dem beschriebenen bekannten Decoder tritt die Schwierigkeit auf, daß sein Schaltungsumfang zum Ausführen einer Hochintegration zu groß ist.
GB-A-2 259 378 offenbart eine wechselseitige Eukliddivisionsschaltung mit verringertem Schaltungsumfang, die mit hoher Geschwindigkeit betreibbar ist, und die in einem Fehlerkorrekturvorgang angewendet werden kann. In dieser Anordnung wird ein Quotientenwert aus einem Teilerausgang von entsprechenden vorhergehenden Stufen in Registern R von kaskadierten Blöcken gespeichert, und in jedem kaskadierten Block wird eine Divisionsberechnung abhängig von einer Schaltanweisung ausgeführt. Der Quotient wird an die kaskadierten Blöcke angelegt, um eine wechselseitige Eukliddivisionsberechnung zu bewirken.
EP-A-0 295 949 offenbart ein Verfahren und eine Einrichtung zum Decodieren eines Fehlerkorrekturcodes, beispielsweise eines Reed-Solomon-Codes, mit Hilfe einer Euklidverarbeitung, bei der man ein Syndrompolynom erhält. Die höchsten Grade des Syndrompolynoms und eines Anfangspolynoms werden multipliziert. Dabei erhält man ein Fehlerpositionspolynom und ein Fehlerbewertungspolynom.
US-A-5 170 399 offenbart einen Reed-Solomon-Galoisfeld-Euklidalgorithmus-Fehlerkorrekturdecoder zum Ausführen des Euklidalgorithmus mit einem Euklidstack, der so konfigurierbar ist, daß er als Eukliddividiermodul und als Euklidmultipliziermodul wirkt.
Erfindungsgemäß wird eine Euklidalgorithmus-Verarbeitungsschaltung zum wiederholten Dividieren von Dividendenpolynomen bereitgestellt, und zwar durch Reste der Division von Dividendenpolynomen mit Divisionspolynomen, bis der Grad der Reste des Divisionsvorgangs eine vorgeschriebene Bedingung erfüllt, umfassend:
eine erste und eine zweite Registergruppe, die eine Anzahl Register zum Speichern der Dividendenpolynome und der Divisionspolynome aufweist;
eine Rückführschleife zum Speichern der Reste, die beim Dividieren der Dividendenpolynome durch die Divisionspolynome entstehen, jeweils in Registern der ersten Registergruppe, wobei die erste und die zweite Registergruppe verwendet wird.
einen Schieber zum Schieben der jeweiligen Registerinhalte der ersten Registergruppe in die nächste Stufe immer dann, wenn eine Division abgeschlossen ist, solange bis der Koeffizient des höchsten Grades der Divisionspolynome ungleich null wird; und
einen Austauscher zum Austauschen der Koeffizienten der Dividendenpolynome mit den Koeffizienten der Divisionspolynome.
In der Euklidalgorithmus-Verarbeitungsschaltung mit dem obigen Aufbau speichert die Rückführschleife die Reste, die aus dem Divisionsvorgang von Dividendenpolynomen durch Divisionspolynome in jeweiligen Registern der ersten Registergruppe entstehen. Die Dividendenpolynome werden wiederholt durch die gespeicherten Reste dividiert. Ist der Koeffizient des höchsten Grades der Reste gleich null, so ist die Division unmöglich. Daher schiebt der Schieber die Inhalte der Register in die Register der nächsten Stufe, bis der Koeffizient des höchsten Grades ungleich null wird. Da der Austauscher die Inhalte der Dividendenpolynome mit denen der Divisionspolynome vertauscht, gelingt es, den Schaltungsumfang zu verkleinern.
Die Erfindung stellt auch einen Decoder bereit, in dem die erfindungsgemäße Euklidalgorithmus-Verarbeitungsschaltung enthalten ist.
Fachleute können weitere Aufgaben und Vorteile der Erfindung aus der folgenden Beschreibung und den beiliegenden Zeichnungen entnehmen, die hiermit in die Patentschrift aufgenommen sind und einen Teil davon bilden.
Die Erfindung wird nunmehr zur besseren Darstellung, und um viele ihrer Vorteile zu zeigen, beispielhaft mit Bezug auf die beiliegenden Zeichnungen beschrieben.
Es zeigt:
Fig. 1 einen Schaltplan eines herkömmlichen Decoders;
Fig. 2 einen Schaltplan einer Schaltung für abgewandelte Syndrome nach Fig. 1;
Fig. 3 ein Blockdiagramm mit den Verarbeitungselementen, die eine herkömmliche Euklidalgorithmus-Verarbeitungsschaltung umfaßt;
Fig. 4 ein Blockdiagramm der gesamten Schaltungsanordnung einer herkömmlichen Euklidalgorithmus-Verarbeitungsschaltung, in der die Verarbeitungselemente nach Fig. 3 verwendet werden;
Fig. 5 ein Blockdiagramm einer Ausführungsform eines Dividierers, der in der Euklidalgorithmus-Verarbeitungsschaltung gemäß einer ersten Ausführungsform der Erfindung eingesetzt wird;
Fig. 6 ein Blockdiagramm zum Erklären des Grundgedankens der Ausführungsform in Fig. 5;
Fig. 7 eine Erläuterungsskizze zum Erklären des Grundgedankens der Ausführungsform in Fig. 5;
Fig. 8 ein Flußdiagramm zum Erklären der Arbeitsweise der Ausführungsform in Fig. 5;
Fig. 9 eine Zeitverlaufsdarstellung zum Erklären der Arbeitsweise der Ausführungsform in Fig. 5;
Fig. 10 ein Blockdiagramm einer Ausführungsform des Decoders gemäß einer zweiten Ausführungsform der Erfindung;
Fig. 11 einen Schaltplan einer bestimmten Schaltungsanordnung eines Erzeugers für abgewandelte Syndrome/Euklidalgorithmusteilers 3 in Fig. 10;
Fig. 12 ein Blockdiagramm mit der grundlegenden Schaltung zum Ausführen des Erzeugungsvorgangs der abgewandelten Syndrome in Fig. 10;
Fig. 13 einen Schaltplan eines Teilers für den Euklidalgorithmus in Fig. 10;
Fig. 14 einen Schaltplan der bestimmten Schaltungsanordnung 4 der Löschortungs-Polynomerzeuger/Produktsummen-Verarbeitungsschaltung für den Euklidalgorithmus in Fig. 10;
Fig. 15 ein Blockdiagramm mit der grundlegenden Schaltung zum Ausführen des Löschortungspolynom-Erzeugungsvorgangs in Fig. 10;
Fig. 16 einen Schaltplan der Produktsummen-Verarbeitungsschaltung für den Euklidalgorithmus in Fig. 10;
Fig. 17 eine Zeitverlaufsdarstellung zum Erklären des Vorgangs in Fig. 13;
Fig. 18 eine Zeitverlaufsdarstellung zum Erklären des Vorgangs in Fig. 16;
Fig. 19 eine Erläuterungsskizze zum Erklären der Arbeitsweise der Ausführungsform nach Fig. 10;
Fig. 20 eine Erläuterungsskizze zum Erklären der Arbeitsweise der Ausführungsform nach Fig. 10;
Fig. 21 eine Erläuterungsskizze zum Erklären der Arbeitsweise der Ausführungsform nach Fig. 10; und
Fig. 22 eine Erläuterungsskizze zum Erklären der Arbeitsweise der Ausführungsform nach Fig. 10.
Die Erfindung wird nun ausführlich mit Bezug auf Fig. 5 bis 22 beschrieben.
In den Zeichnungen wurden zur Vereinfachung gleiche Bezugszeichen dazu verwendet, gleiche oder gleichwertige Elemente zu bezeichnen.
Es wird nun Bezug auf Fig. 5 genommen. Eine erste Ausführungsform des erfindungsgemäßen Decoders, d. h. eine Euklidalgorithmus-Verarbeitungsschaltung, wird nun ausführlich beschrieben.
Fig. 5 zeigt ein Blockdiagramm einer Ausführungsform eines Teilers, der in der erfindungsgemäßen Euklidalgorithmus-Verarbeitungsschaltung eingesetzt wird.
Zuerst sei jedoch Bezug auf Fig. 6 genommen. Es wird der Grundgedanke eines in dieser Ausführungsform verwendeten Divisionspolynoms beschrieben.
Als Beispiel der Division wird [X&sup4; + aX³ + bX² + CX + d] betrachtet, die die Division eines Dividendenpolynoms durch ein Divisionspolynom ist. In Fig. 6 dienen die Register 1 bis 3 zum Speichern der Koeffizienten von Dividendenpolynomen. Die Register 5 bis 7 Speichern jeweils die Divisionspolynomkoeffizienten d, c, b und a und geben die Koeffizienten d, c, b und a an die Multiplizierer 12 bis 14 und ein Kehrwertspeicher-ROM 8 aus. Das Kehrwertspeicher-ROM 8 liefert Kehrwerte der Inhalte des Registers 7 an einen Multiplizierer 15. Tabelle 1
Tabelle 1 oben zeigt die Eingaben bzw. Ausgaben und die Inhalte der Register 1 bis 3 zu den Zeitpunkten t0 bis t6. Die Dividendenpolynome werden nacheinander vom höchsten Grad an in den Addierer 9 eingegeben. Zum Zeitpunkt t0, siehe Tabelle 1, werden die Register 1 bis 3 mit null initialisiert. Zum Zeitpunkt t1 wird der Koeffizient von X&sup4; des größten Grades X eines Dividendenpolynoms eingegeben. Anschließend nehmen zu den Zeitpunkten t2 bis t6 die Koeffizienten des eingegebenen Dividendenpolynoms alle den Wert null an. Beim folgenden Zeitpunkt t2 ist das Ausgabesignal null, und der Addierer 9 addiert die Null von einem Multiplizierer 12 und die eingegebene 1 und speichert das Ergebnis im Register 1. Die Inhalte des Registers 1 werden nacheinander zu den Zeitpunkten t3 und t4 in die Register 2 und 3 übertragen.
Nimmt der Inhalt des Registers 3 zum Zeitpunkt t4 den Wert 1 an, so multipliziert der Multiplizierer 15 1/a aus dem Kehrwertspeicher-ROM 8 und gibt zum ersten Mal einen Quotienten des höchsten Grades aus. Dieser Quotient wird auf die Multiplizierer 12 bis 14 zurückgeführt und mit den Koeffizienten d bis a multipliziert. In den Registern 1 bis 3 werden jeweils d/a, c/a und b/a gespeichert. Man erhält zum Zeitpunkt t5 das Ergebnis b/a². Die Ausgabe ist zum Zeitpunkt t5 abgeschlossen.
Anschließend wird der gleiche Vorgang wiederholt, und zum Zeitpunkt t6 sind die Reste in den Registern 1 bis 3 gespeichert. Fig. 7 zeigt eine Berechnung des beschriebenen Divisionsvorgangs. Die in Fig. 6 dargestellte Schaltung führt einen der Berechnung in Fig. 7 äquivalenten Vorgang aus; man erhält das gleiche Ergebnis wie bei der Berechnung in Fig. 7.
Bis zu dem Zeitpunkt, zu dem von null verschiedene höchste Grade von Dividendenpolynomen im Register 3 gespeichert sind, d. h. für die Periode zwischen den Zeitpunkten t0 und t3, werden die höchsten Grade nur verschoben, und die von null verschiedenen höchsten Grade der Dividendenpolynome kann man im Register 3 speichern. Koeffizienten unter den höchsten Graden können parallel in den Registern 2 und 1 gespeichert werden. In diesem Fall sind die Verarbeitungen zu den Zeitpunkten t4 bis t6 ausreichend.
Beträgt der Gradunterschied zwischen einem Dividendenpolynom und einem Divisionspolynom wie in diesem Fall 1, so muß die Berechnung in zwei Taktzyklen abgeschlossen sein.
Fig. 5 zeigt ein Blockdiagramm eines Teilers, der in diese Ausführungsform aufgenommen ist.
Die Register 21 bis 28 dienen zum Speichern der Koeffizienten eines Dividenden Ri-2(X). Die Register 31 bis 38 dienen zum Speichern der Koeffizienten eines Divisors Ri-1(X). Da die Register 21 bis 28 nach Abschluß der Division Reste speichern, werden sie als Ri-Register bezeichnet. Die Register 31 bis 38 heißen Ri-1-Register. In die Dateneingänge D der Register 21 bis 28 werden über die Schalter 60 bis 67 Daten eingegeben.
Die Datenausgabeanschlüsse Q der Register 21 bis 28 werden an die Addierer 41 bis 47 bzw. einen Multiplizierer 72 geführt und an die Dateneingänge D der Register 31 bis 38. Die Ausgabedaten der Register 31 bis 38 werden jeweils an die Multiplizierer 51 bis 57 und ein Kehrwertspeicher-ROM 70 angelegt sowie an die Schalter 60 bis 67.
An den Schalter 60 wird eine Null und ein Syndromkoeffizient 50 angelegt. Gesteuert durch die später beschriebenen Steuersignale LDN1 und LDN2 wird entweder die Null, der Syndromkoeffizient 50 oder das Ausgangssignal des Registers 31 gewählt und an das Register 21 ausgegeben. In ähnlicher Weise werden die Schalter 61 bis 67 jeweils mit den Ausgangssignalen der Addierer 41 bis 47 und 51 bis 57 aus der vorhergehenden Stufe versorgt. Die Schalter wählen einen der drei Eingänge und geben an die Register 22 bis 28 aus.
Das Kehrwertspeicher-ROM 70 gibt den Kehrwert des Ausgangssignals aus dem Register 38 an ein AND-Gatter 71 aus. Das AND-Gatter legt bei einem "H"-Pegel des Signals QEN den Kehrwert an einen Multiplizierer 72 an. Der Multiplizierer 72 multipliziert das Ausgangssignal des Registers 28 mit dem Kehrwert und gibt ein Produkt als Ausgangssignal Q(X) aus, das an die Multiplizierer 51 bis 57 angelegt wird. Die Multiplizierer 51 bis 57 multiplizieren die Ausgangssignale der Register 31 bis 37 mit Q(X) und geben die Produkte an die Addierer 41 bis 47 aus. Die Addierer 41 bis 47 addieren die Ausgangssignale der Register 21 bis 27 aus der vorhergehenden Stufe und die Ausgangssignale der Multiplizierer 51 bis 57 und legen die Gesamtausgangssignale an die Schalter 61 bis 67 an.
Es wird nun die Arbeitsweise der Ausführungsform mit der beschriebenen Schaltungsanordnung mit Bezug auf Fig. 8 und 9 erklärt. Fig. 8 zeigt ein Flußdiagramm zum Erklären des Euklidalgorithmus. Es ist in "Code Theory", p. 172, von Hideki IMAI besprochen (übersetzt vom Japan Electronic Information & Communication Institute). Fig. 9 zeigt eine Zeitverlaufsdarstellung zum Erklären der Arbeitsweise des Teilers aus Fig. 5.
Als Beispiel wird das Decodieren eines (15, 7)-RS-Codes auf dem Galoisfeld GF(2&sup4;) erklärt. Es sei nun angenommen, daß für das Grundpolynom P(X) gilt: P(X) = X&sup4; + X + 1, und daß für ein Generatorpolynom G(X) die Gleichung (41) gilt:
G(X) = (Π(x - αi). ...(41)
Es sei zudem vorausgesetzt, daß die 15. Information von der letzten bis zur ersten Information der empfangenen Signale die nullte bis vierzehnte Information ist, und daß bei den neunten, zehnten, elften und zwölften Werten ein Fehler erzeugt wird. In diesem Fall erhält man die Syndromkoeffizienten 50 bis 57 gemäß den Gleichungen (37) bis (44):
S0 = α&sup8; · (α&sup9;) + α · (α¹&sup0;) + α&sup6; · (α¹¹) + α&sup9; · (α¹²) = α, ... (37)
S1 = α&sup8; · (α&sup9;)² + α · (α¹&sup0;)² + α&sup6; · (α¹¹)² + α&sup9; · (α¹²)² = α¹&sup0;, ... (38)
S2 = α&sup8; · (α&sup9;)³ + α · (α¹&sup0;)³ + α&sup6; · (α¹¹)³ + α&sup9; · (α¹²)³ = α¹², ... (39)
S3 = α&sup8; · (α&sup9;)&sup4; + α · (α¹&sup0;)&sup4; + α&sup6; · (α¹¹)&sup4; + α&sup9; · (α¹²)&sup4; = α¹¹, ... (40)
S4 = α&sup8; · (α&sup9;)&sup5; + α · (α¹&sup0;)&sup5; + α&sup6; · (α¹¹)&sup5; + α&sup9; · (α¹²)&sup5; = 1, ... (41)
S5 = α&sup8; · (α&sup9;)&sup6; + α · (α¹&sup0;)&sup6; + α&sup6; · (α¹¹)&sup6; + α&sup9; · (α¹²)&sup6; = α&sup8;, ... (42)
S6 = α&sup8; · (α&sup9;)&sup7; + α · (α¹&sup0;)&sup7; + α&sup6; · (α¹¹)&sup7; + α&sup9; · (α¹²)&sup7; =α¹³, ... (43)
S7 = α&sup8; · (α&sup9;)&sup8; + α · (α¹&sup0;)&sup8; + α&sup6; · (α¹¹)&sup8; + α&sup9; · (α¹²)&sup8; = α³ . ... (44)
Damit kann man ein Syndromgeneratorpolynom S(X) durch die Gleichung (45) ausdrücken:
S(X) = α³ · X&sup7; + α¹³ · X&sup6; + α&sup8; · X&sup5; + X&sup4; +
α¹¹ · X³ + α¹² · X² + α¹&sup0; · X + α . ... (45)
Es erfolgt nun eine Berechnung, die auf dem Euklidalgorithmus nach Fig. 8 beruht.
Zuerst setzt man im Schritt A1 voraus, daß gilt: R-1(X)
= X2t = X&sup8;, R0 = S(X), B-1 (X) = 0 und B0 = 1.
Nun nimmt man im Schritt A2 i = 1 an und führt die Berechnung gemäß Gleichung (46) im Schritt A3 aus:
Ri(X) = Ri - 2(X) · mod Ri - 1(X), ... (46)
wobei Qi(X) der Quotient ist, wenn Ri-2(X) durch Ri-1(X) dividiert wird.
Anschließend folgt die Berechnung der Gleichung (47) im Schritt A4:
Bi(X) = Bi - 2(X) - Q(X) · Ri - 1(X) . ... (47)
Die Berechnungen gemäß den Gleichungen (46) und (47) erfolgen solange, bis deg Ri(X) kleiner wird als t (= 4). Gilt deg R(X) < 4, schreitet der Ablauf vom Schritt A5 zum Schritt A6, und es wird 1 zu i addiert. Die Schritte A3 und A4 werden nun wiederholt.
In diesem Beispiel nimmt R1(X) im ersten Schleifendurchlauf die Gestalt in Gleichung (48) an:
R1(X) = R-1(X)÷ R0(X) = X&sup8; ÷ S(X)
= {(α¹² · X + α&sup7;)/Q1(X)}
+ {(α¹¹ · X&sup5; + α¹¹ · X&sup4; + α · X³
+ α³ · X² + α¹&sup4; · X + α&sup8;)/R1(X)} .... (48)
Da deg R1(X) = 5 gilt, erhält man R2(X) durch Inkrementieren von i im Schritt A6:
R2(X) - {(α&sup7; · X² + α¹² · X + α¹²/Q2(X)}
+ {(Q¹¹ · X&sup4; + α¹¹ · X³ + X² + α¹² · X²)/R2(X)}... (49).
Da deg R2(X) = 4 gilt, erhält man R3(X) wiederum durch Inkrementieren von i im Schritt A6.
R3(X) = R1(X)÷ R2(X) = {(X)/Q3(X)}
÷ {(α&sup4; · X + α¹&sup0; · X² + α¹³ · X + α&sup8;)/R3(X)}.... (50)
Da deg R3(X) = 3 gilt, ist die Berechnung der Gleichung (50) abgeschlossen, und die Verarbeitung geht vom Schritt A5 zum Schritt A7. In Gleichung (50) ist R3(X) ω(X). In ähnlicher Weise erhält man nun B1(X) bis B3(X) wie folgt:
B1(x) = B-1(x) - Q1(x) · B0(x) = 0 - Q1(x) · 1]
= Q1(X) = (α¹² · X + α&sup7;), ... (51)
B2(X) = B0(X) - Q2(X) · B1(X) = 1 - Q2(X) · B1(X)
= 1 - (α&sup7; · X² + α¹² · X + α¹²)
= α&sup4; · X³ + α&sup4; · X² + α¹&sup4; · X + α, ... (52)
B3(X) = B1(X) - Q3(X) · B2(X)
= (α¹² · X + α&sup7;) - X · (α&sup4; · X³ + α&sup4; · X² + α¹&sup4; · X + α)
= α&sup4; · X&sup4; + α&sup4; · X³ + α¹&sup4; · X² + α¹³ · X + α&sup7; .... (53)
B3(X) in Gleichung (53) ist σ(X).
Setzt man σ&supmin;¹² in σ(X) ein, so erhält man die Gleichung (54):
σ(α³) = α&sup4; · α¹² + α&sup4; · α&sup9;
+ α¹&sup4; · α&sup6; + α¹³ · α³ + α&sup7; = 0 .... (54)
Gleichung (54) kann man entnehmen, daß beim zwölften Wert ein Fehler erzeugt wurde. Den Fehlerwert e kann man nun durch die Gleichung (55) ausdrücken, wobei eine Ableitung σ'(X) = α&sup4; · X² + α¹³ verwendet wird, die man durch Sammeln der ungeraden Terme von σ(X) erhält:
e = ω(X) ÷ σ'(X) .... (55)
Da X = α&supmin;¹² = α³ gilt, wenn man α&supmin;¹² in die Gleichung (55) einsetzt, erhält man Gleichung (56):
e = ω(α³) ÷ σ'(α³)
= (α&sup4; · α&sup9; + α¹&sup0; · α&sup6; + α¹³ · α&sup9; + α&sup8;) ÷ (α&sup4; · α&sup6; + α¹³)
= α³ ÷ α&sup9; = α&sup9; .... (56)
Damit erhält man den Fehlerwert α&sup9;.
In ähnlicher Weise setzt man α&supmin;¹¹, α&supmin;¹&sup0; und α&supmin;&sup9; in die Gleichungen (54) und (55) ein.
Da X = α&supmin;¹¹ = α&sup4; gilt, erhält man aus Gleichung (54) die Gleichung (57):
σ(α&sup4;) = α&sup4; · α¹&sup6; + α&sup4; · α¹² + α¹&sup4; · α&sup8; + α¹³ · α&sup4; + α&sup7; = 0. ... (57)
Weiterhin erhält man aus Gleichung (55) das folgende Ergebnis:
e = ω(α&sup4;) ÷ σ'(α&sup4;)
= (α&sup4; · α¹² + α¹&sup0; · α&sup8; + α¹³ · α&sup4; + α&sup8;)
÷ (α&sup4; · a&sup8; + α¹³) = α&sup6; .... (58)
Da auch X = α&supmin;¹² = α&sup5; gilt, erhält man aus den Gleichungen (54) und (56):
σ(α&sup5;) = α&sup4; · α²&sup0; + α&sup4; · α¹&sup5; + α¹&sup4; · α¹&sup0; + α¹³ · α&sup5; + α&sup7; = 0. ... (59)
e = ω(α&sup5;) ÷ σ'(α&sup5;) = α .... (60)
Da zudem X = α&supmin;&sup9; = α&sup6; gilt, erhält man die Gleichungen (61) und (62).
σ(α&sup6;) = α&sup4; · α²&sup4; + α&sup4; · α¹&sup8; + α¹&sup4; · α¹² + α¹³ · α&sup6; + α&sup7; = 0. ... (61)
e = ω(α&sup6;) ÷ σ'(α&sup6;) = α&sup8; .... (62)
Damit sind ein Fehlerort und ein Fehlerwert bestimmt.
Der in dieser Ausführungsform verwendete Teiler dient dazu, einen Quotienten Q(X) und ω(X) aus Ri(X) = Ri-2(X) mod Ri-1(X) in den beschriebenen Gleichungen (44) und (45) zu erhalten.
Zuerst speichert man während der Periode A, siehe Fig. 9, mit dem Steuersignal LDN (Fig. 9(a)) S(X) im Ri-Register und X8 im Ri-1-Register. Es wird nun festgestellt, ob für den Grad des R1-Registers Ri(X) < t (= 4) gilt. Da gilt S(X) = α³ · X&sup7; + α¹³ · X&sup6; + α&sup8; · X&sup5; + X&sup4; + α¹¹ · X³ + α¹² · X² + α, und der Grad in dieser Ausführungsform 7 ist, erfolgt der nächste Verarbeitungsschritt.
Während der Periode B in Fig. 9 wird geschoben, bis der Koeffizient des höchsten Grades des Registers Ri von null verschieden ist. Im Fall von Fig. 9 wird nicht geschoben, da der Koeffizient des höchsten Grades von R6 α³ (= 8(HEX)) ist:
In der folgenden Periode C werden durch das Steuersignal LDN2 die Inhalte der Register Ri und Ri-1 miteinander vertauscht. Es beginnt nun die Berechnung von X&sup8; ÷ S(X), um den höchsten Grad α¹² (= F(HEX)) für Q(X) zu erhalten. Dadurch nimmt das Signal, das eine Periode anzeigt, in der Q(X) wirksam ist, den Wert "H" an. Da der Gradunterschied wie beschrieben 1 ist, wird die Division in zwei Taktzyklen abgeschlossen. Während der nächsten Periode D erhält man einen Koeffizient α&sup7; (= B(HEX)) für Q(X). Zu diesem Zeitpunkt ist der Divisionsvorgang abgeschlossen, und das Signal QEN nimmt den Wert "L" an.
In der Periode E in Fig. 9 werden Koeffizienten der Restpolynome im Ri-Register gespeichert. Durch den gleichen Vorgang wie in der Periode A erhält man die Ausgangssignale der Register 21 bis 28 zu R6 = 0, R5 = α¹¹, R4 = α¹¹, R3 = α, R2 = α³, R1 = α¹&sup4;, R0 = α&sup8;. Der Grad ist in diesem Fall 5. Daher geht die Verarbeitung zum nächsten Vorgang. Anschließend werden die Vorgänge in den Perioden A bis D wiederholt.
In der Periode F wird der gleiche Vorgang wie in der Periode B ausgeführt. Es wird fortlaufend geschoben, bis sich der Koeffizient des höchsten Grades des Ri-Registers von null unterscheidet. Da R6 null ist, wird nur einmal geschoben.
In der Periode G wird der gleiche Vorgang wie in der Periode C ausgeführt. Durch das Steuersignal LDN2 wird der Inhalt der Register Ri und Ri-1 miteinander vertauscht. Der Divisionsvorgang beginnt, um den höchsten Grad α&sup7; (= B(HEX)) für Q(X) zu erhalten. Da durch einen Schiebevorgang in der Periode F der Gradunterschied 2 wird, dauert das Signal QEN drei Taktzyklen. D. h., das Signal QEN wird durch das Schieben für die Periode F verlängert, und der Grad nach der Berechnung wird durch das Schieben erniedrigt.
Die Periode H ist eine Divisionsvorgangsperiode, und man erhält α¹² (= F(HEX)) für Q(X). In der Periode I erfolgt der gleiche Vorgang wie in der Periode D. Für Q(X) wird 2 (= F(HEX)) ausgegeben. Der Divisionsvorgang wird in der Periode I abgeschlossen, und das Signal QEN nimmt den Wert "L" an.
In der Periode J erfolgt der gleiche Vorgang wie in der Periode E. Die Restpolynomkoeffizienten werden im Ri-Register gespeichert. Sie nehmen die Werte R6 = α¹¹, R5 = α¹¹, R4 = 1, R3 = α¹², R2 = α², R1 = 0, R0 = 0 an. Die Gradermittlung bestimmt den Grad 4. Da der Grad nicht kleiner ist als 4, geht der Ablauf weiter.
In der nächsten Periode wird nicht geschoben, da R6 = α¹¹ gilt. In der Periode L werden durch das Steuersignal LDN2 die Inhalte der Register Ri und Ri-1 miteinander vertauscht. Der Divisionsvorgang beginnt, und man erhält den höchsten Grad αº (= 1(HEX)) für Q(X).
In der Periode M ist der Divisionsvorgang abgeschlossen, und der Grad null von Q(X) wird ausgegeben. In der Periode N werden die Restpolynomkoeffizienten R6 = α&sup4;, R5 = α¹&sup0;, R4 = α¹³, R3 = α&sup8;, R2 = 0, R1 = 0, R0 = 0 im Register Ri gespei chert. In der Periode O wird der Grad untersucht. Da man dabei den Grad 3 erhält, endet die Verarbeitung.
Der Registerinhalt wird also für jeden Divisionsvorgang vertauscht, und der Divisionsvorgang wird mit Polynomkoeffizienten ausgeführt. Man kann die Geschwindigkeit des Fehlerkorrekturvorgangs dadurch verbessern, daß die Bearbeitungszeit bei der Euklidalgorithmusverarbeitung kürzer wird. Da eine Echtzeitverarbeitung ohne Pufferspeicher möglich ist, ist diese Ausführungsform für einen digitalen VCR (Videorecorder) und andere Einrichtungen wirksam, die für eine Hochgeschwindigkeits-Datenübertragung verwendet werden.
In dieser Ausführungsform kann man den grundlegenden Schaltungsabschnitt (in Fig. 5 durch gestrichelte Linien dargestellt) mit ungefähr 500 Gattern auf dem Galoisfeld GF(2&sup8;) aufbauen. Zusätzlich kann man ein Kehrwertspeicher-ROM ebenfalls mit etwa 500 Gattern aufbauen. Es sind lediglich 2t Stück des grundlegenden Schaltungsabschnitts bereitzustellen und ein Stück des Kehrwertspeicher-ROMs. Daher ist für 2t = 10 ein Schaltungsumfang von ungefähr 5500 Gattern ausreichend. Für 2t = 16 kann man eine Schaltung aus etwa 85000 Gattern aufbauen. Damit erhält man einen kleineren Schaltungsumfang als früher. Zudem ist klar, daß man den Schaltungsumfang leicht auf eine gewichtete Fehlerkorrektur erweitern kann, indem man die Grundschaltungen einfach in Kaskade schaltet.
Wie beschrieben kann man erfindungsgemäß den Schaltungsumfang verkleinern, ohne die Fähigkeit zur Hochgeschwindigkeitsverarbeitung zu beeinträchtigen.
Es wird nun eine zweite Ausführungsform des erfindungsgemäßen Decoders beschrieben, der die Euklidalgorithmus-Verarbeitungsschaltung verwendet. Fig. 10 zeigt ein Blockdia gramm einer zweiten Ausführungsform des erfindungsgemäßen Decoders.
Ein empfangenes Codewort wird in den Syndromgenerator 1 eingegeben. Ein Löschortungsflag, das mit dem empfangenen Codewort synchronisiert, wird in einen Löschortungsgenerator 2 eingegeben. Der Syndromgenerator 1 berechnet aus dem empfangenen Codewort ein Syndrom S(X). Der Löschortungsgenerator 2 erzeugt aus dem eingegebenen Löschortungsflag einen Löschortungskoeffizienten αi und speichert ihn in einem Register (nicht dargestellt).
In dieser Ausführungsform werden Schaltungen für den Erzeugungsvorgang des abgewandelten Syndroms und den Erzeugungsvorgang des Löschortungspolynoms zusammen mit einem Teiler bzw. einer Produktsummenoperation für die Euklidalgorithmusverarbeitung verwendet. Das Syndrom S(X) aus dem Syndromgenerator 1 und der Löschortungskoeffizient αi aus dem Löschortungsgenerator werden in den Erzeuger für abgewandelte Syndrome/Euklidalgorithmusteiler 3 eingegeben. Zudem wird der Löschortungskoeffizient αi an die Löschortungspolynom-Erzeugungs- bzw. Euklid-Produktsummen-Verarbeitungsschaltung 4 angelegt.
Fig. 11 zeigt einen Schaltplan mit der besonderen Schaltungsanordnung des Erzeugers für abgewandelte Syndrome bzw. des Euklidalgorithmus-Teilers 3 nach Fig. 10. Vor dem Erklären von Fig. 11 werden mit Bezug auf Fig. 12 und 13 der Hauptgedanke beim Erzeugen modifizierter Syndrome und der Teiler für die Euklidalgorithmus-Verarbeitung beschrieben.
Die in Fig. 12 dargestellte Schaltung wird durch das Verbinden von 2t Zellen aufgebaut, die einen Schalter 10, einen Addierer 11, ein Register 12 und einen Multiplizierer 13 umfassen. Im initialisierten Zustand wählt der Schalter 10 einen Anschluß 14 und legt Syndrome S0 bis S2t-1 an ent sprechende Register an. Anschließend wählt der Schalter 10 einen Anschluß 15 und legt das Ausgangssignal des Registers 12 aus der vorhergehenden Stufe an den Addierer 11 an. Ferner wird eine Null in den Schalter 10 einer Zelle auf der Seite des kleinsten Grades eingegeben. An den Addierer 11 ist das Ergebnis einer Multiplikation des Ausgangssignals aus dem Register 12 mit dem Löschortungskoeffizienten αi angelegt worden, und der Addierer 11 führt die Addition von mod X2t aus. Nach dem Eingeben des erfaßten Löschortungskoeffizienten αi werden die Koeffizienten des abgewandelten Syndroms S(X) aus Gleichung (39) im Register 12 gespeichert.
Es wird nun Bezug auf Fig. 13 genommen und ein Teiler beschrieben, der für die Division in der Euklidalgorithmus-Verarbeitung verwendbar ist. (Der Teiler in Fig. 13 ist in der Patentschrift (TOKU-GAN-HEI) 5-74652 beschrieben, die der Anmelder dieses Patents bereits früher eingereicht hat).
Die Register 21 bis 28 dienen zum Speichern von Koeffizienten eines Dividenden Ri-2(X). Die Register 31 bis 38 dienen zum Speichern der Koeffizienten eines Divisors Ri-1(X). Da die Register 21 bis 28 nach Abschluß der Division Reste speichern, werden diese Register als Ri-Register bezeichnet und die Register 31 bis 38 als Ri-1-Register.
Gilt R-1(X) = X2t und R0 = S&epsi;(X), so wird gemäß der Schaltungsanordnung nach Fig. 13 die Gleichung (63) berechnet:
Ri(X) = Ri - 2(X) mod Ri-1, ... (63)
wobei Qi(X) ein Quotient nach dem Dividieren von Ri-2 mit Ri-1(X) ist. In Fig. 11 haben die Ri-Register 21 bis 28 und die Ri-1-Register 31 bis 38 die Schaltungsanordnung wie in Fig. 11. Die Datenanschlüsse D der Register 21 bis 28 werden jeweils mit Daten aus den Schaltern 60 bis 67 versorgt. Die Ausgabedaten aus den Registern 21 bis 28 werden jeweils an die Addierer 41 bis 47 und einen Multiplizierer 72 angelegt und ebenso an die Datenanschlüsse D der Register 31 bis 38. Die Ausgabedaten aus den Registern 31 bis 37 werden jeweils über die Schalter 151 bis 157 an die Multiplizierer 51 bis 57 angelegt. Das Ausgangssignal eines Registers 38 wird an ein Kehrwertspeicher-ROM angelegt. Die Ausgabedaten aus den Registern 31 bis 38 werden auch an die Schalter 60 bis 67 angelegt.
An den Schalter 60 wird gesteuert durch die später beschriebenen Steuersignale LDN1 und LDN2 null und ein Syndromkoeffizient 50 angelegt. Der Schalter wählt entweder die Null, den Syndromkoeffizient 50 oder das Ausgangssignal des Registers 31 und legt die gewählte Größe an das Register 21 an. In ähnlicher Weise werden die Ausgangssignale der Addierer 41 bis 47 aus der vorhergehenden Stufe und 51 bis 57 an die Schalter 61 bis 67 angelegt, die einen von drei Eingängen wählen und ihn an die Register 22 bis 28 anlegen.
Das Kehrwertspeicher-ROM 70 gibt den Kehrwert des Ausgangssignals des Registers 38 an ein AND-Gatter 71 aus. Das AND-Gatter 71 legt den Kehrwert bei "H"-Pegel des Signals QEN an den Multiplizierer 72 an. Der Multiplizierer 72 multipliziert das Ausgangssignal des Registers 28 mit dem Kehrwert und gibt das Produkt als Ausgangssignal Q(X) aus und legt es auch an die Multiplizierer 51 bis 57 an. Die Multiplizierer 51 bis 57 multiplizieren die Ausgangssignale der Register 31 bis 37 mit Q(X) und geben die Produkte an die Addierer 41 bis 47 aus. Die Addierer 41 bis 47 addieren die Ausgangssignale der Register 21 bis 27 in der vorhergehenden Stufe zu den Ausgangssignalen der Multiplizierer 51 bis 57 und legen die addierten Ausgangssignale jeweils an die Schalter 61 bis 67 an.
In dieser Ausführungsform sind die Schalter 150 bis 157 und 158 zum Auswählen des Berechnungsvorgangs für die abgewandelten Syndrome oder den Eukliddivisionsvorgang bereitgestellt. Ein Multiplizierer 159 dient zum Anlegen des Ausgangssignals des Multiplizierers 72 an den Schalter 60. Die Schalter 150 bis 157 und 158 wählen einen Anschluß b zum Ausführen der Berechnung des abgewandelten Syndroms und einen Anschluß a zum Ausführen der Division.
Fig. 14 zeigt einen Schaltplan einer besonderen Schaltungsanordnung der Löschortungspolynomerzeuge- bzw. Euklid-Produktsummen-Verarbeitungsschaltung 4 aus Fig. 10. Vor dem Erklären von Fig. 14 wird die grundlegende Löschortungspolynom-Erzeugeschaltung und die Euklidalgorithmus-Produktsummen-Verarbeitung mit Bezug auf Fig. 15 und 16 beschrieben.
Die Schaltungsanordnung in Fig. 15 gleicht der grundlegenden Erzeugungsschaltung für die abgewandelten Syndrome in Fig. 12. In Fig. 15 sind 2t + 1 Zellen verbunden. In den Anschluß 14 eines Schalters 10 werden 1, 0, 0, ... eingegeben. Im initialisierten Zustand wählt der Schalter 10 den Anschluß 14 und anschließend einen Anschluß 15 zum Eingeben des Ausgangssignals der Zelle in der vorhergehenden Stufe. Sind die Löschortungskoeffizienten αi, αj, αk, ..., so erhält man einen Koeffizienten eines Löschortungspolynoms σ&epsi;(X) in Gleichung (64):
σ&epsi;(X) = (X - αi) · (X - αj) · (X - αk) ... . ... (64)
Es wird nun mit Bezug auf Fig. 16 ein Produktsummenverarbeiter beschrieben, der für die Produktsummenverarbeitung des Euklidalgorithmus nützlich ist.
In den Registern 80 bis 88 ist Bi(X) gespeichert. Die Multiplizierer 90 bis 98 geben die Multiplikationsergebnisse der Ausgangssignale der Register 80 bis 88 mit einem Quotienten Q(X) des Teilers in Fig. 13 an die Addierer 100 bis 108 aus. Die Ausgangssignale der Addierer 100 bis 108 werden an die QBi-Register 120 bis 128 angelegt. An die Addierer 130 bis 138 werden die Ausgangssignale der Bi-2-Register 110 bis 118 angelegt, die die Ausgangssignale der Register 80 bis 88 speichern; sie addieren zwei Eingangssignale.
Gelten B-1(X) = 0 und B0 = S&epsi;(X), so führt der Produktsummenverarbeiter in Fig. 16 die Produktsummenverarbeitung gemäß der Gleichung (65) aus:
Bi(X) = Bi - 2(X) - Qi(X) · Ri-1(X). ... (65)
Die Verarbeitung gemäß den Gleichungen (64) und (65) wird solange fortgeführt, bis deg Ri(X) kleiner ist als [(2t + N&epsi;)/2] (N ist die Anzahl der Löschungen (die Anzahl der Löschortungsflags)).
In Fig. 14 werden die Ausgangssignale der Schalter 140 bis 148 in die Datenanschlüsse D der Bi-Register 80 bis 88 eingegeben. Die Ausgangssignale der Register 80 bis 88 werden jeweils an die Multiplizierer 90 bis 98 angelegt sowie an die Datenanschlüsse D der Bi-2-Register 110 bis 118. Die Ausgangssignale der Register 80 bis 87 werden ferner über die Schalter 161 bis 168 an die Addierer 101 bis 108 angelegt. An die Multiplizierer 90 bis 98 wird Q(X) angelegt. Sie multiplizieren jeweils die Ausgangssignale der Bi-Register 80 bis 88 mit Q(X) und geben die Multiplikationsergebnisse an die Addierer 100 bis 108 aus. Die Ausgangssignale der Addierer 100 bis 108 werden jeweils in die QBi-Register 120 bis 128 eingegeben. Die Addierer 100 bis 108 addieren die Ausgangssignale der Multiplizierer 90 bis 98 und null oder die Ausgangssignale der Schalter 161 bis 168 und geben das Ergebnis aus. Die Ausgangssignale der QBi-Register 120 bis 128 werden in die Addierer 130 bis 138 eingegeben, die ihrerseits die Ausgangssignale der Register 120 bis 128 und die Ausgangssignale der Register 110 bis 118 addieren und die addierten Ausgangssignale an die Schalter 140 bis 148 liefern.
In dieser Ausführungsform sind die Schalter 161 bis 168 dazu bereitgestellt, den Löschortungspolynom-Erzeugevorgang oder den Euklid-Produktsummenvorgang auszuwählen. Die Schalter 161 bis 168 wählen den Anschluß a für die Löschortungspolynom-Erzeugung und den Anschluß b für den Euklid-Produktsummenvorgang.
Die Löschortungspolynom-Erzeuge- bzw. Euklid-Produktsummen-Verarbeitungsschaltung 4 bestimmt mit Hilfe der Löschortungskoeffizienten αi, αj, αk, ..., ein Löschortungspolynom S&epsi;(X) gemäß Gleichung (64). Gleichzeitig ermittelt die Erzeugeschaltung für abgewandelte Syndrome bzw. der Euklidteiler 3 aus dem Syndrom S(X) und den Löschortungskoeffizienten αi, αj, αk, ... das modifizierte Syndrom nach Gleichung (1). Die Ergebnisse dieses Vorgangs dienen als Startwerte für die Euklidalgotithmus-Verarbeitung. Die Erzeugeschaltung für abgewandelte Syndrome bzw. der Euklidteiler 3 bestimmen gemäß Gleichung (65) ein Fehlerwertpolynom ω(X), wobei der abgewandelte Syndromkoeffizient S&epsi;(X) als Anfangswert dient. Die Löschortungspolynom-Erzeuge- bzw. Euklid-Produktsummen-Verarbeitungsschaltung 4 bestimmt ein Fehlerwertpolynom ω(X) gemäß Gleichung (56) wobei das Löschortungspolynom σ(X) als Startwert dient.
Das Fehlerwertpolynom ω(X) und das Löschortungspolynom σ(X) werden in den Chien-Sucher 6 eingegeben. Der Chien-Sucher 6 bestimmt eine Ableitung σ'(X) des Löschortungspolynoms σ(X) und ermittelt einen Fehlerwert ω(αi)/σ'(αi) durch die Berechnung an einer Stelle i, an der das Löschortungspolynom σ(αi) null wird. Diese Fehlerorte und Fehlerwerte werden in den Korrekturprozessor 7 eingegeben. Ein empfangenes Codewort und ein Löschortungsflag werden auch an die Verzögerungs schaltung 8 angelegt. Die Verzögerungsschaltung 8 liefert das empfangene Codewort und das Löschortungsflag an dem Korrekturprozessor 7 und verzögert sie, wobei die Verzögerungszeit beim Bearbeiten bis hin zum Chien-Sucher 6 einbezogen wird. Der Korrekturprozessor 7 korrigiert - falls vorhanden - einen Fehler des empfangenen Codeworts, indem er die Galoisfeldaddition des empfangenen Codeworts und eines Fehlerwerts an einem Fehlerort ausführt und das korrigierte empfangene Codewort ausgibt.
Es wird nun die Verarbeitung der Ausführungsform in der beschriebenen Schaltungsanordnung mit Bezug auf die zeitlichen Darstellungen in Fig. 17 und 18 und die erläuternden Skizzen in Fig. 19 bis 22 erklärt. Fig. 17 zeigt eine Zeitliche Darstellung zum Erklären der Wirkungsweise des Teilers in Fig. 13. Fig. 18 zeigt eine zeitliche Darstellung zum Erklären der Arbeitsweise der Produktsummen-Verarbeitungsschaltung.
In dieser Ausführungsform wurden die Erzeugung des abgewandelten Syndroms und die Euklidteilung ebenso wie die Erzeugung des Löschortungspolynoms und Euklid-Produktsummenverarbeitung mit den Schaltungen nach Fig. 11 und 14 verwirklicht. Da es die Erklärung vereinfacht, wird zuerst beschrieben, daß diese Vorgänge mit den Schaltungen nach Fig. 12 bis 16 realisiert werden. Anschließend wird dargelegt, daß die Schaltungsabläufe in Fig. 12 bis 16 mit den Schaltungen aus Fig. 11 und 14 bewerkstelligt werden.
Wie beim beschriebenen Euklidalgorithmus in der ersten Ausführungsform, in der das Decodieren eines (15, 7) RS-Codes auf dem Galoisfeld GF(2&sup4;) als Beispiel dient, bleibt die Gleichung (36) gültig, wenn man das Grundpolynom zu P(X) = X&sup4; + X + 1 annimmt.
In ähnlicher Weise nimmt man an, daß das fünfzehnte informationstragende Symbol vom letzten bis zum ersten Symbol des empfangenen Signals das nullte bis vierzehnte informationstragende Symbol sind. Wenn die Fehler α&sup8;, α, α&sup6; und α&sup9; auf dem neunten, zehnten, elften und zwölften Symbol erzeugt werden, so sind die Syndromkoeffizienten 50 bis 57 durch die Gleichungen (37) bis (44) gegeben.
Daher kann man ein Syndromgeneratorpolynom S(X) wie beschrieben mit der Gleichung (45) ausdrücken.
Setzt man dagegen voraus, daß ein Löschortungsflag auf den zwölften und elften informationstragenden Symbolen eines empfangenen Codeworts erzeugt wird, so erhält man ein abgewandeltes Syndrom S&epsi;(X) gemäß Gleichung (66) durch das Berechnen der Gleichung (34) mit der Schaltung in Fig. 12:
S&epsi;(X) = (X - α&supmin;¹²) · (X - α&supmin;¹¹) · S(X) mod X&sup8;
= α² · X&sup7; + α&sup5; · X&sup6; + α² · X&sup5; + α&sup6; · X&sup4;
+ α&sup6; · X³ + α&sup8; · X² + X + α&sup8; . ... (66)
Zudem bestimmt man durch das Auswerten der Gleichung (64) mit der Schaltung nach Fig. 15 ein Löschortungspolynom σ&epsi;(X) gemäß der Gleichung (67):
σ&epsi;(X) = (X - α&supmin;¹²) · (X - α&supmin;¹¹)
= X² + α&sup7; · X + α&sup7; . ... (67)
Zunächst sei angenommen, daß gilt R-1(X) = X2t = X&sup8;, R0
= S&epsi;(X), B-1(X) = 0, B0 = σ&epsi;(X).
Weiterhin sei angenommen, daß i = 1 gilt. Die Berechnung erfolgt gemäß der Gleichung 63 mit der Schaltung nach Fig. 13.
Qi(X) ist wie beschrieben der Quotient, dem man durch das Dividieren von Ri-2(X) durch Ri-1(X) erhält.
Diese Berechnung wird fortgeführt, bis deg Ri(X) kleiner ist als (8 + 2)/2 (= 5). Ist deg Ri(X) kleiner als 5 (deg Ri(X) < 5), so wird die Berechnung wiederholt und i jedesmal um 1 erhöht.
In diesem Beispiel erhält man Ri(X) im ersten Schleifendurchlauf gemäß Gleichung (68):
R1(X) = R-1(X) ÷ R0(X) = X&sup8; ÷ S&epsi;(X)
= {(α¹³ · X + α)/Q1(X)}
+ {(α¹³¹ · X&sup6; + α&sup7; · X&sup5; + α³ · X&sup4; + α¹&sup0; · X³
+ α¹¹ · X² + α¹¹ · X + α&sup9;)/R1(X)}. ... (68)
Da deg R1(X) = 6 gilt, wird die Berechnung wiederholt und i jedesmal um 1 erhöht, so daß man R2(X) aus der Gleichung (69) erhält:
R2(X) = R0(X) ÷ R1(X) = {((α&sup4; · X + α&sup5;)/Q2(X)}
+ {(α² · X³ + α&sup8; · X² + α¹¹ · X + α&sup6;)/R2(X)}. ... (69)
Da deg R3(X) - 3 gilt, wird das Auswerten der obigen Gleichung beendet. In der obigen Gleichung ist R3(X) gleich ω(X).
Dagegen führt die Schaltung nach Fig. 16 die Auswertung der Gleichung (64) fort, bis deg Ri(X) kleiner wird als 5 (deg Ri(X) < 5).
Damit erhält man die Gleichungen (70) und (71):
B1(X) = B-1(X) - Q1(X)· B0(X)
= 0 - (α¹³ · X + α) · (X² + α&sup7; · X + α&sup7;)
= α¹³ · X + α² · X² + α&sup4; · X + α&sup8;, ... (70)
B2(X) = Bo(X) - Q2(X)· B1(X)
=(X² + α&sup7; · X + α&sup7;)
- (α&sup4; · X + α&sup5;) · (α¹³ · X³ + α² · X² + α&sup4; · X + α&sup8;)
= α² · X&sup4; + α² · X³ + α¹² · X² + α¹¹ · X + α&sup5; . ... (71)
Dabei ist B2(X) in Gleichung (71) gleich σ(X).
Da X = α&supmin;¹² = α³ gilt, wenn man α&supmin;¹² in σ(X) einsetzt, erhält man die Gleichung (72):
σ(α³) = α² · α¹² + α² · α&sup9; + α¹² · α&sup6; + α¹¹ · α³ + α&sup5;
= α¹&sup4; + α¹¹ + α³ + α¹&sup4; + α&sup5; = 0. ... (72)
Der Gleichung (72) kann man entnehmen, daß beim zwölften Wert ein Fehler erzeugt worden ist. Den Fehlerwert e kann man nun durch Gleichung (73) ausdrücken, wobei man die Ableitung σ'(X) = α² · X² + α¹¹ verwendet, die man durch Sammeln der ungeraden Terme von σ(X) erhält:
e = ω(X) ÷ σ'(X). ... (73)
Da X = α&supmin;¹² = α³ gilt, wenn man α&supmin;¹² in die Gleichung (73) einsetzt, erhält man Gleichung (74):
e = ω(α³) ÷ σ'(α³)
= (α² · α&sup9; + α&sup8; · α&sup6; + α¹¹ · α³ + α&sup6;) ÷ (α² · α&sup6; + α¹¹)
= α¹ · α&sup7; = α&sup9; .... 74)
Damit erhält man den Fehlerwert α&sup9;.
In ähnlicher Weise setzt man α&supmin;¹¹, α&supmin;¹&sup0; und α&supmin;&sup9; in die Gleichungen (71) und (73) ein, um die elften, zehnten und neunten Terme zu berechnen.
Da X = α&supmin;¹¹ = α&sup4; gilt, erhält man aus Gleichung (71) die Gleichung (75):
s(α&sup4;) = α² · α¹&sup6; + α² · α¹² + α¹² · α&sup8; + α¹¹ · α&sup4; + α&sup5;
= α³ + α¹&sup4; + α&sup5; + α&sup5; + α&sup0; + α&sup5; - 0 .... (75)
Zudem erhält man das Ergebnis (76) aus Gleichung (73):
e = ω(α&sup4;)÷ σ'(α&sup4;)
= (α&sup4; · α&sup4; + α&sup5; ) ÷ (α² · α¹² + α&sup8; · α&sup8; + α¹¹ · α&sup4; + α&sup5;)
= α&sup6; .... (76)
Setzt man X = α&supmin;¹&sup0; = α&sup5; ein, so erhält man aus den Gleichungen (71) und (73):
σ(α&sup5;) = α&sup7; + α² + α&sup7; + α¹ + α&sup5; = 0, ... (77)
e = ω(α&sup5;) ÷ σ'(α&sup5;) = α . ... (78)
Setzt man X = α&supmin;&sup9; = α&sup6; ein, so erhält man die Gleichungen (79) und (80):
σ(α&sup6;) = α¹¹ + α&sup5; + α&sup9; + α² + α&sup5; = 0, ... (7 9)
e = ω(α&sup6;) ÷ σ'(α&sup6;) = α&sup8; .... (80)
Somit erhält man einen Fehlerort und einen Fehlerwert.
Es werden nun die Verarbeitungsweisen des Teilers in Fig. 13 und der Produktsummen-Verarbeitungsschaltung nach Fig. 16 beim Ausführen der obigen Berechnungen beschrieben. Der Teiler in Fig. 13 wird dazu verwendet, die Quotienten Q(X) und ω(X) aus der Gleichung (63) zu gewinnen.
Zunächst wird während der Periode A, siehe Fig. 17, durch ein Steuersignal LDN (Fig. 17(a)) S&epsi;(X) im Ri-Register und X8 im Ri-1-Register gespeichert. Es wird bestimmt, ob deg Ri(X) < 5 gilt. Da S&epsi;(X) = α² · X&sup7; + α² · X&sup6; + α² · X&sup5; + α&sup6; · X&sup4; + α&sup6; · X³ + α&sup8; · X² + X + α&sup8; gilt, und der Grad in dieser Ausführungsform 7 ist, wird die nächste Verarbeitung ausgeführt.
Während der Periode B in Fig. 17 wird solange geschoben, bis der Koeffizient des höchsten Grades des Ri-Registers von null verschieden ist. Im dargestellten Fall in Fig. 17 wird nicht geschoben, da der Koeffizient des höchsten Grades von R6 α³ ist (= 4(HEX)).
In der folgenden Periode C werden die Inhalte des Ri-Registers und des Ri-1-Registers durch das Steuersignal LDN2 miteinander vertauscht. Die Berechnung von X&sup8; ÷ S&epsi;(X) beginnt, und man erhält einen höchsten Grad α¹³ (= D(HEX)) für Q(X). Dadurch nimmt das Signal QEB, das eine Periode anzeigt, in der Q(X) wirksam ist, den Wert "H" an. Da der Gradunterschied wie beschrieben 1 ist, ist die Division nach zwei Taktzyklen abgeschlossen. Während der folgenden Periode D erhält man einen Koeffizienten α² (= 2(HEX)) für Q(X). Zu diesem Zeitpunkt ist die Division abgeschlossen. Das Signal QEN nimmt den Wert "L" an, und SFTN nimmt den Wert "H" an.
In der Periode E in Fig. 17 werden die Koeffizienten der Restpolynome im Ri-Register gespeichert. D. h., die Ausgangssignale der Register 21 bis 28 nehmen durch den gleichen Vorgang wie in der Periode A die Werte R7 = α¹³, R6 = α&sup7;, R4 = α¹&sup0;, R3 = α¹&sup0;, R2 = α¹¹, R1 = α&sup9; und R0 = 0 an. Der Grad ist in diesem Fall 6; daher geht die Verarbeitung zum nächsten Vorgang über. Anschließend werden die Verarbeitungen in den Schritten A bis D wiederholt.
In der Periode F wird der gleiche Vorgang wie in der Periode B ausgeführt. Es wird solange geschoben, bis der Koeffizient des höchsten Grades des Ri-Registers von null verschieden ist. Da R6 = α¹³ ist, wird nicht geschoben.
In der Periode G wird der gleiche Vorgang wie in der Periode C ausgeführt. Die Inhalte der Register Ri und Ri-1 werden durch das Steuersignal LDN2 miteinander vertauscht. Der Divisionsvorgang beginnt, und man erhält den höchsten Grad α&sup4; (= 3(HEX)) für Q (X). Da der Gradunterschied 1 beträgt, nimmt das Signal QEN für zwei Taktzyklen den Wert "H" an.
Die Periode H ist eine Divisionsvorgangsperiode, und man erhält α&sup5; (= 6(HEX)) für Q(X). Die Division endet in der Periode H. Anschließend nimmt das Signal QEN den Wert "L" an. In der Periode I wird der gleiche Vorgang wie in der Periode E ausgeführt. Ein Koeffizient des Restpolynoms wird im Ri-Register gespeichert. Es gilt R7 = 0, R6 = 0, R5 = 0, R4 = α², R3 = α³, R2 = α¹¹, R1 = α&sup6;, R0 = 0. Da die Gradbeurteilung den Grad 3 ermittelt, endet der Vorgang.
Die Produktsummen-Verarbeitungsschaltung in Fig. 16 dient zum Gewinnen von σ(X) aus der Gleichung (65).
Die Produktsummenverarbeitung wird immer dann ausgeführt, wenn ein Quotient Q(X) aus dem Teiler in Fig. 13 eingegeben wird. In der Periode A in Fig. 18 nimmt das Steuersignal LDN den Wert "L" an, und die Koeffizienten des Löschortungspolynoms werden im Bi-Register voreingestellt. Das Bi-2-Register und das QBi-Register werden gelöscht. In dieser Ausführungsform sind die voreingestellten Werte im Bi-Register B2 = α&sup0;, B1 = α&sup7; und B0 = α&sup7; aus der Gleichung (65).
In der Periode B in Fig. 18 werden die Koeffizienten des Quotienten Q(X) von den höheren Koeffizienten an nacheinander eingegeben. D. h., sie werden in der Reihenfolge α¹³, α und X² + α&sup7; · X + α&sup7; eingegeben, die im Bi-Register in der Periode A voreingestellt wird, und mit dem Quotienten Q(X) multipliziert. Das erhaltene Produkt wird zum Inhalt null des Bi-2-Registers addiert. Ein Signal SFTN2 zum Aktivieren des QBi-Registers, siehe Fig. 18(0), nimmt den Wert "L" an, und es wird nur das QBi-Register bearbeitet. Die Daten im Bi-Register und im Bi-2-Register werden gehalten.
In der folgenden Periode C nimmt das Steuersignal LDN3 den Wert "L" an, um das Ergebnis der Produktsummenverarbeitung im Bi-Register zu speichern. Die Inhalte 1 des Bi-Registers werden für die nächste Berechnung in das Bi-2-Register übertragen. Zudem wird das QBi-Register gelöscht. In der Periode C wird das Ergebnis der erstmaligen Produktsummenverarbeitung (α¹³ · X³ + α² · X² + α&sup4; · X + α&sup8;) im Bi-Register gespeichert.
In der folgenden Periode D werden wie in der Periode B die Koeffizienten von Q(X) von den höheren Koeffizienten her nacheinander eingegeben. D. h., sie werden in der Reihenfolge α&sup4;, α&sup5; und (α¹³ · X³ + α² · X² + α&sup4; · X + α&sup8;) eingegeben, die in der Periode C im Bi-Register eingestellt worden ist, anschließend mit Q(X) multipliziert und zum Ausdruck (X² + α&sup7; · X + α&sup7;) addiert, der im Bi-2-Register gespeichert ist.
In der Periode E nimmt das Steuersignal LDN3 wie in der Periode C den Wert "L" an. Das folgende Ergebnis Bi (X) der Produktsummenverarbeitung wird im Bi-Register gespeichert,
Bi(X) = α² · X&sup4; + α² · X³ + α¹² · X + α&sup5; = σ(X)
D. h., das endgültige Ergebnis der Produktsummenverarbeitung bleibt im Bi-Register gespeichert.
Die Euklidalgorithmusverarbeitung wird auf diese Art ausgeführt. In der Euklidalgorithmusdivision werden abgewandelte Syndromkoeffizienten als voreingestellte Werte verwendet. Zudem werden bei der Produktsummenbildung Koeffizienten des Löschortungspolynoms als voreingestellte Werte verwendet. In dieser Ausführungsform wurde der Schaltungsumfang dadurch verringert, daß darauf geachtet wurde, Schaltungen gemeinsam zu verwenden.
Die Erzeugeschaltung für abgewandelte Syndrome bzw. der Euklidalgorithmusteiler 3 ist also der in Fig. 13 dargestellte Teiler, dem die Schalter 150 bis 157 und 159 hinzugefügt wurden. Die Schaltung 3 berechnet zuerst abgewandelte Syndrome aus den Syndromen (50 bis 57) und Löschortungskoeffizienten (ELO0 bis ELO7). Anschließend erzeugt sie durch die Euklidalgorithmusdivision ein Fehlerwertpolynom.
Kurz gesagt werden zuerst über die Schalter 60 bis 67 Syndrome in das Ri-Register geladen. Anschließend werden mit den Schaltern 60 bis 67 die Ausgangssignale des Multiplizierers 159 und der Addierer 41 bis 47 gewählt und mit den Schaltern 150 bis 157 und 159 die Anschlüsse b. Die Schaltung in Fig. 11 nimmt dann den Schaltungszustand an, der in Fig. 19 mit einer breiten Linie eingetragen ist.
Die Löschortungsdaten ELO0 bis ELO7 werden also über den Schalter 158 in die Multiplizierer 159 und 51 bis 57 eingegeben. Die Multiplizierer 159 und 51 bis 57 multiplizieren sie mit den Syndromen aus dem Ri-Register. Die Ergebnisse dieser Multiplikation werden von den Addierern 41 bis 47 zum Ausgangssignal des Ri-Registers aus der vorhergehenden Stufe addiert und über die Schalter 60 bis 67 im Ri-Register in der nächsten Stufe gespeichert. Auf diese Weise ist bekannt, daß der Schaltungszustand in Fig. 19 gleich dem Schaltungszustand in Fig. 12 ist. Das Signal SFTN hat in diesem Fall stets den Wert "L". Nach dem Abschluß der Eingabe der Löschortungsdaten werden die Koeffizienten der abgewandelten Syndrome im Ri-Register gehalten.
Durch das Wählen der Ausgangssignale aus den Registern 31 bis 38 mit den Schaltern 60 bis 67 und der Anschlüsse a mit den Schaltern 150 bis 157 und 159 wird die Verarbeitungsschaltung für abgewandelte Syndrome so verändert, daß die Verbindungen für die Euklidalgorithmusdivision entstehen. In diesem Fall nimmt die Schaltung den Verbindungszustand an, der in Fig. 20 mit der breiten Linie eingetragen ist. Ein Vergleich von Fig. 20 und Fig. 13 zeigt, daß der Euklidalgorithmusteiler durch den Verbindungszustand aufgebaut wird, der in Fig. 20 mit der fetten Linie eingezeichnet ist. Zudem wird in diesem Fall ein Quotient Q(X) aus dem Multiplizierer 72 über den Anschluß a des Schalters 158 ausgegeben. Die Schaltung in Fig. 11 führt auf diese Weise den Erzeugungsvorgang für die abgewandelten Syndrome und die Euklidalgorithmusdivision aus.
Die Löschortungspolynom-Erzeuge- bzw. Euklid-Produktsummen-Verarbeitungsschaltung 4 nach Fig. 4 ist die Produktsummen-Verarbeitungsschaltung nach Fig. 16, der die Schalter 161 bis 168 zugefügt wurden. Sie erzeugt zuerst ein Löschortungspolynom aus den Löschortungskoeffizienten (ELO0 bis ELO7) und erzeugt anschließend ein Fehlerortungspolynom durch die Produktsummenverarbeitung für den Euklidalgorithmus.
Nach dem Abschluß der Syndromverarbeitung wählen die Schalter 140 bis 148 die Ausgangssignale aus den Addierern 100 bis 108. In das unterste Register wird 1 geladen, in alle anderen Register null. Anschließend wählen die Schalter 161 bis 168 die Anschlüsse a. Die Schaltung nach Fig. 14 nimmt damit den Verbindungszustand an, der in die Schaltung nach Fig. 21 mit der breiten Linie eingetragen ist.
Nun werden die Löschortungskoeffizienten ELO0 bis ELO7 in die Multiplizierer 90 bis 98 eingegeben. Die Ausgangssignale der Multiplizierer 90 bis 98 und die Ausgangssignale der Register 80 bis 187 in der vorhergehenden Stufe werden eingegeben, und die Ausgangssignale der Addierer 100 bis 108 werden in die Register 180 bis 188 eingegeben. Eine Schaltung für den Erzeugungsvorgang des Löschortungspolynoms, die der Schaltung in Fig. 12 gleicht, wird aufgebaut. Beim Erzeugungsvorgang des Löschortungspolynoms bleibt das Signal LDN3 stets auf dem Wert "L". Nach dem Abschluß der Eingabe der Löschortungskoeffizienten bleiben die Koeffizienten des Löschortungspolynoms in den Registern 180 bis 188 gespeichert.
Die Schalter 140 bis 148 wählen nun die Ausgangssignale der Addierer 130 bis 148, und die Schalter 161 bis 168 wählen die Anschlüsse b. In diesem Fall nimmt die Schaltung also den Verbindungszustand an, der in Fig. 22 mit der breiten Linie dargestellt ist. Ein Vergleich von Fig. 22 und Fig. 16 zeigt, daß die Produktsummen-Verarbeitungsschaltung für den Euklidalgorithmus durch die Verbindung gebildet wird, die in Fig. 22 mit der breiten Linie eingezeichnet ist.
In diesem Fall wird zudem ein Divisionsquotient Q(X) anstelle der Löschortungskoeffizienten ELO0 bis ELO7 an die Multiplizierer 90 bis 98 angelegt. Die Erzeugungsvorgänge für das Löschortungspolynom und die Euklidproduktsumme werden auf diese Weise ausgeführt.
In der zweiten Ausführungsform des Decoders wird die Erzeugeschaltung für abgewandelte Syndrome bzw. der Euklidalgorithmusteiler 3 in einer einfachen Schaltungsanordnung verwendet, wobei dem Euklidalgorithmusteiler Schalter zugefügt sind. Die Division für den Euklidalgorithmus erfolgt mit Hilfe von Registern zum Halten der abgewandelten Syndrome, die man durch den Erzeugungsvorgang für die modifizierten Syndrome erhält. Die Löschortungspolynom-Erzeuge- bzw. Euklid-Produktsummen-Verarbeitungsschaltung wird in einer einfachen Schaltungsanordnung verwendet, wobei der Produktsummen-Verarbeitungsschaltung für den Euklidalgorithmus Schalter zugefügt sind. Die Produktsummenverarbeitung für den Euklidalgorithmus wird mit Hilfe von Registern zum Halten der abgewandelten Syndrome ausgeführt, die man durch den Erzeugungsvorgang für die Löschortungspolynome erhält. Durch die gemeinsame Verwendung dieser Schaltungen kann man den Schal tungsumfang beträchtlich verringern, und man kann leicht einen hohen Integrationsgrad erzielen.
Im herkömmlichen Decoder nach Fig. 1 und 2 werden durch die Verarbeitung erhaltene Daten übertragen, und die Verarbeitungszeit wird mit Hilfe des I/F reguliert. Der erfindungsgemäße Decoder hat den Vorzug, daß keine Datenübertragung erforderlich ist. Die Verarbeitungsgeschwindigkeit kann erhöht werden, da die Schaltungen gemeinsam verwendet werden. Zudem werden die Register zum Speichern der ermittelten Syndromkoeffizienten oder der Koeffizienten des Löschortungspolynoms, und die Register, in die diese Koeffizienten zum Ausführen der nächsten Division oder Produktsummenverarbeitung geladen werden, gemeinsam verwendet.
Die Erfindung ist nicht auf die beschriebenen Ausführungsformen eingeschränkt. Die Anzahl der Paritäten auf dem Galoisfeld GF(2&sup4;) ist zu 8 erklärt. Die Erfindung ist jedoch auch auf dem Galoisfeld GF(2&sup8;) anwendbar, und wie bei der Paritätsanzahl ist es möglich, leicht jede beliebige Anzahl Paritäten zu behandeln, indem lediglich die Zellenanzahl erhöht und die Gradbeurteilung geändert wird.
Die Erfindung kann wie beschrieben einen ganz besonders bevorzugten Decoder bereitstellen.

Claims

1. Euklidalgorithmus-Verarbeitungsschaltung zum wiederholten Dividieren von Dividendenpolynomen durch Reste der Division von Dividendenpolynomen mit Divisionspolynomen, bis der Grad der Reste vorgeschriebene Bedingungen erfüllt, dadurch gekennzeichnet, daß die Schaltung umfaßt:

eine erste (1-3) und eine zweite (5-7) Registergruppe, die eine Anzahl Register zum Speichern der Dividendenpolynome und der Divisionspolynome aufweist;

eine Rückführschleife zum Speichern der Reste, die beim Dividieren der Dividendenpolynome durch die Divisionspolynome entstehen, in Registern der ersten Registergruppe, wobei die erste und die zweite Registergruppe verwendet wird;

einen Schieber zum Schieben der Registerinhalte der ersten Registergruppe in Register in der nächsten Stufe immer dann, wenn eine Division abgeschlossen ist, solange bis der Koeffizient des höchsten Grades der Divisionspolynome ungleich null wird; und

einen Austauscher zum Austauschen der Koeffizienten der Dividendenpolynome mit den Koeffizienten der Divisionspolynome.

2. Decoder, umfassend:

einen Syndromoperator (1) zum Berechnen von Syndromen aus empfangenen Codewörtern;

einen Löschortungsgenerator (2) zum Erzeugen von Löschortungsdaten aus Löschortungsflags, die mit empfangenen Codewörtern synchronisieren;

einen abgewandelten Syndromgenerator (3) zum Erzeugen abgewandelter Syndrome mit Ausnahme der Löschortungsinformation aus den Syndromen;

einen Löschortungs-Polynomgenerator (4) zum Erzeugen von Löschortungspolynomen aus Löschortungsdaten;

die Euklidalgorithmus-Verarbeitungsschaltung nach Anspruch 1 zum Ermitteln von Fehlerortungspolynomen und Fehlerwertpolynomen aus den abgewandelten Syndromen und den Löschortungspolynomen;

einen Chien-Sucher (6) zum Bestimmen von Fehlerorten und Fehlerwerten aus den Fehlerortungspolynomen und den Fehlerwertpolynomen, die mit der Euklidalgorithmus-Verarbeitungsschaltung ermittelt wurden;

einen Korrekturprozessor (7) zum Korrigieren von Fehlern des empfangenen Codeworts aufgrund von Fehlerorten und Fehlerwerten, die man mit dem Chien-Sucher erhalten hat,

wobei der abgewandelte Syndromgenerator (3) und der Löschortungs-Polynomgenerator (4) gemeinsam mit der Euklidalgorithmus-Verarbeitungsschaltung verwendet werden.

3. Decoder nach Anspruch 2, worin die Euklidalgorithmus-Verarbeitungsschaltung einen Teiler und eine Produktsummen-Verarbeitungsschaltung für den Euklidalgorithmus enthält, und

der abgewandelte Syndromgenerator (3) gemeinsam mit dem Teiler der Euklidalgorithmus-Verarbeitungsschaltung verwendet wird, und der Löschortungs-Polynomgenerator (4) gemeinsam mit der Produktsummen-Verarbeitungsschaltung für den Euklidalgorithmus verwendet wird.

4. Decoder nach Anspruch 3, worin:

der Teiler der Euklidalgorithmus-Verarbeitungsschaltung Fehlerortungspolynome durch das Ausführen des Divisionsvorgangs erzielt, bis die Koeffizienten des höchsten Grades der Dividendenpolynome ungleich null werden, während er für jeden Divisionsvorgang die Daten von Registern austauscht, in denen Koeffizienten der Dividendenpolynome und Divisionspolynome gespeichert sind, und abgewandelte Syndrome mit Hilfe der Register für die Dividendenpolynome erzeugt.

Decoder nach Anspruch 3, worin:

die Produktsummen-Verarbeitungsschaltung (4) für den Euklidalgorithmus die Löschortungspolynome erzeugt und dabei Register zur Multiplikation verwendet.

6. Decoder, umfassend:

eine erste Zellengruppe, die eine Anzahl erster verbundener Zellen umfaßt, von denen jede Zelle erste und zweite Register (12) aufweist;

einen ersten Addierer (11) und einen ersten Multiplizierer (13);

einen abgewandelten Syndromgenerator (3) zum Erzeugen abgewandelter Syndrome mit Ausnahme der Löschortungsinformation aus den Syndromen, wobei das erste Register (12), der erste Addierer (11) und der erste Multiplizierer (13) verwendet werden, und die Syndrome und die Löschortungsdaten für die erste Zellengruppe und für das Speichern im ersten Register (12) bereitgestellt werden;

einen Euklidalgorithmusteiler zum Ermitteln von Fehlerwertpolynomen aus den abgewandelten Syndromen und den Löschortungspolynomen, die im ersten Register (12) gespeichert sind, wobei die ersten und zweiten Register, der erste Addierer (11) und der erste Multiplizierer (13) verwendet werden;

eine zweite Zellengruppe, umfassend eine Anzahl zweiter verbundener Zellen, von denen jede ein drittes, viertes und fünftes Register aufweist, einen zweiten Addierer und einen zweiten Multiplizierer und einen Löschortungs-Polynomgenerator zum Bereitstellen der Löschortungsdaten für die Zellengruppe und zum Erzeugen von Löschortungspolynomen mit Hilfe des dritten Registers, des zweiten Addierers und des zweiten Multiplizierers, und um sie im dritten Register zu speichern;

eine Euklidalgorithmus-Verarbeitungsschaltung nach Anspruch 1, die mit einem Quotienten aus dem Euklidteiler beliefert wird und ein Fehlerortungspolynom ermittelt, und zwar mit Hilfe der dritten, vierten und fünften Register, des zweiten Addierers und des zweiten Multiplizierers aus den Löschortungspolynomen, die im dritten Register gespeichert sind, und aus dem Quotient;

einen Chien-Sucher (6) zum Bestimmen von Fehlerorten und Fehlerwerten aus den Fehlerortungspolynomen und den Fehlerwertpolynomen, die mit dem Teiler bzw. der Produktsummen-Verarbeitungsschaltung für den Euklidalgorithmus ermittelt wurden; und

einen Korrekturprozessor (7) zum Korrigieren von Fehlern empfangener Codewörter aufgrund von Fehlerorten und Fehlerwerten, die man mit dem Chien-Sucher (6) erhalten hat.