Binair rekenen

binairstelsel

Binair Rekenen

Misschien klinkt het wat suf dat “binair rekenen” maar je computer doet eigenlijk niets anders dan dat !
Maar het binaire systeem is zelfs overal om ons heen.
Neem nu een lichtschakelaar : deze kan aan en uit…binair dus (aan = 1, uit  = 0)
Nu weet je ook meteen waarom op de meeste schakelaars een 1 en een 0 staat.

Waaruit dacht je dat letters, cijfers en andere karakters uit bestaan ?
Elk karakter is opgebouwd 1 byte, wat weer 8 bits zijn. een bit kan dan weer een 1 of een 0 zijn.
Zo kan een karakter bestaan uit 01001001, maar wat voor karakter komt daar nu uit ?

Elk karakter heeft een ASCII code en om de ASCII code te weten, zullen we moeten gaan rekenen met binaire getallen.
Dit klinkt moeilijker dan dat het eigenlijk is.
Wanneer we 1 byte, dus 8 bits pakken, hebben we een reeks van 8 enen of nullen. De positie van de bits zijn weer belangrijk voor de waarde er van.
De maximale waarde van 1 byte is 255.

We gaan dit even uiteenzetten aan de hand van 01001001 :
Eigenlijk is het een optelsommetje van de decimale waardes die bij de active bits, dus de enen, horen.
In onderstaande tabel tellen we de decimale waardes bij elkaar op die bij de corresponderende bits horen

Bitwaarde01001001
Decimale waarde1286432168421

OK, we hebben nu de decimale waardes die bij de actieve bits horen : 64 + 8 + 1 = 73
73 is de ASCII waarde voor de letter I

Nog eentje :

Bitwaarde01000011
Decimale waarde1286432168421

De ASCII waarde is : 64 + 2 + 1 = 66
Het karakter wat ASCII 66 is : de letter C

Zie je hoe makkelijk dit eigenlijk is ?
Zo is bijvoorbeeld de binaire waarde voor ICT Tips and Tricks :

01001001010000110101010000100000010101000110100101110000011100110010000001100001011011100110010000100000010101000111001001101001011000110110101101110011

Terug van ASCII naar Binair

Van ASCII/Decimaal terug naar binair is ook niet zo moeilijk.
Van een decimaal getal trek je steeds 1 binaire positie af, bijvoorbeeld 189 :

189 – 128 = 61, dus de eerste bit is een 1
61 – 64 = -3, dit is negatief en kan dus niet, de 2e bit is een 0
61 – 32 = 29, de derde bit is een 1
29 – 16 = 13, de vierde bit is een 1
13 – 8 = 5, de vijfde bit is een 1
5 – 4 = 1, de zesde bit is een 1
1 – 2 = -1, ook weer negatief en dus niet mogelijk. Zevende bit is een 0
1 – 1 = 0, achtste bit is weer een 1

189 decimaal is dus 10111101 binair !

Binair optellen

Je kunt ook binaire getallen optellen, aftrekken, vermenigvuldigen en delen.
Dit werkt eigenlijk hetzelfde als het normale decimale stelsel waarbij je in gedachten moet houden dat je nooit hoger kunt dan 1 of lager dan 0

Om bijvoorbeeld 26 + 38 in binaire getallen uit te rekenen gaan we zo te werk :

26 = 00011010
38 = 00100110

Deze zetten we net zoals we op school geleerd hebben onder elkaar en tellen dan op van rechts naar links :

Onthouden :
0 + 0 = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 0 waarbij een 1 een positie naar links opschuift. dus hetzelfde als 5 + 5 =10 waarbij je een 0 opschrijft en 1 onthoudt.

De berekening :
0 + 0 = 0
1 + 1 = 0 (1 onthouden)
1 + 0 + 1 = 0 (1 onthouden)
1 + 1 + 0 = 0 (1 onthouden)
1 + 1 + 0 = 0 (1 onthouden)
1 + 0 + 1 = 0 (1 onthouden)
1 + 0 + 0 = 1
0 + 0 = 0

De uitkomst van 00011010 + 00100110 is dus 01000000

En dan controleren of dit klopt :

Binaire Waarde01000000
Decimale waarde1286432168421

26 + 38 is inderdaad 64, de berekening klopt dus !

En met aftrekken, vermenigvuldigen en delen werkt dit op dezelfde manier.
Onthoud altijd dat met het binaire stelsel je alleen maar van 0 tot 1 kunt tellen.

Je kunt nu dus decimalen omzetten naar binaire getallen en andersom, deze optellen, aftrekken, delen en vermenigvuldigen !

Tot slot nog de complete ASCII tabel zodat je eens kunt oefenen met het binaire stelsel of gewoon kunt zien welke codes er zijn.

TextASCIIBinary
 n/a chr(0) 00000000
 n/a chr(1) 00000001
 n/a chr(2) 00000010
 n/a chr(3) 00000011
 n/a chr(4) 00000100
 n/a chr(5) 00000101
 n/a chr(6) 00000110
 n/a chr(7) 00000111
 n/a chr(8) 00001000
 n/a chr(9) 00001001
 n/a chr(10) 00001010
 n/a chr(11) 00001011
 n/a chr(12) 00001100
 n/a chr(13) 00001101
 n/a chr(14) 00001110
 n/a chr(15) 00001111
 n/a chr(16) 00010000
 n/a chr(17) 00010001
 n/a chr(18) 00010010
 n/a chr(19) 00010011
 n/a chr(20) 00010100
 n/a chr(21) 00010101
 n/a chr(22) 00010110
 n/a chr(23) 00010111
 n/a chr(24) 00011000
 n/a chr(25) 00011001
 n/a chr(26) 00011010
 n/a chr(27) 00011011
 n/a chr(28) 00011100
 n/a chr(29) 00011101
 n/a chr(30) 00011110
 n/a chr(31) 00011111
 chr(32) 00100000
 ! chr(33) 00100001
 “ chr(34) 00100010
 # chr(35) 00100011
 $ chr(36) 00100100
 % chr(37) 00100101
 & chr(38) 00100110
 ‘ chr(39) 00100111
 ( chr(40) 00101000
 ) chr(41) 00101001
 * chr(42) 00101010
 + chr(43) 00101011
 , chr(44) 00101100
 – chr(45) 00101101
 . chr(46) 00101110
 / chr(47) 00101111
 0 chr(48) 00110000
 1 chr(49) 00110001
 2 chr(50) 00110010
 3 chr(51) 00110011
 4 chr(52) 00110100
 5 chr(53) 00110101
 6 chr(54) 00110110
 7 chr(55) 00110111
 8 chr(56) 00111000
 9 chr(57) 00111001
 : chr(58) 00111010
 ; chr(59) 00111011
 < chr(60) 00111100
 = chr(61) 00111101
 > chr(62) 00111110
 ? chr(63) 00111111
 @ chr(64) 01000000
 A chr(65) 01000001
 B chr(66) 01000010
 C chr(67) 01000011
 D chr(68) 01000100
 E chr(69) 01000101
 F chr(70) 01000110
 G chr(71) 01000111
 H chr(72) 01001000
 I chr(73) 01001001
 J chr(74) 01001010
 K chr(75) 01001011
 L chr(76) 01001100
 M chr(77) 01001101
 N chr(78) 01001110
 O chr(79) 01001111
 P chr(80) 01010000
 Q chr(81) 01010001
 R chr(82) 01010010
 S chr(83) 01010011
 T chr(84) 01010100
 U chr(85) 01010101
 V chr(86) 01010110
 W chr(87) 01010111
 X chr(88) 01011000
 Y chr(89) 01011001
 Z chr(90) 01011010
 [ chr(91) 01011011
 \ chr(92) 01011100
 ] chr(93) 01011101
 ^ chr(94) 01011110
 _ chr(95) 01011111
 ` chr(96) 01100000
 a chr(97) 01100001
 b chr(98) 01100010
 c chr(99) 01100011
 d chr(100) 01100100
 e chr(101) 01100101
 f chr(102) 01100110
 g chr(103) 01100111
 h chr(104) 01101000
 i chr(105) 01101001
 j chr(106) 01101010
 k chr(107) 01101011
 l chr(108) 01101100
 m chr(109) 01101101
 n chr(110) 01101110
 o chr(111) 01101111
 p chr(112) 01110000
 q chr(113) 01110001
 r chr(114) 01110010
 s chr(115) 01110011
 t chr(116) 01110100
 u chr(117) 01110101
 v chr(118) 01110110
 w chr(119) 01110111
 x chr(120) 01111000
 y chr(121) 01111001
 z chr(122) 01111010
 { chr(123) 01111011
 | chr(124) 01111100
 } chr(125) 01111101
 ~ chr(126) 01111110
 n/a chr(127) 01111111
TextASCIIBinary
 n/a chr(127) 01111111
 € chr(128) 10000000
 n/a chr(129) 10000001
 ‚ chr(130) 10000010
 ƒ chr(131) 10000011
 „ chr(132) 10000100
 … chr(133) 10000101
 † chr(134) 10000110
 ‡ chr(135) 10000111
 ˆ chr(136) 10001000
 ‰ chr(137) 10001001
 Š chr(138) 10001010
 ‹ chr(139) 10001011
 Œ chr(140) 10001100
 n/a chr(141) 10001101
 Ž chr(142) 10001110
 n/a chr(143) 10001111
 n/a chr(144) 10010000
 ‘ chr(145) 10010001
 ’ chr(146) 10010010
 “ chr(147) 10010011
 ” chr(148) 10010100
 • chr(149) 10010101
 – chr(150) 10010110
 — chr(151) 10010111
 ˜ chr(152) 10011000
 ™ chr(153) 10011001
 š chr(154) 10011010
 › chr(155) 10011011
 œ chr(156) 10011100
 n/a chr(157) 10011101
 ž chr(158) 10011110
 Ÿ chr(159) 10011111
 chr(160) 10100000
 ¡ chr(161) 10100001
 ¢ chr(162) 10100010
 £ chr(163) 10100011
 ¤ chr(164) 10100100
 ¥ chr(165) 10100101
 ¦ chr(166) 10100110
 § chr(167) 10100111
 ¨ chr(168) 10101000
 © chr(169) 10101001
 ª chr(170) 10101010
 « chr(171) 10101011
 ¬ chr(172) 10101100
 ­ chr(173) 10101101
 ® chr(174) 10101110
 ¯ chr(175) 10101111
 ° chr(176) 10110000
 ± chr(177) 10110001
 ² chr(178) 10110010
 ³ chr(179) 10110011
 ´ chr(180) 10110100
 µ chr(181) 10110101
 ¶ chr(182) 10110110
 · chr(183) 10110111
 ¸ chr(184) 10111000
 ¹ chr(185) 10111001
 º chr(186) 10111010
 » chr(187) 10111011
 ¼ chr(188) 10111100
 ½ chr(189) 10111101
 ¾ chr(190) 10111110
 ¿ chr(191) 10111111
 À chr(192) 11000000
 Á chr(193) 11000001
 Â chr(194) 11000010
 Ã chr(195) 11000011
 Ä chr(196) 11000100
 Å chr(197) 11000101
 Æ chr(198) 11000110
 Ç chr(199) 11000111
 È chr(200) 11001000
 É chr(201) 11001001
 Ê chr(202) 11001010
 Ë chr(203) 11001011
 Ì chr(204) 11001100
 Í chr(205) 11001101
 Î chr(206) 11001110
 Ï chr(207) 11001111
 Ð chr(208) 11010000
 Ñ chr(209) 11010001
 Ò chr(210) 11010010
 Ó chr(211) 11010011
 Ô chr(212) 11010100
 Õ chr(213) 11010101
 Ö chr(214) 11010110
 × chr(215) 11010111
 Ø chr(216) 11011000
 Ù chr(217) 11011001
 Ú chr(218) 11011010
 Û chr(219) 11011011
 Ü chr(220) 11011100
 Ý chr(221) 11011101
 Þ chr(222) 11011110
 ß chr(223) 11011111
 à chr(224) 11100000
 á chr(225) 11100001
 â chr(226) 11100010
 ã chr(227) 11100011
 ä chr(228) 11100100
 å chr(229) 11100101
 æ chr(230) 11100110
 ç chr(231) 11100111
 è chr(232) 11101000
 é chr(233) 11101001
 ê chr(234) 11101010
 ë chr(235) 11101011
 ì chr(236) 11101100
 í chr(237) 11101101
 î chr(238) 11101110
 ï chr(239) 11101111
 ð chr(240) 11110000
 ñ chr(241) 11110001
 ò chr(242) 11110010
 ó chr(243) 11110011
 ô chr(244) 11110100
 õ chr(245) 11110101
 ö chr(246) 11110110
 ÷ chr(247) 11110111
 ø chr(248) 11111000
 ù chr(249) 11111001
 ú chr(250) 11111010
 û chr(251) 11111011
 ü chr(252) 11111100
 ý chr(253) 11111101
 þ chr(254) 11111110
 ÿ chr(255) 11111111

 

Reageer !

reacties