NL9301240A - Foutcorrectiesysteem met selecteerbare foutcorrectiecapaciteiten. - Google Patents

Description

Foutcorrectiesysteem met selecteerbare foutcorrectie-capaciteiten.

UITVINDINGSGEBIF.D

De uitvinding heeft algemeen betrekking op foutcorrectie van data en meer in het bijzonder op foutcorrectiecodering met selecteerbare foutcorrectiecapaciteiten.

UITVINDINGSACHTERGRQND

Het belang van foutcorrectiecodering van data in digitale computersystemen is in grote mate toegenomen, naarmate de dichtheid van de data, geregistreerd op massa-opslagmedia, meer in het bijzonder magnetische schijven, is toegenomen.

Met hoger registrerende dichtheden kan een geringe onvolmaaktheid in het registratieoppervlak van een schijf een grote hoeveelheid data bederven. Teneinde teloor gaan van deze data te vermijden, worden foutcorrectiecodes ("ECC's") gebruikt om, zoals de naam zegt, de foutieve data te corrigeren.

Alvorens een rij datasymbolen wordt geregistreerd op een schijf, is zij mathematisch gecodeerd voor het vormen van ECC- of redundantiesymbolen. De redundantiesymbolen worden dan gehecht aan de datarij voor het vormen van codewoorden - datasymbolen plus redundantiesymbolen - en de codewoorden worden dan opgeslagen op de schijf. Wanneer de opgeslagen informatie moet worden uitgelezen, worden de codewoorden, welke de datasymbolen bevatten, teruggewonnen van de schijf en mathematisch gedecodeerd. Tijdens decoderen worden mogelijke fouten in de data gedetecteerd en, indien mogelijk, gecorrigeerd door middel van manipulatie van de redundantiesymbolen. (Voor een gedetailleerde beschrijving van decoderen, zie Peterson and Weldon, Error Correcting Codes, 2nd Edition, MIT Press, 1972).

Opgeslagen digitale codewoorden kunnen multiple fouten bevatten. Eén van de meest effectieve soorten ECC, gebruikt voor de correctie van multiple fouten, is een Reed-Solomon code (zie Peterson and Weldon, Error Correcting Codes'!.

Foutdetectie- en eorrectietechnieken voor Reed-Solomon ECC's zijn welbekend.

Een (n,k) Reed-Solomon ECC codeert k datasymbolen voor het vormen van n-k, of r, redundantiesymbolen. De (n,k) code heeft een minimum afstand van D = r+1, hetgeen betekent, dat elk codewoord verschilt van elk ander codewoord met ten minste r+1 symbolen. Het aantal fouten, welke een ECC kan corrigeren, is direkt gerelateerd aan het aantal redundantiesymbolen, welke zij voortbrengt. Elk redundantie-symbool kan worden gebruikt om te bepalen, dat wil zeggen op te lossen, of een foutlokatie of een foutwaarde. Zodoende zijn twee redundantiesymbolen nodig om elke fout te corrigeren. De (n,k) code kan corrigeren tot (D-l)/2 fouten in een n-symbool codewoord.

Een uitwissing is een fout met een bekende lokatie.

Zulke fouten kunnen bijvoorbeeld worden gedetecteerd gedurende detectie en demodulatie van signalen, verkregen van een magnetische schijfaandrijving. Het systeem behoudt een wijzer voor de lokatie van de uitwissing. Dienovereenkomstig is slechts één redundantiesymbool nodig om een uitwissing te corrigeren, aangezien uitsluitend de datawaarde van de uitwissing onbekend is. De (n,k) code kan derhalve e uitwissingen, 0 < e < D-l, corrigeren en [D-l)-e]/2 fouten.

Het is mogelijk, dat een systeemontwerper geen Reed-Solomon ECC kan vinden, die in staat is om een gewenst aantal fouten te corrigeren in de k datasymbolen, dat wil zeggen, een code, welke R redundantiesymbolen genereert door k datasymbolen te coderen. De ontwerper kan bijvoorbeeld een code vinden, die R-t redundantiesymbolen genereert door de k datasymbolen te coderen en codewoorden formuleert met k+R+t symbolen. Een dergelijke code is evenwel niet aanvaardbaar voor een systeem, dat aan een codewoord een (k+R) symboolopslagruimte heeft toegekend. Dienovereenkomstig kan de ontwerper een ECC kiezen met bijvoorbeeld een grote lengte, een (N,K) code, waarbij N > n en K > k, welke N-K, of R redundantiesymbolen produceert, en vervolgens het codewoord afkappen door sommige van de datasymbolen te elimineren. Dit proces wordt vaak "verkorten" van de code genoemd, maar hier zal de term afkappen gebruikt worden, teneinde verwarring met het hier beschreven systeem te vermijden.

Afkappen van een (N,K) code bestaat uit het selecteren als geldige codewoorden van slechts die codewoorden van de oorspronkelijke (N,K) ECC, welke "in beginsymbolen bevatten, die corresponderen met een voorbepaald patroon, bijvoorbeeld, i beginsymbolen allemaal nul, waarbij K-i=k.

In een binaire code zijn er bijvoorbeeld 2 van deze codewoorden. De geselecteerde codewoorden vormen een (N-i, K-i) subcode van de (N,K) code. Indien de i beginsymbolen worden gewist, worden codewoorden met k datasymbolen en R redundantiesymbolen geproduceerd. Aangezien deze codewoorden hetzelfde aantal redundantiesymbolen inhouden als codewoorden van de oorspronkelijke (N,K) code, kan hetzelfde aantal fouten worden gecorrigeerd. Afgekapte codes worden in detail besproken in Peterson and Weldon, Error Correcting Codes.

Om fouten in de afgekapte codewoorden te corrigeren, zou het systeem de afgekapte symbolen kunnen vervangen en conventionele foutcorrectietechnieken gebruiken, ontworpen voor (N,K) code. Het systeem manipuleert zodoende de R redundantiesymbolen, teneinde foutsyndromen te genereren, en bepaalt uit deze de foutlokaties en foutwaarden. Alternatief kan het systeem, aangezien de gewiste begin-nulsymbolen, de manipulaties van de redundantiesymbolen, die de foutcorrectiesyndromen voortbrengen, niet beïnvloeden, het foutsyndroom voortbrengen zonder de afgekapte symbolen te vervangen. Wanneer het systeem evenwel een foutlokatie i bepaalt onder gebruikmaking van deze syndromen, moet het systeem rekening houden met de afgekapte maximale codewoord-lengte, welke N-i symbolen bedraagt. Onder gebruikmaking van een of ander van deze wijzen van aanpak manipuleert het systeem de R redundantiesymbolen voor het corrigeren van tot i R/2 codewoordfouten in de N-i codewoordsymbolen.

Indien een bekend informatieverwerkingssysteem voor bepaalde toepassingen de capaciteit vereist om een groot aantal fouten in de data te corrigeren, moet het systeem een krachtige ECC gebruiken, welke een groot aantal redundantie- symbolen produceert voor een gegeven aantal datasymbolen. Indien het systeem soms, of voor bepaalde toepassingen, kan werken met een gereduceerde foutcorrectiecapaciteit, kan het een minder krachtige ECC gebruiken, welke minder redundantiesymbolen voor hetzelfde aantal data voortbrengt.

Het systeem kan zodoende een grotere of kleinere hoeveelheid opslagruimte toekennen aan een gegeven codewoord in afhankelijkheid van de foutcorrectievereisten. Wanneer een systeem bijvoorbeeld informatie opslaat op een relatief nieuwe schijf, kan het systeem minder redundantiesymbolen gebruiken, dat wil zeggen een minder krachtige ECC, teneinde de data te beschermen, dan het gebruikt voor het beschermen van data, opgeslagen op een oudere, potentieel verslechterde schijf. Overeenkomstig kan het systeem in wezen de schijven aanslaan volgens hun totale integriteit met geassocieerde mate van fouten, en meer of minder krachtige ECC's gebruiken voor het beschermen van de informatie, opgeslagen op de schijven in afhankelijkheid van hun rangorde.

Het systeem kan tevens een meer of minder krachtige code gebruiken in afhankelijkheid van het soort opslagmedium, dat gebruikt wordt. Een systeem, dat de capaciteit bezit om informatie op te slaan op zowel optische als magnetische schijven, kan bijvoorbeeld een meer krachtige code gebruiken voor data, welke worden opgeslagen op de optische schijf. De kwaliteit van de optische schijven is in het algemeen niet zo goed als de kwaliteit van de magnetische schijven, en zodoende is de kans op het hebben van een defekt in de optische schijf hoger, en de kans, dat dat defekt een relatief groot aantal datasymbolen beïnvloedt, is tevens hoger dan de waarschijnlijkheden, geassocieerd met magnetische schijven. Dienovereenkomstig beschermt het systeem de informatie met een ECC, welke een groter aantal fouten kan corrigeren.

In netwerkinformatieverwerkingssystemen kunnen data, die over een lange afstand worden gezonden, worden beschermd met meer redundantiesymbolen dan data, die gezonden worden over een kortere afstand. Het systeem beschermt zodoende de data tegen transmissiefouten, die waarschijnlijker zullen optreden, wanneer data worden getransmitteerd over langere communicatiewegen.

Om zowel codewoorden met grote aantallen redundantiesymbolen alsook codewoorden met minder redundantiesymbolen voort te brengen, coderen bekende informatieverwerkingssystemen de datasymbolen onder gebruikmaking van verschillende, dat wil zeggen meer en minder krachtige ECC's. Dergelijke systemen moeten verschillende codeer- en decodeerorganen hebben om te gebruiken met de respectievelijke ECC's. Wat gewenst is, is een mechanisme, waardoor een systeem een enkelvoudig codeer- en decodeerorgaan kan gebruiken om deze codewoorden te coderen en te decoderen.

Dit is een ander probleem dan het probleem, opgelost door het afkappen van een ECC, aangezien het het aantal codewoordredundantiesymbolen is, dat verandert, niet het aantal codewoord-datasymbolen. Daarom zijn, hoewel de technieken, gebruikt voor het genereren van foutsyndromen voor een (N,K) code gebruikt kunnen worden bij een afgekapte (N-i, K-i) code, dat wil zeggen bij een code, welke hetzelfde aantal redundantiesymbolen voortbrengt, deze technieken niet geschikt voor codes, die verschillende aantallen redundantiesymbolen voortbrengen.

SAMENVATTING

Een foutcorrectiesysteem, dat een enkel codeerorgaan gebruikt met selecteerbare niveaus van redundantie voor het coderen en decoderen van data, produceert voor hetzelfde aantal datasymbolen codewoorden met selecteerbare aantallen redundantiesymbolen. Het codeerorgaan codeert k datasymbolen in overeenstemming met een (n,k) Reed-Solomon ECC voor het genereren van r redundantiesymbolen. Het systeem sèlecteert een gewenst niveau van foutcorrectie van één fout tot r/2 fouten per codewoord op basis van bijvoorbeeld het medium, waarop de informatie moet worden opgeslagen. Het systeem wist dan arbitrair p van de gegenereerde redundantiesymbolen voor het voortbrengen van een (n-p) symbool-codewoord, dat k datasymbolen bevat en r-p redundantiesymbolen, waarbij (r-p)/2 overeenkomt met het geselecteerde niveau van fout-bescherming. Het codewoord vormt deel van een (n-p,k) gepunctureerde code, die minder krachtig is dan de (n,k) code.

Tijdens decoderen behandelt het systeem de p gewiste symbolen als uitwissingen en corrigeert de p uitwissingen en op tot (r-p)/2 fouten in het codewoord. Het systeem vult eerst de p gewiste symbolen in met voortoegekende symbolen, bijvoorbeeld allemaal nulsymbolen, en stelt wijzers in op deze p symbolen, alsook e wijzers voor het detecteren van uitwissinglokaties. Het systeem manipuleert dan de r-p redundantiesymbolen en de p voortoegekende symbolen voor het produceren van foutsyndromen. Gebruikmakend van de foutsyndromen en de p+e wijzers bepaalt het systeem de foutlokaties en foutwaarden voor de gedetecteerde fouten en de foutwaarden voor de e gedetecteerde uitwissingen, alsook de foutwaarden voor de p voortoegekende symbolen.

Bij een voorkeursuitvoering wist het systeem de laatste p van de redundantiesymbolen. Tijdens het decoderen maakt het systeem voordelig gebruik van de cyclische eigenschap van de Reed-Solomon code en decodeert het (n-p) symbool-codewoord, alsof de p gewiste redundantiesymbolen de plaats innemen van p begincodewoordsymbolen, die gewist zijn bij het verkorten van het codewoord. Het systeem bespaart zodoende tijd door het invullen te vermijden van de p gewiste redundantiesymbolen bij de voortoegekende symbolen tijdens decoderen. Het systeem modificeert dan de foutsyndromen, gegenereert door dit (n-p) symboolcodewoord, zodat de foutlokaties en foutwaarden, berekend onder de gebruikmaking van deze syndromen, corresponderen met de codewoordsymbolen, die essentieel verschoven p symbool-lokaties zijn, zoals in detail hieronder zal worden besproken.

Dezelfde aanpak van decoderen kan worden gedaan door een systeem, dat een (n,k) code gebruikt, welke een verkorte code is, geassocieerd met een (N,K) code, waarbij N=n-i. Het systeem decodeert het (n-p) symboolcodewoord en genereert foutsyndromen zonder de p gewiste symbolen in te vullen.

Het modificeert dan de foutsyndromen om te corresponderen met de lokaties van deze n-p symbolen in het N symboolcodewoord, welke cyclisch verschoven p symboollokaties zijn. Dit systeem wordt in detail in het onderstaande besproken.

KORTE BESCHRIJVING VAN DE TEKENINGEN

Bovengenoemde en verdere voordelen van de uitvinding zullen beter worden begrepen bij verwijzing naar de volgende beschrijving in samenhang met de bijgevoegde tekeningen, waarin: fig. 1 een blokschema toont van een informatieverwerkingssysteem , fig. 2 een blokschema is van een codeersysteem van fig.

1, fig. 3 een blokschema is van een foutcorrectiesysteem, fig. 4 een werkschema is van de operaties van het foutcorrectiesysteem, getoond in fig. 3, fig. 5 een blokschema is van een voorkeursuitvoering van een foutcorrectiesysteem, fig. 6 een werkschema is van de operaties van het foutcorrectiesysteem, weergegeven in fig. 5, fig. 7 een werkschema is van operaties van een syndroom- calculator getoond in fig. 5 bij het iteratief modificeren van foutsyndromen, en fig. 8 een werkschema is van de operaties van de syndroomcalculator bij het parallel modificeren van foutsyndromen.

GEDETAILLEERDE BESCHRIJVING

Fig. 1 toont een informatieverwerkingssysteem 2 dat data codeert, bestemd voor opslag op optische geheugeninrichtingen 6, magnetische geheugeninrichtingen 7 of voor verdere transmissie naar een netwerkknooppunt 8. Een systeemregelaar 4 levert aan een codeersysteem 10 data en besturingsinformatie. Het codeer/decodeersysteem 10 codeert de data in overeenstemming met de foutcorrectiecode (ECC) en genereert redundantiesyrabolen. Vervolgens selecteert het een aantal van de gegenereerde redundantiesymbolen en hecht deze aan de data voor het produceren van foutcorrectie-codewoorden, zoals in nader detail besproken met verwijzing naar fig. 2 hieronder. Het aantal redundantiesymbolen, dat geselecteerd wordt, kan variëren in afhankelijkheid van de bestemming van de data, bijvoorbeeld de inrichting, waarop de data moeten worden opgeslagen. Het codeersysteem 10, onder besturing van de systeemregelaar, zendt de codewoorden voor opslag naar een aangewezen optische geheugeninrichting 6 of magnetische geheugeninrichting 7, of voor verdere transmissie naar een netwerkknooppunt 8.

Pig. 2 toont het coderende deel van het codeer/decodeer-systeem 10 in groter detail. Het codeersysteem 10 omvat een codeerorgaan 12 voor het coderen van data voor foutbescherming en een codewoordzender 16 voor het zenden van datacodewoorden naar een aangewezen geheugen of netwerk-inrichting 6-8 (fig. 1). Het codeerorgaan 12 codeert op gebruikelijke wijze k datasymbolen in overeenstemming met een (n,k) Reed-Solomon code met generatorpolynoom g(x) en produceert n-k, of r, redundantiesymbolen. Het codeerorgaan 12 houdt de redundantiesymbolen tijdelijk vast in een buffer 14.

De systeemregelaar 4 (fig. 1) selecteert een niveau van foutcorrectie, gebaseerd op bijvoorbeeld het medium, waarop de informatie moet worden opgeslagen. De regelaar 4 zendt aan het codeerorgaan 12 een waarde p, 0 < p < r-2, geassocieerd met het gekozen niveau. Het codeerorgaan wist dan p van de r redundantiesymbolen en zendt de overblijvende r-p symbolen naar codewoordzender 16. De zender 16 hecht de r-p redundantiesymbolen aan de datasymbolen en zendt een (n-p) symboolcodewoord naar een aangewezen geheugeninrichting 6 of 7 (fig. 1).

Indien bijvoorbeeld het informatieverwerkingssysteem de data opslaat op een magnetisch geheugen, dat een relatief hoge foutgraad heeft, vereist het de volledige (n-k)/2 foutcorrectiecapaciteiten van de code. De regelaar zendt dan aan het codeerorgaan 12 een waarde p=0. Het codeerorgaan zendt dan naar de codewoordzender 16, parallel of op een symbool-seriewijze, alle r van de redundantiesymbolen. De zender 16 hecht de r redundantiesymbolen aan de k datasymbolen voor het vormen van een n symboolcodewoord:

Indien het systeem de data opslaat op een schijf, welke een lagere foutgraad bezit, en het zodoende niet nodig is om de volledige foutcorrectiecapaciteiten van de code te gebruiken, zendt de systeemregelaar 4 aan het codeerorgaan 12 een waarde p, waarbij 0 < p < r-2. Het codeerorgaan 12 wist dan arbitrair p symbolen van de r redundantiesymbolen in buffer 14 en zendt aan de codewoordzender de overblijvende r-p redundantiesymbolen. De zender 16 hecht de r-p redundantiesymbolen aan de k datasymbolen en produceert een (n-p) symboolcodewoord:

waarin cr ···· co de redundantiesymbolen zijn, naar voren gebracht door het codeerorgaan 12. De zender 16 zendt dan het codewoord naar de aangewezen geheugeninrichting.

Fig. 3 toont een foutcorrectiesysteem 20, dat is opgenomen in het codeer/decodeersysteem 10 van fig. 1, en fig. 4 is een werkschema, dat de operaties van het systeem 20 beschrijft, dat fouten detecteert en corrigeert in codewoorden, verkregen van bijvoorbeeld een magnetische geheugeninrichting 7. Een uitwissingsdetector 22 detecteert uitwissingen in een teruggewonnen (n-p) symboolcodewoord en bewaart in een buffer 24 voor elke gedetecteerde uitwissing een wijzer aan de geassocieerde codewoordsymboollokatie (stap 30). De detector 22 vermeerdert tevens een uitwissingsteller 33 voor elke gedetecteerde uitwissing (stap 32). indien de keten e uitwissingen detecteert, vermeerdert zij zodoende de uitwissingsteller 33 e maal en formuleert en slaat e wijzers op. De uitwissingsdetectie-keten hecht dan e wijzers, welke corresponderen met de lokaties van de p gewiste symbolen, aan deze e wijzers en vermeerdert de uitwissingsteller 33 tot een telling van e+p (stap 34).

Vervolgens vergelijkt een vergelijkingsketen 24 het aantal uitwissingen, dat wil zeggen e+p, met de minimum afstand, D = r+1, geassocieerd met de (n,k) code om vast te stellen, of de code dat aantal uitwissingen kan corrigeren (stap 36). Indien het aantal uitwissingen ten minste één minder is dan de codeafstand, dat wil zeggen, indien e+p < D-l, is de code potentieel in staat om de uitwissingen te corrigeren. In het andere geval kan de code de uitwissingen niet corrigeren en de vergelijkingsketen 24 zendt een foutsignaal aan een foutcorrector 28. In reactie op het foutsignaal labelleert de foutcorrector 28 de codewoorddatasymbolen als fout en zendt hen en de label naar de vraagketen (niet getoond) (stap 37).

Indien e+p < D-l, activeert de vergelijkingsketen 24 een syndroomcalculator 26, die de p gewiste redundantiesymbolen invult met voorbepaalde symbolen, bijvoorbeeld allemaal nul symbolen, teneinde een n symbool codewoord te produceren (stap 38). De syndroomcalculator 26 manipuleert dan de n symboolcodewoordsymbolen onder gebruikmaking van gebruikelijke technieken voor het produceren van codewoord-foutsyndromen Sj (stap 40): k=n-l

Sj = Σ c^cpk voor j = Lr, Lr+1, Lr+2, ..., Lr+D-2 k=0 waarin c'^ het k-de symbool is van het ontvangen of teruggewonnen n-symboolcodewoord, Lr de laagste wortel is van de generatorpolynoom g(x) en de vermenigvuldigings- en sommeringsoperaties zijn Galois Field operaties. Bij gebruikelijke foutcorrectieketens worden de gegenereerde syndromen gecontroleerd om te bepalen, of zij allemaal nul zijn, hetgeen aangeeft, dat er geen fouten zijn in het codewoord. Het foutcorrectiesysteem 20 kan deze stap overslaan, indien het codewoord geassocieerd is met p>0 uitwissingen.

Het aantal fouten, dat kan worden gecorrigeerd in een codewoord, dat p gewiste symbolen heeft, die worden behandeld als p uitwissingen, bedraagt (r-p)/2. Indien een verdere "e" uitwissingen worden gedetecteerd tijdens decoderen, kan een maximum van [(r-p)-e]/2 fouten worden gecorrigeerd samen met de e+p uitwissingen. De syndroomcalculator selecteert vervolgens een maximum aantal fouten, t, die moeten worden gecorrigeerd, waarbij 0<t<[(D-l)-(e+p)]/2 (stap 42). De calculator selecteert t zo, dat deze het foutcorrectievermogen benut van de code, terwijl tegelijk de kans op een aanvaardbare waarde gehouden wordt, dat de foutcorrectieketen per vergissing niet foutieve codewoordsymbolen zal "corrigeren". Door deze niet foutieve symbolen te "corrigeren", kan de foutcorrectieketen het ontvangen codewoord transformeren tot een ander codewoord van de (n,k) code, hetgeen in de data een niet detecteerbare decodeerfout introduceert. Des te kleiner de gekozen t is, des te kleiner is de kans, dat de foutcorrectieketen zo'n fout zal maken.

De foutcorrectieketen 28 ontvangt de syndromen Sj van de syndroomcalculator 26 en de e+p uitwissingswijzers van de uitwissingsdetectieketen 23 en corrigeert fouten in het codewoord door op gebruikelijke wijze een t-fout en (e+p)-uitwissingscorrectieprocedure uit te voeren (stap 44).

Indien de foutcorrectieketen 28 alle t+e gedetecteerde fouten en uitwissingen kan lokaliseren en corrigeren, zendt de foutcorrectieketen de gecorrigeerde codewoorddata-symbolen naar de inrichting (niet getoond), welke deze opvroeg. Indien de foutcorrectieschakeling niet alle fouten kan corrigeren, labelleert zij de datasymbolen als foutief en zendt ze samen met de label naar de vragende inrichting.

Het decodeersysteem kan tot (r-p-e)/2 gedetecteerde fouten en e uitwissingen corrigeren in elk codewoord, geformuleerd onder gebruikmaking van r-p van de redundantie-symbolen, gegenereerd door het coderen van de data in overeenstemming met de oorspronkelijke (n,k) ECC. Het decodeersysteem behoeft niet separate decodeerorganen te hebben voor codewoorden, die verschillende aantallen redundantiesymbolen bevatten. Zodoende kan een enkel decodeerorgaan worden gebruikt voor het decoderen van codewoorden, geassocieerd met krachtige foutprotectie (r redundantiesymbolen) en codewoorden, geassocieerd met minder krachtige foutprotectie (minder dan r redundantiesymbolen).

In een voorkeursuitvoeringsvorm zijn de symbolen die gewist worden de laatste p van de r redundantiesymbolen. Het systeem vormt zodoende een codewoord door de eerste r-p redundantiesymbolen te hechten aan k datasymbolen. Het systeem zou het codewoord kunnen decoderen door p voorbepaalde symbolen aan te hechten aan het eind van een ontvangen codewoord om de gewiste symbolen op te vullen en t fouten en e+p uitwissingen te corrigeren onder gebruikmaking van gebruikelijke technieken, zoals boven besproken. Een voorkeursdecoderingstechniek benut evenwel de cyclische eigenschappen van Reed-Solomon codes en decodeert het codewoord alsof de p gewiste redundantiesymbolen de plaats innemen van de p beginsymbolen, die genegeerd zijn bij het inkorten van het codewoord. Het codewoord komt conceptueel overeen met:

cn-l'cn-2· 'cn-k· cn-k-l' 'cp+2'cp+l'CP

|. .p gewiste.. |.......data.........|----r-p redundantie. — | symbolen symbolen symbolen

Het systeem genereert foutsyndromen onder gebruikmaking van het (n-p)-symboolcodewoord, en modificeert vervolgens de syndromen om te compenseren voor de p gewiste symbolen, zoals in meer detail hieronder zal worden besproken met verwijzing naar fig. 5. Dienovereenkomstig vermijdt het systeem het invullen van de p gewiste symbolen, en het kan zodoende beginnen de foutsyndromen te berekenen, zodra het het laatste codewoordsymbool Cp ontvangt.

Indien de (n,k) ECC, gebruikt in codeerorgaan 12 (fig.

2) een verkorte versie is van een (N,K) code, waarbij K = k+i, moet een decodeerorgaan, wanneer het de foutsyndromen modificeert om te compenseren voor het cyclische verschuiven van het p symbool, tevens de voorafgaand gewiste i begincodewoordsymbolen in rekening brengen, hier weergegeven als i allemaal nul symbolen. Het ontvangen codewoord correspondeert conceptueel met:

00000...0000 cn-1, cn_k cn-k-i'*·'cn+i'CP

|.p gewiste.|..i gewiste..|____data----|..r-p redundantie..| symbolen begin nul symbolen symbolen symbolen waarbij het eerste niet-nul datasymbool, dat zich bevindt in lokatie N-i in een N-symboolcodewoord, verschoven is naar een lokatie (N-i)-p, wanner de laatste p redundantiesymbolen cyclisch verschoven 21jn naar lokaties aan het begin van het N symboolcodewoord.

Als het aantal wissingen toeneemt, gaat het meer en meer tijd kosten voor de foutcorrectieketen 28 (fig. 3) om syndromen te berekenen, indien de keten deze in serie berekent, of wordt de syndroomberekeningsketen meer en meer complex voor het berekenen van syndromen, indien de keten deze parallel berekent. Indien een maximum waarde van t+e is gespecificeerd, modificeert een voorkeursuitvoering van het foutcorreetiesysteem de berekende syndromen op basis van het aantal wissingen, dat wil zeggen op basis van de waarde p, zodat deze syndromen corresponderen met syndromen, berekend voor een codewoord van een (n-p,k) gepunctureerde code, zoals besproken in meer detail hieronder met verwijzing naar fig. 5 Het systeem behoeft dan slechts polynomen te berekenen van de graad t+e in plaats van de graad t+e+p, hetgeen een besparing oplevert in decoderingstijd.

Het systeem gebruikt de gemodificeerde syndromen en een t fout en e uitwissingdecodeerprocedure om t+e foutwaarden en t foutlokaties te bepalen voor het (n-p) symboolcodewoord. Aangezien het systeem eerder compenseerde voor p gewiste redundantiesymbolen door de syndromen te modificeren, kan het systeem deze symbolen nu negeren. Het systeem moet evenwel de t+e berekende foutwaarden modificeren, teneinde deze te conformeren aan het cyclisch verschoven codewoord, zoals in het onderstaande besproken met verwijzing naar de fig. 7 en 8.

Fig. 5 toont een systeem 50 voor het corrigeren van fouten in een codewoord onder gebruikmaking van een t-fout en e-uitwissingsdecoderingsprocedure. Nadat de e uitwissingen zijn gedetecteerd door uitwissingsdetector 22 en de telling e+p is vergeleken met de codeafstand D door een vergelijkingsketen 24, bepaalt een syndroomcalculator 52 op gebruikelijke wijze syndromen Sj, j=Lr, Lr+l,...Lr+D-2.

De syndromen kunnen worden voorgesteld door een polynoom S(x), S(x) = SLr + SLr+lX + SLr+2x2 + ’mmSLr+O-2^ ^

De codewoordlokaties, die corresponderen met de p gewiste symbolen, kunnen worden voorgesteld door een polynoom U(x) = 1 + U·^ + U2x2 + ... + UpxP, die kan worden herschreven als: U(x) = (αη_1χ + 1)(αη-2χ + 1)...(αη-ρχ + 1), waarin de p gewiste symbolen zijn verschoven naar de lokaties opgegeven in tabel 1; positie van onverschoven positie van verschoven redundantiesymbool symbool 0 n-p 1 n-p+1 2 n-p+2 h n-p+h p-1 n-p+(p-l)=n-l TABEL 1

De gemodificeerde syndromen S'(x) zijn dan: S'(x) = (S(x)U(x).

Indien de (n,k) code een verkorte versie is van een (N,K) code, wordt U(X) U(x) - (an-1x + 1)(an_2x + l)...(an_px + 1) U(X) kan worden voorberekend voor verschillende waarden van p en worden opgeslagen in de syndroomcalculator of iteratief bepaald voor elk codewoord, zoals in het onder staande besproken roet verwijzing naar de fig. 6 en 7,

De laagste p termen van de gemodificeerde syndroomvergelijking kunnen worden verwaarloosd, aangezien deze termen verband houden met de p gewiste redundantie-symbolen, en de overige termen die zijn, vereist om de foutwaarden en foutlokaties op te lossen. De foutcorrector-keten 54 maakt dan gebruik van de overblijvende gemodificeerde syndromen en de wijzers aan de e gedetecteerde uitwissingslokaties om tot t foutlokaties "ei" en t+e foutwaarden "ev" te bepalen.

Aangezien p kan worden geselecteerd als elke waarde tussen o en r-2, is U(x) niet een constante. De fig. 6 en 8 zijn werkschema's die respectievelijk de operaties laten zien van de syndroomcalculator 52 van fig. 5 bij het modificeren van de syndromen Sj op iteratieve wijze en bij het modificeren van de syndromen parallel.

Met verwijzing nu naar fig. 6 zet de calculator 52 een interne in telling tot c = 0 (stap 54). Vervolgens wordt de telling vermeerderd met 1 en vergeleken met p (stappen 56-58). Indien de telling c minder dan p is, vermeerdert de calculator Lr met 1 en vermindert D met 1 (stap 60). De calculator werkt dan de syndromen bij (stap 62) tot:

Sj = SI_1an“C + Sj I = Lr + (D-2), Lr + (D-2)-l, ..., Lr

Indien de (n,k) code een verkorte versie is van een (N,K) code, wordt de waarde N gebruikt in plaats van n.

De calculator vermeerderd de telling c wederom met 1 en vergelijkt deze met p. Indien c<p, vermeerdert de calculator Lr met 1, vermindert D met 1 en werkt de syndromen bij (stappen 60-62). De calculator herhaalt deze operaties, totdat de telling c hoger is dan p, hetgeen aangeeft, dat de gemodificeerde syndromen corresponderen met het codewoord, dat gepunctureerd is door de wissing van p symbolen. De calculator zendt dan de gemodificeerde syndromen naar de foutcorrectorketen 54 (stap 64).

De foutcorrectorketen 54 gebruikt de gemodificeerde syndromen om op een gebruikelijke wijze onder gebruikmaking van een t-fout en e-uitwissingsfoutcorrectieprocedure op tot t foutlokaties en t+e foutwaarden te bepalen. De foutcorrectorketen moet dan de foutwaarden manipuleren teneinde te compenseren voor de cyclische verschuiving van de p-lokatie van de codewoordsymbolen. Dienovereenkomstig produceert de foutcorrectorketen voor elke foutwaarde, ev, bepaald onder gebruikmaking van de gemodificeerde syndromen, een werkelijke foutwaarde, "av": av = ev/f t waarin f = U(a”ei), met ei de fout of uitwissingslokatie, geassocieerd met de foutwaarde en, zoals boven besproken, U(x) = 1 + UiX + U2x2 + ... UpxP.

Zodoende f = (an“1-ei + 1) (an“2_ei + 1) ---- (crn"P-ei + 1), met de waarde N gebruikt voor n, indien de (n,k) code een verkorte versie is van de (N,K) code.

De polynoom f kan iteratief of parallel worden bepaald. Fig. 7 is een werkschema van de operaties van de foutcorrectieketen 54 bij het iteratief bepalen van de polynoom. Fig. 8f hieronder besproken, is een werkschema van de operaties van de foutcorrectieketen 54 bij het parallel bepalen van de polynoom.

Om f iteratief te bepalen, initialiseert de foutcorrectieketen 54 f tot l en een telling, c, tot 0 (stap 66). De correctieketen vermeerdert de telling met l (stap 68), vergelijkt de telling met p (stap 70) en indien de telling minder dan of gelijk is aan p, vermenigvuldigt de correctieketen f met (α11 c ei +1) en produceert een bijgewerkte f (stap 72). De foutcorrectieketen vermeerdert wederom de telling c met 1, vergelijkt deze met p, en indien de telling kleiner is dan of gelijk aan p, vermenigvuldigt zij f wederom met (a11 c ei + 1), enz. Wanneer de telling p overschrijdt, deelt de correctieketen ev door f om de geassocieerde werkelijke foutwaarde, av, te produceren, welke correspondeert met het symbool in lokatie ei (stap 74).

De foutcorrectieketen combineert uiteindelijk de werkelijke foutwaarde, av, met het codewoordsymbool in lokatie ei en corrigeert het symbool (stap 76). De correctieketen kan elke fout corrigeren, zodra de passende werkelijke foutwaarde bepaald is, of kan de werkelijke foutwaarden opslaan en deze combineren met de corresponderende codewoordsymbolen in één operatie.

Fig. 8 toont de werking van de syndroomcalculator 52 (fig. 5), welke de foutsyndromen Sj modificeert in één stap door U(x) voor te berekenen en de syndromen bij te werken tot si - Sj.püp + Vp+iVi + · ·' + si-iUl + Sl I = Lr + (D-2),...,Lr + p.

De syndroomcalculator heeft of een geheugen voor het opslaan van de waarden voor de coëfficiënten van U(x) voor alle mogelijke waarden van p, of een keten welke de coëfficiënten van U(X) berekent voor een geselecteerde waarde van p (stap 78). De calculator modificeert dan de syndromen door deze te vermenigvuldigen met de passende coëfficiënten van de voorberekende U(X) (stap 80) teneinde voort te brengen: sl = SI-pUP + SI(P-1) Vl + ·· + SI-1 Ü1 + SI·

Het systeem gebruikt dan deze gemodificeerde syndromen om foutlokaties, ei, te bepalen en foutwaarden, ev, op gebruikelijke wijze.

Wanneer de foutwaarden, ev, eenmaal bepaald zijn, modificeert het systeem deze teneinde te corresponderen met het verschoven codewoord. Het modificeert derhalve of iteratief de foutwaarden, zoals besproken met verwijzing naar fig. 6 hierboven, of het gebruikt de voorberekende polynoom (U(x) voor de geselecteerde p en berekent voor elke gedetecteerde fout en uitwissingslokatie, ei: f = UjcT6·^ + . . . + U2a”ei2 + U-^ot”+ 1 en bepaalt de corresponderende werkelijke foutwaarde, av: av = ev/f

De foutcorrectieketen 54 corrigeert dan de fout aan lokatie ei door de werkelijke foutwaarde te combineren met het codewoordsymbool, zoals boven besproken met verwijzing naar fig. 6.

Samengevat codeert en decodeert het foutcorrectiesysteem data in overeenstemming een selecteerbaar aantal redundantiesymbolen, hetgeen data-selecteerbare niveaus van foutbescherming mogelijk maakt. Het systeem gebruikt een enkel codeerorgaan voor het produceren van codewoorden, die k datasymbolen bevatten, en een geselecteerd aantal redundantiesymbolen tussen 2 en r symbolen. Verder gebruikt het systeem een enkel decodeerorgaan voor het decoderen van de verschillend gedimensioneerde codewoorden en om in elk codewoord te corrigeren tot aan geschikt aantal fouten, waarbij het aantal fouten voor elke code gerelateerd is aan het geselecteerde aantal redundantiesymbolen.

In de voorkeursuitvoering wist het systeem de laatste p van de redundantiesymbolen, waarbij r-p het gekozen aantal redundantiesymbolen is voor een (r-p)/2 gewenste foutcorrectiecapaciteit, en produceert (n-p)-symbool- codewoorden van een (n-p,k) gepunctureerde code. Later decodeert het de codewoorden alsof de p gewiste symbolen de symbolen zijn, gewist bij het verkorten van het codewoord en produceert foutsyndromen zonder de p gewiste symbolen in te vullen. Het modificeert dan de foutsyndromen op geschikte wijze om te compenseren voor de p gewiste symbolen. Met gebruikmaking van deze foutsyndromen corrigeert het systeem tot aan t fouten en e uitwissingen onder gebruikmaking van een t-fout en een e uitwissingcorrectieprocedure voor het bepalen van foutlokaties en fout- en uitwissingswaarden. Het modificeert dan de foutwaarden om te compenseren voor de p-symbool-cyclische verschuiving van codewoordsymbolen, toe te schrijven van de behandeling van de gewiste redundantie-symbolen als de p beginsymbolen, die gewist zijn bij het verkorten van het codewoord.

De voorgaande beschrijving was beperkt tot specifieke uitvoeringen van de uitvinding. Het zal evenwel duidelijk zijn, dat variatie en modificaties kunnen worden aangebracht bij de uitvinding onder behoud van sommige of alle voordelen ervan.

Claims (7)

1. Foutcorrectiesysteem, met het kenmerk, dat dit systeem omvat: A. een codeerorgaan voor het coderen van k datasymbolen in overeenstemming met een afstand D (n,k) Reed-Solomon foutcorrectiecode, en het produceren van r=n-k redundantie-symbolen, B. een selectieorgaan voor het selecteren van een foutcorrectieniveau, welk selectieorgaan een geassocieerde waarde p instelt, waarbij 0 < p < r-2, C. een orgaan voor het wissen van p van de r redundantiesymbolen, en D. een codewoordorgaan voor het vormen van een (n-p)-symboolcodewoord, welk codewoordorgaan r-p redundantiesymbolen aanhecht aan de k datasymbolen.

2. Foutcorrectiesysteem volgens conclusie 1, m e t het kenmerk, dat het systeem verder omvat: E. een uitwissingsdetectieorgaan voor het detecteren van e uitwissingen in een codewoord, e > 0, F. een orgaan voor het met voorbepaalde symbolen vullen van de codewoordlokaties, corresponderende met de p gewiste redundantiesymbolen, en het produceren van een n-symboolcodewoord, G. een syndroomcalculator voor het berekenen van foutsyndromen voor het n-syraboolcodewoord, H. een vergelijkingsorgaan voor het vergelijken van e+p en D, welk vergelijkingsorgaan een foutsignaal laat opkomen, indien e+p > D-l, en I. een foutcorrectieorgaan voor het manipuleren van de foutsyndromen voor het bepalen van foutlokaties en geassocieerde foutwaarden, en het corrigeren van fouten en uitwissingen in het codewoord door de foutwaarden te combineren met de codewoordsymbolen in de geassocieerde foutlokaties, indien het vergelijkingsorgaan het foutsignaal niet heeft doen opkomen, terwijl het foutcorrectieorgaan reageert op een opgekomen foutsignaal door de codewoorddata te labelleren als foutief en er van af te zien om de fout- syndromen te manipuleren.

3. Foutcorrectiesysteem volgens conclusie l, m e t het kenmerk, dat het orgaan voor het wissen van p van de r redundantiesymbolen de p minst significante redundantie-symbolen wist.

4. Foutcorrectiesysteem volgens conclusie 3, m e t het kenmerk, dat het systeem verder omvat: E. een uitwissingsdetectieorgaan voor het detecteren van e uitwissingen in een codewoord, e > 0, welk uitwissings-detecteringsorgaan voor elke gedetecteerde fout een wijzer formuleert aan de geassocieerde codewoordsymboollokatie, F. een syndroomcalculator voor het berekenen van foutsyndromen, S(x) voor het n-symboolcodewoord, welke syndroomcalculator de syndromen modificeert door deze te vermenigvuldigen met een polynoom U(x), geassocieerd met de p gewiste symbolen, G. een vergelijkingsorgaan voor het vergelijken van e+p en D, welk vergelijkingsorgaan een foutsignaal aanneemt indien e+p > D-l, en H. een foutcorrectieorgaan voor het corrigeren van fouten en uitwissingen in het codewoord, welk foutcorrectieorgaan omvat i. een orgaan voor het manipuleren van de foutsyndromen om foutlokaties vast te stellen en foutwaarden, ev, geassocieerd met de foutlokaties en de uitwissingswij2ers, ii. een foutwaardemodificeringsorgaan voor het modificeren van de foutwaarden, welk foutwaardemodificeringsorgaan een werkelijke foutwaarde, av, bepaald, geassocieerd met een foutwaarde, ev, door bepaling van av - ev/f . . —ei waarin f is ü(a ) en ei de lokatie is van een gedetecteerde fout of gedetecteerde uitwissing, en iii. een correctieorgaan voor het corrigeren van de fouten en uitwissingen door de werkelijke foutwaarden, av, te combineren met geassocieerde codewoordsymbolen.

5. Foutcorrectiesysteem volgens conclusie 4, m e t het kenmerk, dat de syndroomcalculator omvat een syndroom-modificeringsorgaan, welk syndroommodificeringsorgaan omvat: i. een teller voor het tellen van iteraties, welke teller wordt geinitialiseerd op c=0, ii. een orgaan voor het vergelijken van de telling c met P, iii. een orgaan voor het vermeerderen van een index Lr tot Lr+1, waarbij Lr wordt geinitialiseerd tot de waarde van de laagste wortel van de (n,k) codegeneratorpolynoom, indien c < p, iv. een orgaan voor het verminderen van een index D tot D-l, waarbij D wordt geinitialiseerd tot de afstand van de (n,k) code, v. een orgaan voor het bijwerken van de syndromen tot SX = SI_1an_c + Sx voor I = Lr + (D-2), Lr + (D-2)-l,...,Lr, vi. waarbij de syndroomcalculator de teller c vermeerdert voor elke iteratie en de syndromen bijwerkt voor elke nieuwe waarde van Lr en D totdat c groter is dan p.

6. Foutcorrectiesysteem volgens conclusie 5, m e t het kenmerk, dat het foutwaardemodifieeringsorgaan omvat: i. een iteratieteller, geinitialiseerd tot c=0, ii. een orgaan voor het vergelijken van c met p, iii. een f calculator, geinitialiseerd tot f=l, welke f calculator f bijwerkt voor elke iteratie, waarin c < p, tot f=f* (a11 c ei + 1), waarin een Galois Field vermenigvuldiging representeert, waarbij het foutwaarde- modificeringsorgaan de teller vermeerdert met 1 voor een volgende iteratie.

7. Foutcorrectiesysteem volgens conclusie 4, m e t het kenmerk, dat de syndroomcalculator een syndroommodificeringsorgaan heeft, welk syndroommodificeringsorgaan omvat: i. een orgaan voor het berekenen van U(x) voor de waarde van p geselecteerd door het selectieorgaan, ii. een orgaan voor het bijwerken van de syndromen tot Si = S^pUp + s^p^Up.! + ... + + Sl voor I = Lr + (D-2),Lr + p.