Informaticasite van het Lauwers College te Buitenpost © R.J. van der Beek

Hoofdstuk 7. Netwerken.

7.2. Transport van bits, protocollen.

7.2.1. Hoe worden bits over een draad verzonden.

Bij "datacommunicatie" worden meestal elektrische signalen gebruikt om gegevens te transporteren.

De voortplanting van elektrische signalen over een draad gaat verschrikkelijk snel. In vacuum gaat dat met de lichtsnelheid, dat is 300000 km per sec., in koperdraad is de snelheid circa 200000 km per sec.

In een computer worden gegevens m.b.v. bits vastgelegd, dus met enen en nullen. Als je een bitreeks wilt versturen over een draad dan kan dat m.b.v. gelijkstroom.
Het kan ook m.b.v. wisselstroom, maar dat wordt in het volgende hoofdstuk besproken.

Je zou dat heel eenvoudig als volgt kunnen doen: Aan de zendkant van de draad zet je een batterij met een schakelaar, die dient als signaalbron en aan de ontvangkant kun je het signaal waarnemen met behulp van een voltmeter.
Je kunt m.b.v. de schakelaar aan de zendkant regelen wanneer er spanning op de draad staat.

We spreken af dat spanning betekent '1' en geen spanning betekent '0'.

Stel je voor dat je de bitreeks 0110000111100 wilt versturen.
Je kunt dan eerst de schakelaar bijv. een halve sec. op uit zetten, dan twee keer een halve sec. op aan, dan vier keer een halve sec. op uit, dan vier keer een halve sec. op aan en dan nog twee keer een halve sec. op uit.
De figuur hieronder geeft dan aan wat je gedurende zes sec. op de voltmeter afleest.

Tussen computers gaat dat natuurlijk veel sneller, dan gaat het om miljoenen bits per sec.

Als je uit bovenstaande grafiek wilt achterhalen welke bits zijn verzonden dan heb je een aantal problemen.

Ten eerste weet je niet wanneer het zenden is begonnen, omdat als er geen spanning op de voltmeter staat het kan betekenen dat er nog niet is begonnen met zenden, maar het kan ook betekenen dat er één of meer nullen worden overgeseind.
Je weet ook niet wanneer er met seinen is gestopt.
En als je het zendtempo niet weet dan weet je ook niet of de spanning van t = 3.5 tot t = 5.5 is ontstaan door twee enen of door vier enen of misschien nog wel meer enen.

Je moet daar afspraken over maken, en dat noem je een protocol.

Bits worden altijd in groepjes verzonden. Een groepje bij elkaar horende bits noemen we een frame.
De bits van een frame moeten in een vast tempo verzonden worden. De zender volgt daarbij het ritme van een zendklok , op iedere tik van de zendklok wordt er een bit verzonden.
De ontvanger moet in hetzelfde tempo de toestand van de lijn meten, hij moet over een ontvangklok beschikken die gelijk moet lopen met de zendklok.

Snelheid is belangrijk bij communicatie. We willen dus zo veel mogelijk bits per sec. versturen. Maar als het te snel gaat dan kan de voltmeter het niet meer bijhouden, het meetinstrument heeft een bepaalde traagheid.
Ook de draad kan door zijn natuurkundige eigenschappen niet een willekeurig groot aantal toestandsveranderingen per sec. ondergaan.
Het maximale aantal toestandsveranderingen dat de draad per sec. kan ondergaan noem je baud.
100 baud betekent bijvoorbeeld 100 toestandsveranderingen per sec. Maar dat betekent nog niet dat er dan maximaal 100 bits per sec. worden verstuurd.
Dat is wel zo als er maar twee toestanden in de draad zijn : wel spanning=1 en geen spanning=0

Je kunt je ook voorstellen dat er bits worden overgeseind m.b.v. een batterij en een schakelaar, waarbij je met de schakelaar kunt kiezen uit:

0 = geen spanning
1 = spanning van 1 Volt
2 = spanning van 2 Volt
3 = spanning van 3 Volt.

Dan kun je dus telkens één van de getallen 0, 1, 2 of 3 overseinen. En m.b.v. bits kun je dat schrijven als 00, 01, 10 en 11. Dus je seint dan eigenlijk twee bits tegelijkertijd over !

Hoe meer spanningsniveau's je hebt, hoe meer bits je per keer kunt overseinen. Als je acht spanningsniveau's hebt dan sein je per keer 3 bits over. Bij 16 spanningsniveau's is dat per keer 4 bits.

Maar als het aantal spanningsniveau's toeneemt dan is het verschil tussen die niveau's steeds geringer en moeilijker waarneembaar, en dan heb je een grotere kans op transmissiefouten.

Gewone binaire codering, zoals hierboven is toch wat verwarrend doordat het moeilijk is onderscheid te maken tussen een stilte in het zenden (0 volt) en een 0-bit (ook 0 volt).

Daarom wordt vaak gebruik gemaakt van Manchester-codering.

Bij Manchester-codering. wordt elke bit in tweeën verzonden: een binaire 1 wordt gezonden door de spanning in de eerste helft van het interval hoog te maken en in het tweede laag. Bij een binaire 0 is het net andersom: eerst laag, dan hoog.
Elke bitperiode heeft in het midden een overgang, waardoor de synchronisatie van ontvanger en zender gemakkelijker wordt.

Een nadeel is dat er, om dezelfde snelheid te houden, twee keer zo snel van spanning gewisseld moet worden.

7.2.2. Standaarden.

Er zijn veel fabrikanten en leveranciers van hard- en software voor netwerken, elk met hun eigen opvattingen.
Als ze geen afspraken met elkaar zouden maken dan zou er een chaos ontstaan.

Gelukkig worden er wel afspraken gemaakt, zodat er standaards ontstaan.
Zo is er de Amerikaanse IEEE (Institute of Electrical and Electronics Engineers), die standaards ontwikkelt op het gebied van elektriciteit en computers, vooral voor LAN's.
Standaard 802 van IEEE voor lokale netwerken is de belangrijkste standaard voor LAN's.

In IEEE 802.3 staat precies beschreven waar de soft- en hardware voor 10BaseT-Ethernet aan moet voldoen.
Dit is na te lezen op http://www.ieee.org/portal/site en

7.2.3. CSMA/CD.

Dit principe, dat bij Ethernet wordt toegepast is te vergelijken met een aantal mensen die elkaar niet kunnen zien maar allemaal aan een grote buis zitten waarin een klein gat zit.

Als ze willen spreken, moeten ze eerst luisteren of er al iemand bezig is.
AIs het stil, dan kan iemand die wil spreken zijn mond voor het gat brengen en beginnen met spreken.
Is het niet stil, dan moet hij wachten tot het wel stil is.
Nu is het natuurlijk mogelijk dat je niks hoort als je luistert, maar dat wel al iemand anders begonnen was met spreken.
Als jij begint met spreken terwijl er nog iemand anders bezig is verstaat niemand wat er gezegd wordt. In zo'n geval moet iedereen die bezig is met spreken ophouden, een willekeurige tijd wachten en dan opnieuw luisteren voordat men probeert te spreken.

Wat gebeurt er in een Ethernet-LAN als een computer data moet verzenden naar een andere computer (of printer, of nog weer een ander apparaat) :

De data worden in stukjes verdeeld, in frames.
Voordat het eerste frame wordt verstuurd "luistert" de computer eerst het kanaal af. Als hij merkt dat er al dataverkeer op de lijn is, dan verstuurt hij het frame nog niet.
De stations kunnen dus vaststellen of het kanaal in gebruik is. Dat aftasten of de lijn bezet is noem je carrier sense.
Zodra hij merkt dat de lijn vrij is verstuurt hij het eerste frame, op de eerstvolgende "kloktik".
(De tijd wordt in intervallen (slots) verdeeld)
Maar als dan toevallig een andere computer op hetzelfde moment een frame verstuurt ontstaat er toch een botsing. (ook wel collision genoemd)
De computer merkt een botsing direkt (hij "luistert" ook steeds naar de lijn), en dan stopt hij direkt met zenden, hij zendt dan dus niet het hele frame.
Na een botsing wacht hij een aantal kloktikken (hoeveel kloktikken, dat hangt van het toeval af) en dan probeert hij het weer. Hij probeert het niet direkt bij de eerstvolgende kloktik, want als dat de regel is dan zal die andere computer ook direkt weer gaan zenden en dan onstaat er direkt weer een botsing.

Deze manier van zenden of niet-zenden heet CSMA/CD (Carrier sense Multiple Access with Collision Detection).

Toen de eerste LAN's ontstonden werd niet direkt deze manier gebruikt.

In het begin was het zo, dat als een computer wilde zenden, hij ook direkt ging zenden (zonder op kloktikken te letten en zonder eerst te "luisteren" of de lijn vrij was). En als er een botsing ontstond zond hij direkt weer. Kortweg gezegd: "send and pray".

Deze manier werd ALOHA genoemd (het werd het eerst toegepast op HAWAI).

Doordat er veel botsingen ontstonden was dit niet zo efficiënt. Het beste resultaat dat je kon boeken was een gebruiksgraad van het kanaal van 18 %

Steeds werden er verbeteringen aangebracht en tot nu toe werkt CSMA/CD het best.

De frames worden verstuurd m.b.v. Manchester bitcodering.

Het is een zogenaamd "broadcasting systeem", dat wil zeggen dat alle computers alle berichten "horen", maar alleen degene voor wie het bericht bestemd is neemt het in ontvangst.

7.2.4. Het 802.3-protocol.

Als een computer data wil verzenden dan verdeelt hij de data eerst in stukken van 1500 bytes.
Maar aan elk van die pakketjes van 1500 bytes wordt nog iets toegevoegd.

Elk frame begint met zeven bytes, die allemaal uit het bitpatroon 10101010 (hexadecimaal is dat AA) bestaan.
De Manchester-codering daarvan levert een blokgolf van 10 MHz op gedurende 5,6 microsec. Die kan de ontvanger gemakkelijk herkennen en het stelt de ontvanger in staat zich met de zender te synchroniseren.
Dan komt het "Start of frame-byte", dat uit het bitpatroon 10101011 (hexadecimaal is dat AB) bestaat. Samen worden deze acht bytes wel de preambule genoemd, of de vlagbytes. Die geven dus aan dat het frame begint.
Dan komt het doeladres, dat bestaat uit zes bytes.
Elk netwerkstation op Ethernet heeft namelijk een uniek hardware-adres, het zogenaamde MAC-adres (als je een netwerkkaart koopt zit dat adres er al "ingebakken") Een MAC-adres is 6 bytes lang, en dat is dus niet hetzelfde als het IP-adres.
Als dat adres met een 0 begint dan is het een gewoon adres, en als het met een 1 begint dan is het een groeps-adres. (het zenden naar een groep wordt multicasting genoemd).

Als het doeladres uit allemaal enen bestaat dan wordt het afgeleverd bij alle computers van het netwerk (dat wordt broadcasting genoemd).
Na het doeladres komt het bronadres (zes bytes), dus het adres van de computer waar het bericht vandaan komt.
Daarna komen twee bytes, waarin de lengte van de data (het aantal bytes daarvan) in het frame wordt gegeven. Dat is maximaal 1500 maar het kan ook veel korter zijn, het kan ook zijn dat er maar één byte wordt verstuurd (maar dan is de totale lengte van het frame toch nog 64 bytes, zie hierna)
Dan komen de echte data waarom het gaat. Maximaal 1500 bytes. De totale lengte van het frame moet minimaal 64 bytes zijn, als het korter zou zijn dan wordt dit veld gebruikt om het op te vullen tot 64 bytes.
Het laatste veld bestaat uit 4 bytes en dat bevat de "checksum" waaraan de ontvanger kan zien of het frame goed is overgekomen. Als bepaalde bits verkeerd zijn overgekomen (wat bijvoorbeeld door ruis veroorzaakt kan worden) dan klopt de checksum niet. Die controlesom is een cyclische redundantiecode, wat besproken wordt in één van de volgende paragrafen.
Als afkorting hiervoor wordt wel gebruikt FCS (Frame Check Sequence) en dit zit in de staart van het frame (ook wel trailer genoemd) omdat dat de snelheid bevordert: de zender kan al beginnen met het zenden van het frame voordat hij de checksum heeft berekend)

In totaal is het frame dus maximaal 1526 bytes lang.

Bovenstaande afspraken worden samen het protocol genoemd.

Het frameformaat van 802.3 in tabelvorm:

8 bytes	6 bytes	6 bytes	2 bytes	0-1500	4 bytes
preambule	doeladres	bronadres	lengte dataveld	data	checksum

De minimale lengte van een frame is 64 bytes. Als het korter is dan kan het gebeuren dat een frame helemaal verstuurd is, dus het laatste byte is al verstuurd, terwijl het eerste byte nog niet aan het einde van de bus is. Als het laatste byte verstuurd is en er is nog geen botsing gedetecteerd dan denkt de computer dat het frame met succes is verstuurd. Maar het kan dan gebeuren dat er toch nog een botsing komt met een ander frame.

Een frame van 64 bytes bestaat uit 64 x 8 = 512 bits. In een 100-baseT-netwerk worden 100 miljoen bits per sec. verstuurd, dus per bit is dat 0,01 microsec., en 512 bits duurt dan 5,12 microsec.
Als de afstand tussen de zendende (=computer A) en de ontvangende computer (=computer B) 500 meter is, dan heeft een bit 2,5 microsec. nodig om van A naar B te komen (de snelheid van de electriciteitsgolven is 200000 km per sec, dat is 200000000 meter per sec en dus 200 meter per microsec.).
Als computer B - vlak voordat het eerste bit dat door A wordt gezonden aankomt- een bit verzendt dan treedt er een botsing op, en het bit dat een botsing heeft gehad komt 2,5 microsec. later bij A aan, en dan pas weet A dat er een botsing geweest is. Dat is dus ongeveer 5 microsec. nadat A het eerste bit verstuurd heeft.
Dan is A nog bezig met het verzenden van de laatste bits van het frame, want dat duurt in totaal 5,12 microsec. Als de afstand van A tot B langer dan 500 meter is dan zal het vrij snel meer dan 5,12 microsec. duren voordat A een botsing opmerkt en dan is er een probleem want dan is het hele frame al verstuurd en dan denkt A dat alles is goed gegaan.
Dus de maximale afstand tussen zender en ontvanger is theoretisch ongeveer 500 meter, maar door repeaters en hubs kunnen er vertragingen optreden. Voor de zekerheid houdt men daarom een maximale afstand van circa 250 meter aan.
Daarom is de minimale lengte van een frame 64 bytes, en is de maximale afstand 250 m.

7.2.5. Foutcorrectie en foutdetectie.

Bij datacommunicatie wordt de bitstroom in frames verdeelt. Voor elk frame wordt dan een zogenaamde controlesom (checksum) berekend, en aan het frame toegevoegd.
Als het frame op zijn bestemming aankomt wordt de controlesom nog eens berekend. En als dan de berekende controlesom verschilt van de controlesom die in het frame is opgenomen, dan is er een transmissiefout.
Dan wordt het frame weggegooid en misschien wordt er dan een foutmelding teruggestuurd (of misschien wordt er juist alleen een bericht teruggestuurd als het frame goed is aangekomen, een zogenaamde ack=acknowledgment=bevestiging), dat hangt van het protocol af.

Je hebt foutontdekkende codes en foutcorrigerende codes.

Bij een foutontdekkende code wordt er alleen ontdekt dat er een fout in het frame zit, het ontvangen frame wordt weggegooid en hetzelfde frame moet door de zender nog eens woren verzonden.

Bij een foutcorrigerende code wordt er niet alleen ontdekt dat er een fout in het frame zit, maar ook waar die fout zit, en die kan dan direkt worden hersteld.

Pariteitsbit

Een eenvoudig voorbeeld van een foutenontdekkende code is het pariteitsbit.

Er wordt een bit aan het frame toegevoegd (het zogenaamde pariteitsbit), en dat bit wordt zo gekozen dat het aantal enen in het frame even is (of juist oneven, maar net wat de afspraak is).

Je ziet in de figuur hieronder steeds een byte, en daarachter het zelfde byte met een even pariteitsbit toegevoegd.

Hiermee kun je alleen enkelvoudige fouten ontdekken. Als er een dubbele fout in zit dan ontdek je die niet !

Twee-dimensionale pariteitscheck.

Een andere foutontdekkende code is de twee-dimensionale pariteitscheck.
Je moet de bits dan in een aantal rijen en kolommen verdelen.
Stel dat je 6 rijen van 7 bits hebt.
Je voegt aan elke rij rechts een pariteitsbit toe.
En je voegt aan elke kolom onderaan een pariteitsbit toe.
In totaal voeg je dan 14 bits toe.

Hiermee kun je enkele fouten ontdekken, maar ook dubbele. Zelfs als een hele rij fout is dan kun je dat ontdekken.
En fouten blijken vaak in "bursts" voor te komen (d.w.z. een heel aantal fouten op een rij), daar is dit een goede methode voor.

Een voorbeeld van een foutencorrigerende code is de zogenaamde Hamming-code.

Foutenontdekkende codes worden vaak gebruikt bij de opslag van data op een schijf en bij draadloze transmissie.

CRC-code

De belangrijkste foutontdekkende code is de zogenaamde cyclische redundantiecode (CRC).
Die wordt in de praktijk op grote schaal gebruikt.
Deze code ontdekt alle enkelvoudige fouten, alle dubbele fouten, als er 16 fouten op rij zijn (dus in bursts), en nog meer.
CRC wordt o.a. gebruikt bij Ethernet. Je hebt weinig extra code nodig. Bij een frame van 1600 bytes heb je slechts 4 bytes nodig voor de checksum.

Het idee achter de CRC-code is om te kijken naar de data als één groot binair getal.
Dit getal wordt gedeeld door een bepaald getal (de CRC-generator) en de rest bij die deling wordt de CRC genoemd.
Er moet wel bij de zender en de ontvanger bekend zijn door welk getal er gedeeld moet worden. Dat getal is altijd oneven, en het is heel belangrijk welk getal daarvoor wordt gekozen, want dat getal bepaalt welke fouten er gevonden worden en welke niet.

We gaan een voorbeeld bekijken waarbij er gedeeld wordt door 19, dat is binair 10011.
En we nemen aan dat als data verstuurd moeten worden de vogende bits: 1101101
Dan wordt het getal 1101101 gedeeld door 10011, en op de basisschoolmanier gaat dat als volgt (en de computer doet het ook ongeveer op die manier!):

1	1	0	1	1	0	1	: 10011 = 100 + 1 (= 5)
1	0	0	1	1	0	0
_	_	_	_	_	_	_	-
	1	0	0	0	0	1
		1	0	0	1	1
_	_	_	_	_	_	_	-
			1	1	1	0	( = 14, dat is de rest)

De CRC-code is dan dus 14.

Maar wat gebeurt er nu met de rest bij deling door 19, dus de CRC-code, (zie voorbeeld) als één of meer bits fout zijn?
Elke enkelvoudige bitfout zal worden gedetecteerd. Want elke enkelvoudige bitfout heeft tot gevolg dat het deeltal verandert met een macht van 2.

Als bijvoorbeeld het tweede bit verandert van een 1 in een 0 dan zal het deeltal 16 kleiner worden, en de rest zal dan eigenlijk ook 16 kleiner worden, dus 14 - 16 = -2. Maar omdat de rest niet negatief kan zijn wordt het 19 - 2 = 17
De rest is veranderd, en dus wordt de fout ontdekt.
Als bijvoorbeeld het vierde bit verandert van een 0 in een 1 dan zal het deeltal 8 groter worden, en de rest zal dan eigenlijk ook 8 groter worden, dus 14 + 8 = 22. Maar omdat de rest altijd kleiner dan 19 is wordt het 22 - 19 = 3
De rest is veranderd, en dus wordt de fout ontdekt.
Als er twee bits wijzigen in de data kun je op dezelfde manier berekenen dat de fout wel wordt ontdekt.

Het is bekend dat de getallen 8005 en 1021 het heel goed doen als deler bij de CRC-berekeningen.
Bij CRC-16 wordt vaak als deler genomen 11000000000000101
en bij CRC-32 meestal 100000100110000010001110110110111
(die getallen hoef je niet te onthouden)

7.2.6. Programma's om een netwerk te testen.

Er zijn programma's waarmee je een netwerk kunt testen.
M.b.v. het programma PING kun je controleren of een bepaalde computer via het netwerk te bereiken is, en hoelang dat duurt, tenminste als het TCP/IP protocol wordt gebruikt.
De DOS-versie van PING staat vast wel op je computer.

Klik op Start, dan op Programma's, en dan op MSDOS.
Als één van de computers de naam WS-BLC37 heeft tik dan in: ping WS-BLC37
Als het IP-nummer van een computer 172.17.7.143 is probeer je ook maar eens ping 172.17.7.143
Ook: ping -L 30000 WS-BLC37 (er wordt dan een frame verstuurd van 30000 bytes)
Tik ook eens in: ping (zonder iets er achter) Dan krijg je informatie over de ping-opdracht te zien.
Probeer ook eens TraceRoute :
Tik in tracert 172.17.7.143 Wat zie je ?

Er zijn een heleboel programma's om de snelheid van het netwerk te testen, bijv. NetIQ QCheck

Als je de snelheid van je internetverbinding wilt testen kun je dat online doen via www.speedtest.nl