Het sorteren van post Jeroen Wessels 0778324 Ruben Kwant 0780949 15 mei 2012 1
1 Samenvatting Na het ontvangst van de post op het postkantoor wordt de postcode gelezen en het postadres door middel van een streepjescode op een enveloppe gedrukt. Soms gaat het lezen van het postcode of het drukken van het postadres verkeerd. Het postkantoor wil voorkomen dat de post dan in een verkeerde brievenbus terecht komt. Dit kan met behulp van een foutcorrigerende code. Het doel van dit onderzoek is om een methode te verzinnen om het postadres op een enveloppe te drukken zodat de informatie van het postadres ook bij fouten goed wordt verwerkt. Er is een bepekt aantal bits waarin dit gerealiseerd moet worden. Zo is het niet mogelijk om gewoon de hele code drie maal te bedrukken. Er komen verschillende methode aan bod die wel werken. Een uitgebreide variant van de pariteitscode en de Hamming code werken het best. Zij zijn beide in staat om enkele fouten in de code te ontdekken en te herstellen en ook alle dubbele fouten ontdekken en veel dubbele fouten te herstellen. De Hamming code kan ook alle drie fouten herkennen, en soms zelfs nog herstellen. De uitgebreide pariteitscode kan meer dubbele fouten herstellen dan de Hamming code. Het ligt dus aan het aantal fouten dat er in een code zit, welke foutcorrigerende code het beste werkt. 2
Inhoudsopgave 1 Samenvatting 2 2 Inleiding 4 3 De code 5 3.1 Uitgebreide pariteitscode.............................. 5 3.2 Hamming Code................................... 6 4 Conclusie 7 3
2 Inleiding De postcode in Nederland bestaat uit 4 cijfers en 2 letters. Een postadres wordt eenduidig bepaald door de postcode en een getal tussen 0 en 120, het zogenaamde Street Box Reply number. Na ontvangst van de post op het postkantoor wordt het adres gelezen en het postadres door middel van een fluorescerende code van 52 boven/onder strepen, rechtsonder op de enveloppe gedrukt. Een sorteringsmachine gebruikt deze streepjescode als invoer om de enveloppe razend snel te sorteren. Bij het spuiten en het lezen van de streepjes kunnen fouten ontstaan. De eerste twee en de laatste twee streepjes geven aan waar de streepjes code begint en eindigt. De resterende 48 streepjes worden gebruikt om het postadres te coderen. Dit aantal is groter dan minimaal noodzakelijk is om de informatie op te slaan. De redundante bits worden gebruikt om foutcorrectie toe te passen. De doelstelling is een methode te ontwikkelen om het postadres in 48 posities van boven/onder strepen op de enveloppe te drukken zodat de informatie van het postadres ook bij fouten goed wordt verwerkt. Een voorbeeld van een mogelijke streepjescode 4
3 De code Er zijn 52 strepen voor de code. De eerste twee en de laatste twee streepjes geven aan waar de code begint. De overige 48 strepen worden gebruikt om het postadres te coderen. De postcode in Nederland bestaat uit 4 cijfers en 2 letters. Om de postcode te coderen heb je 10 4 26 2 mogelijke codes. Een postadres wordt eenduidig bepaald door de postcode en een getal tussen 0 en 120. Om het postadres te coderen heb je 10 4 26 2 120 mogelijke codes. Het log(104 262 120) aantal bits dat nodig is om het postadres te coderen is log(2) = 29, 59 30bits. Dan blijven er dus 48 30 = 18 bits over voor de foutcorrectie. Een van de simpelste foutcorrigerende code is een repetitiecode. Een code die iedere bit een aantal malen herhaald. Bijvoorbeeld als het te bedrukken databit een 1 was, bedrukt een n=3 repetitiecode het woord 111. Als de drie gelezen bits niet identiek waren, was er foutdetectie. De foutcorrectie werkt hierbij als volgt: bij het lezen van 000, 001, 010 of 100 wordt het gedecodeerde databit een 0, terwijl bij het lezen van 111, 110, 101, of 011 resulteert in decodering als 1. Uiteraard kunnen zulke codes niet alle mogelijke fouten op correcte wijze corrigeren. Bovendien is de repetitiecode zeer inefficint. Aangezien we maar 18 bits over hebben voor foutcorrectie is een repetitiecode ook niet mogelijk. Een andere mogelijkheid is een pariteitscode. Er wordt een enkel bit toegevoegd aan een codewoord dat aangeeft of er in dat woord een even dan wel een oneven aantal bits de waarde 1 heeft. Een bitfout op de streepjescode verandert de pariteit, waardoor de fout gedetecteerd wordt. Een even aantal bitfouten wordt hierdoor echter niet opgemerkt. Daarnaast is het zo dat bij detectie van een bitfout er niet duidelijk is welk bit fout is bedrukt of gelezen. De enige mogelijke correctiemethode is herdrukken van de code. Er zijn echter wel varianten van de pariteitscode waarbij wel duidelijk is welk bit fout is bedrukt of gelezen. 3.1 Uitgebreide pariteitscode Dit is een variant van de pariteitscode. Met deze methode wordt de code in een zes bij vijf tabel gezet. Vervolgens wordt de pariteit gecheckt van iedere rij,iedere kolom en twee diagonalen. Hieronder staat een voorbeeld van een code met in de onderste rij de pariteit van iedere kolom, in de een na laatste kolom de pariteit van iedere rij en in de laatste kolom de pariteit van twee diagonalen. 1 0 0 1 1 0 1 0 1 0 0 0 1 1 1 1 0 1 1 1 0 1 0 1 1 0 1 0 1 0 1 1 0 1 1 1 0 0 1 0 1 0 1 1 1 0 Deze methode altijd een fout ontdekken en corrigeren, ook kun je alle dubbele fouten herkennen maar niet allemaal corrigeren. De dubbele fouten die in dezelfde rij en dezelfde twee diagonalen zitten kan je niet corrigeren. Alle andere dubbele fouten wel. Deze methode kan heel weinig drie dubbele fouten herkennen en herstellen. Deze methode heeft 16 extra bits nodig. 5
3.2 Hamming Code Voor onze foutencorrectie met behulp van de Hamming Code splitsen we eerst onze code op in 3 delen van 16 bits. Hiervan zijn er dus 10 data bits en 6 bits die we gebruiken voor foutencorrectie. We voegen dan eerst 4 bits toe, op de eerste, tweede, vierde en achtste plek. Alle bits zorgen voor een even pariteit van bepaalde bits. De eerste bit zorgt ervoor dat de pariteit van alle oneven bits tot en met de bit op positie dertien even is. De bit op positie twee kijkt naar de tweede, derde, vijfde, zesde, tiende, elfde en veertiende bit, en zorgt ervoor dat de pariteit weer even is. De bit op positie vier kijkt naar de vierde, vijfde, zesde, zevende, twaalfde, dertiende, veertiende bit, en zorgt er weer voor dat de pariteit even is. De bit op positie acht zorgt ervoor dat de pariteit van bit acht tot en met veertien even is. De laatste twee bits voeg je toe achter aan de code. De eerste van deze twee bits zorgt ervoor dat de pariteit van alle even bits tot en met bit veertien even is. De laatste bit zorgt ervoor dat de pariteit van alle bits even is. Als dan bijvoorbeeld een deel van je data 1011010110 is krijg je daarbij als code die verzonden wordt: p1 p2 d1 p3 d2 d3 d4 p4 d5 d6 d7 d8 d9 d10 p5 p6 Data 1 0 1 1 0 1 0 1 1 0 Bit 1 1 1 0 1 0 0 1 Bit 2 0 1 1 1 1 0 0 Bit 3 0 0 1 1 1 1 0 Bit 4 1 0 1 0 1 1 0 Bit 5 0 0 1 1 1 1 0 0 Bit 6 1 0 1 0 0 1 1 1 0 1 0 1 1 0 0 0 Stel nu dat de vierde databit veranderd, dus deze veranderd van een 1 in een 0. Dan geldt er dus: p1 p2 d1 p3 d2 d3 d4 p4 d5 d6 d7 d8 d9 d10 p5 p6 Data 1 0 1 0 0 1 0 1 1 0 Bit 1 1 1 0 0 0 0 1 Fout Bit 2 0 1 1 0 1 0 0 Fout Bit 3 0 0 1 0 1 1 0 Fout Bit 4 1 0 1 0 1 1 0 Correct Bit 5 0 0 1 1 1 1 0 0 Correct Bit 6 1 0 1 0 0 1 0 1 0 1 0 1 1 0 0 0 Fout Omdat bij een aantal controlebits de pariteit niet klopt is er dus een fout. Deze fout is ook te corrigeren. Hij weet namelijk dat de fout zit op een positie waarvan de pariteit gecontroleerd wordt door de eerste, tweede en derde bit, terwijl het vierde pariteitsbit nog wel correct is. De enige plek waar dit gebeurt is in de code op plek 7, dus het vierde databit. Er ontstaan alleen problemen als er twee fouten zitten in deze code. Bij dubbele fouten weet hij niet waar de fout zit, maar wel dat er twee fouten zitten. Als bijvoorbeeld het eerste en achtste databit fout zijn, dus in de totale code het derde en twaalfde bit, dan lijkt dit voor hem net alsof het zevende en achtste bit fout zijn. Bij beide fouten in namelijk de pariteit 6
van de eerste vijf bits fout, en de pariteit van het zesde bit correct, waardoor hij het verschil niet kan ontdekken. Dit betekend dus dat als er een dubbele fout in zit meestal de brief apart moet worden genomen en handmatig gesorteerd moet worden. 4 Conclusie De Hamming-Code is de beste optie om zoveel mogelijk fouten te corrigeren. Deze methode kan alle enkele fouten en soms zelf nog 3 fouten in de code herstellen. De uitgebreide pariteitscode kan alle enkele fouten en veel dubbele fouten herstellen, maar kan heel weinig drie fouten herkennen en herstellen. De Hamming-Code kan minder dubbele fouten corrigeren dan de uitgebreide pariteitscode. Het ligt dus aan het aantal van de fouten in een code of de Hamming-Code beter is. Als er alleen maar enkele en soms dubbele fouten worden geconstateerd, is de uitgebreide pariteitscode beter. Als ook drie dubbele fouten worden geconstateerd, is de Hamming-Code beter. 7