Binarité

par **Cyberdemon** Dim 13 Jan - 21:43

Tous les microprocesseurs l'utilise : le code binaire.
Un bit est un 0 ou un 1. Il s'agit de la plus petite unité d'information manipulable par une machine numérique. Un petit exemple de codage : Si vous vouliez programmer un chiffre en code binaire vous écririez ceci :
1 : 00000001
2 : 00000010
3 : 00000011
4 : 00000100
5 : 00000101
6 : 00000110
7 : 00000111
8 : 00001000
9 : 00001001
10 : 00001010
11 : 00001011
12 : 00001100
13 : 00001101
14 : 00001110
15 : 00001111
ect...

par **Skritch** Jeu 17 Jan - 12:47

Binaire Caractère

00000000 NUL (Null char.)
00000001 SOH (Start of Header)
00000010 STX (Start of Text)
00000011 ETX (End of Text)
00000100 EOT (End of Transmission)
00000101 ENQ (Enquiry)
00000110 ACK (Acknowledgment)
00000111 BEL (Bell)
00001000 BS (Backspace)
00001001 HT (Horizontal Tab)
00001010 LF (Line Feed)
00001011 VT (Vertical Tab)
00001100 FF (Form Feed)
00001101 CR (Carriage Return)
00001110 SO (Shift Out)
00001111 SI (Shift In)
00010000 DLE (Data Link Escape)
00010001 DC1 (XON)(Device Control 1)
00010010 DC2 (Device Control 2)
00010011 DC3 (XOFF)(Device Control 3)
00010100 DC4 (Device Control 4)
00010101 NAK (Negative Acknowledgement)
00010110 SYN (Synchronous Idle)
00010111 ETB (End of Trans. Block)
00011000 CAN (Cancel)
00011001 EM (End of Medium)
00011010 SUB (Substitute)
00011011 ESC (Escape)
00011100 FS (File Separator)
00011101 GS (Group Separator)
00011110 RS (Request to Send)(Record Separator)
00011111 US (Unit Separator)
00100000 SP (Space)
00100001 ! (exclamation mark)
00100010 " (double quote)
00100011 # (number sign)
00100100 $ (dollar sign)
00100101 % (percent)
00100110 & (ampersand)
00100111 ' (single quote)
00101000 ( (left opening parenthesis)
00101001 ) (right closing parenthesis)
00101010 * (asterisk)
00101011 + (plus)
00101100 , (comma)
00101101 - (minus or dash)
00101110 . (dot)
00101111 / (forward slash)
00110000 0
00111010 : (colon)
00111011 ; (semi-colon)
00111100 < (less than sign)
00111101 = (equal sign)
00111110 > (greater than sign)
00111111 ? (question mark)
01000000 @ (AT symbol)
01000001 A
01000010 B
01000011 C
01000100 D
01000101 E
01000110 F
01000111 G
01001000 H
01001001 I
01001010 J
01001011 K
01001100 L
01001101 M
01001110 N
01001111 O
01010000 P
01010010 R
01010001 Q
01010100 T
01010101 U
01010110 V
01010111 W
01011000 X
01011001 Y
01011010 Z
01011100 \ (back slash)
01011101 ] (right closing bracket)
01011110 ^ (caret cirumflex)
01011111 _ (underscore)
01100000 `
01100001 a
01100010 b
01100011 c
01100100 d
01100101 e
01100110 f
01100111 g
01101000 h
01101001 i
01101010 j
01101011 k
01101100 l
01101101 m
01101110 n
01101111 o
01110000 p
01110001 q
01110010 r
01110011 s
01110100 t
01110101 u
01110111 w
01111000 x
01111001 y
01111010 z
01111011 { (left opening brace)
01111100 | (vertical bar)
01111101 } (right closing brace)
01111110 ~ (tilde)
01111111 DEL (delete)

par **Cyberdemon** Ven 18 Jan - 23:24

Le code binaire permet de faire des opérations. 1 signifie vrai en language machine. Physiquement, quand un 1 est activé, ça veut dire que le courant passe dans un condensateur. 0 c'est faux (le courant ne passe pas.).
Le système du bit fonctionne par puissances : 3 bit à la suite se calculent comme 2^3. 2 parce qu'on a le choix entre 1 et 0. 3 parce que il y a trois bits. On obtient alors 8 possibilité :
0 0 0
0 0 1
0 1 0
0 1 1
1 1 1
1 1 0
1 0 1
1 0 0
Si maintenant on essaye de savoir qu'elle est le plus grand nombre possible dans un octet (8 bits), il suffit de faire 2^8 ce qui donne 256.
11111111 = 256.

un octet = 8 bits
un Ko = 1000 octets
un Mo = 1000 Ko
un Go = 1000 Mo
un To = 1000 Go

Maintenant vous avez des bases permettant de faire des opération ! Smile

On va étudier la plus simple : La multiplication
C'est exactement la même chose qu' en décimal mais avec des 0 et des 1. 0*0=0*1=0; 1*1=1;

ex : Exemple :

0 1 1 1 1 1
* 1 1 0
____________
0 0 0 0 0 0
0 1 1 1 1 1
0 1 1 1 1 1
1 0 1 1 1 0 1 0

L'addition
C'est exactement comme les décimaux sauf que quand la somme dépasse 1, on fait une retenue.

ex :
0 1 1 1 1 1
+ 0 1 1 0 0 1
___________
1 1 1 0 0 0

La soustraction :
Comme l'addition, sauf que lorsque l'on soustrait un bit à un d'un bit à zéro, on soustrait une retenue pour le bit de poids plus élevé.

ex :
0 1 1 1 1 0
- 0 1 1 0 0 1
__________
0 0 0 1 0 1

Maintenant que vous savez faire des opérations, vous allez essayer de convertir des nombres décimaux en nombres primaires
Moi j'ai trouvé une méthode :
prenons 12 à convertir. On le divise par deux le jusqu'à ce que le nombre trouvé soit 1:
12/2
= 6*2 + 0
= 3*2 + 0
= 1*2 + 1
= 1*1=>1
On prends les nb du dernier résultat trouvé jusqu'au premier donc on obtient : 12 = 00001100 (Vérifiez dans le premier post).