Hallo!

Ben aardig nieuw in heel de 'hardware-wereld', en ken er dus nog niet zoveel van. Ben de laatste tijd wel VEEL aan het leren/lezen, mr nu zit ik toch wel met wat vragen.
Ik kom heel vaak Pariteit/pariteitsbits tegen, en ik heb eerlijk gezegd geen flauw idee hoe dat zit.
In mijn boeken word er heel vaag uitgelegd dat het is om te controleren op fouten??
(Kom het tegen bij DRAM-chips uitleg, en Harde schijven enzo..)

Iemand die mij hier een klein woordje uitleg kan bij geven?

Alvast bedankt !

Een pariteitsbit is een extra bit die wordt toegevoegd om een minimale controle te hebben dat een bepaalde code juist is. Met die ene bit kan wel niet de code herstelt worden mocht er een fout zijn, het is dus gewoon een check.

Je zal dit bij geheugens tegenkomen maar ook bij transmissie van data zoals over seriële verbindingen.
Bij een geheugen ic'tje op je geheugen module wordt een pariteitsbit voorzien. Zo heeft 1 byte 8 bit + nog een pariteit en is dus 9 bit totaal.
De pariteitbit is een één als het aantal éénen in de code even is. Omgekeerd bij oneven aantal éénen is ze 0.

Vb de code 1101.1010 heeft 5 éénen en krijgt dus als negende pariteitsbit een 0
vb de code 0011.1100 heeft 4 éénen en krijgt als pariteitbit een 1.

De code zelf kan variëren in lengte. Zo heb je soms serieel verbindingen die met 7 databits en 1 pariteitsbit werken waardoor alles juist 1 byte lang is.

Andere foutcorrectie methodes kunnen soms de plaats van de fout achterhalen. Met de pariteitsbit kan dan ook de code worden herstelt. Je weet immers de plaats waar iets fout is en je weet door bv een 0 als pariteit dat je een oneven aantal éénen moet hebben in de code.

Edit: nog vergeten;) de term pariteit is een instelling die je kan zetten op odd(oneven), even(even) of none(geen) gelijk bij je seriële verbinding. Het is de afspraak wanneer je nu een 1 of een 0 zet als pariteitsbit.
Bij odd(oneven) zal de pariteit 1 zijn bij een oneven aantal éénen in je code.
Zet je de parameter op even (even) dan is hij juist 1 bij een even aantal.
Zet je none(geen) pariteit wordt de bit meestal op 1 gezet maar er wordt geen rekening mee gehouden.

E.

Vb de code 1101.1010 heeft 5 éénen en krijgt dus als negende pariteitsbit een 0
vb de code 0011.1100 heeft 4 éénen en krijgt als pariteitbit een 1.



Kan het zijn dat in mijn boek staat dat code's met een oneven aantal 1'en een pariteitsbit 1 krijgen ?

0001 0101 krijgt een 1 als PB.
0110 0110 krijgt een 0 als PB.

Zo staat het hier toch, weet het dus niet goed :p.

Ze zeggen ook, als er door een leesfout bijvoorbeeld 2 bits veranderen, dan kan de pariteitsbit dit niet meer opmerken, en daarom voegt men soms ook nog een Pariteitsbyte erbij. Dit is eigenlijk hetzelfde ans een Pariteitsbit volgens mij, alleen controleert die niet in de 'rijen' maar in de kolommen?

0001 0101
0110 0110

krijgt dus als Pariteitsbyte 0111 0010 , en die byte krijgt dan nog eens zijn apparte pariteitsbit, in dit geval dus 0 (omdat er een even aantal eentjes zijn? Of is het nu andersom :P?)

Edit: Sorry Peter, verbeter me als ik fout ben , mr volgens mij is oneven een 1tje ja , zo staat het toch op Wikipedia.

Als bij oneven of bij even er een 1 komt hangt van de afspraak af. Dat is wat ik eigenlijk in de vorige post bij edit probeerde duidelijk te maken:p
Heeft het systeem een 'even' pariteit dan zal bij een even aantal éénen in de code de pariteitsbit 1 worden. Heeft het systeem gekozen voor een 'oneven' pariteit, dat zal de pariteitsbit 1 zijn bij een oneven aantal éénen in de code. In jouw boek is het oneven in het vb

Als er twee bits veranderen kan je idd niks aanvangen met die bit. Stel de code 1111.0000 dan heb je 4 éénen en dus even aantal. Veranderen er nu 2 bits bv de code verandert naar 1110.1000 of 1100.0000 dan blijven er even aantal bits één en zie je dus niet dat er een fout is.

Van pariteitsbyte heb ik nog niet gehoord. Ik denk eerder dat ze een soort checksum bedoelen van een blok data? Dit is bv een xor (ja terug je document van philo boven halen) van alle bytes in een data blok. Dus stel een data blok van 5 byte, dan is de checksum (byte1 xor byte2 xor byte3 xor byte4 xor byte5) = byte die moet kloppen
Maar de term pariteitsbyte heb ik nog niet gehoord en kan dus idd iets anders zijn???

Heb het even ingescand ;). De Pariteitsbyte controleert dus eigenlijk op de 'kolommen' van een groep bytes. Denk ik..

Edit : afbeelding viel wat klein uit , dan maar hier:

http://nl.tinypic.com/r/30nkvas/6
http://i46.tinypic.com/30nkvas.jpg

Je hebt 2 soorten pariteit:
Even Pariteit en Oneven Pariteit.

Bij Even Pariteit wordt de pariteitsbit op "1" gezet bij een even aantal eentjes.
Bij Oneven Pariteit wordt de pariteitsbit op "1" gezet bij een oneven aantal eentjes.

Je kan dus kiezen wat je liefst wil gebruiken. ;)

10001000 met Even Pariteit => Pariteitsbit = 1
10001000 met Oneven Pariteit => Pariteitsbit = 0

Opzich wil die bit dus gewoon aangeven of het aantal "eentjes" even of oneven is, afhankelijk van het soort pariteit dat gekozen is. ;)

EDIT: Je wou "byte" weten :P. Direct ff bericht aanpassen. :D

Mvg,
Dave

Byte ja =D , bit snap ik nu wel helemaal denk ik. Alleen wel nog niet helemaal hoe het dan zit bij DRAM enzo, als daar bijvoorbeeld een stel gegevens naar de CVE worden gestuurd , die worden dan ook gecontroleerd aan de hand van die bit, en als er een fout is , gewoon opnieuw gelezen in het werkgeheugen voordat ze naar de CVE gestuurd worden?

Ik heb nog nooit gehoord van de pariteitsbyte. Maar het gaat dus zo (als ik voort ga op de uitleg in je cursus):

Hier zijn 2 bytes met een pariteitsbit achteraan. (oneven pariteit)

1000 1000 -> 0
1100 1110 -> 1

Nu ga je ook nog eens verticaal alle kolommen checken op pariteit. En dat vormt de pariteitsbyte.

1000 1000 -> 0
1100 1110 -> 1
0100 0110 -> 1

Op die manier kan je dus zien of er bijvoorbeeld een even of oneven aantal bits verandert zijn. Terwijl je dat anders niet zou zien. Bijvoorbeeld:

1000 1000 heeft pariteitsbit 0
Stel dat er door een fout dit zou gebeuren:
1010 1010
Die heeft ook pariteitsbit 0, want die is ook "even". Maar de 2 getallen zijn zeker niet hetzelfde.

Via die pariteitsbyte krijg je dan:
1010 1010 -> 0
1100 1110 -> 1
0110 0100 -> 1

Beide uitkomsten:
0100 0110 -> 1 en 0110 0100 -> 1 zijn niet hetzelfde. Dus er is een fout gebeurd. ;) Dat kan je niet zien als je enkel de pariteitsbit gebruikt.

Ivm met dat DRAM; Geen idee;).

Mvg,
Dave

Daar staat ook zo'n oefeningetje, als er 2 bit verandert, welke andere bits moeten er dan ook veranderen opdat de fout niet opgemerkt zou worden?

Bijvoorbeeld:

1010 1010 -> 0
1100 1110 -> 1
---------------
0110 0100 -> 1

Als je nu in de eerste byte daar, de eerste 1 vervangt door een 0, opdat die fout niet gemerkt zou worden, moet de PB van die byte dus vervangen worden door een 1, moet de eerste bit van die pariteitsbyte vervangen worden door een 1 ook, en word de pariteitsbit, van de pariteitsbyte vervangen door een 0 :p?
Denk dat ik het snap!

Ja dat is het gevolg van de verandering. ;) Maar geen antwoord op de vraag die ze stellen :D.

Stel dus inderdaad dit voorbeeld;
1010 1010 -> 0
1100 1110 -> 1
---------------
0110 0100 -> 1

En je gaat 1bit veranderen (links boven), dan krijg je dit resultaat. Alles wat rood is, is aangepast door de bit verandering.
0010 1010 -> 1
1100 1110 -> 1
---------------
1110 0100 -> 0

En de vraag zegt: "Wat moet nog veranderen opdat de fout niet opgemerkt zou worden?"

- We moeten zorgen dat aan de rechterkant, de pariteitsbit van de eerste byte terug 0 wordt. Dat doen we door een willekeurige "0" of "1" van diezelfde byte te veranderen naar het tegenovergestelde. 0 naar een 1 of andersom dus. Bijvoorbeeld:

0011 1010 -> 0
1100 1110 -> 1
---------------
1111 0100 -> 1

Door nog een bit (Oranje) te veranderen is de pariteitsbit van de eerste byte al goed. Maar hierdoor zijn nog 2 andere bits veranderd in de pariteitsbyte.

Om dat ongedaan te maken, moeten we in de rij eronder. (Dus de 2e byte) in DEZELFDE kolom als de 2 bits die we al veranderd hebben, ook weer de bytes omwisselen. ;)

Bovenaan deze post hebben we een bit veranderd in de eerste kolom (links boven). En hierboven hebben we net een bit veranderd in de 4e kolom van de eerste byte. Dus nu moeten in de 2e byte ook in kolom 1 en 4 een omwisseling uitvoeren.

0011 1010 -> 0
0101 1110 -> 1
---------------
0110 0100 -> 1

Resultaat? De pariteitsbits achter elke byte is hetzelfde als onze opgave. EN de pariteitsbyte is hetzelfde als die van de opgave. Zijn onze 2 bytes hetzelfde als die van de opgave, neen :D.
Byte 1 van de opgave: 1010 1010
Byte 1 in de oplossing: 0011 1010

Byte 2 van de opgave: 1100 1110
Byte 2 in de oplossing: 0101 1110

Greetz,
Dave

Juist ja ! Vraag een beetje verkeerd geïnterpreteerd dan .

Ik snap het ^^ ! Thx allebij !!!

No problem. Die vraag werd waarschijnlijk gesteld om aan te tonen dat deze methode niet volledig waterdicht is. ;)

Suc6.

Greetz,
Dave