Langage haut-niveau : ne pas se soucier de la réalité du stockage
1 mois en NSI et pas un mot sur le binaire pour l'instant. Pourquoi ? Simplement car Python et Javascript sont des langages dits "de haut-niveau" : ils sont conçus pour que le développeur n'ai pas besoin de se soucier de la façon dont les données sont réellement gérées physiquement.
Le développeur parle à l'interpréteur Python.
L'interpréteur Python traduit et parle en langage machine.
On peut dire que l'interpréteur joue le rôle d'interface entre les deux mondes.
Langage bas-niveau : gestion du stockage réel des données
Au niveau électronique physique, l'ordinateur stocke les données sous forme d'octets.
Un système informatique ne sait que stocker des 0 ou des 1 .
Il faut donc savoir passer d'une représentation décimale (base 10) à une représentation binaire (base 2).
Encore faut-il savoir comment cela fonctionne...
C'est le principe de cette première activité.
Et si on ne sait pas comment ça fonctionne, c'est grave ?
Dans 99% des cas, non. Les langages de haut niveau permettent même de programmer sans jamais faire de binaire. D'ailleurs, la preuve : vous n'en avez pas fait une ligne depuis le début de l'année !
Mais, parfois, ça tourne mal...
Cette image en est la preuve :
Logiciel nécessaire pour l'activité : Arduino, la bibliothèque Makeblock et un robot, uniquement si vous voulez reproduire l'expérience d'introduction.
Exercices corrigés complémentaires de cours : exos
Documents de cours : open document ou pdf
Présentation de cours : open document ou pdf
Magie Magie : open document ou pdf
Regardons ce petit programme Arduino (proche du C++) qu'on va appliquer à un robot Makeblock, compatible Arduino.
Le but est de le faire tourner sur lui-même de plus en plus rapidement.
Nous n'analyserons pas en détail le code. Si vous voulez en savoir plus sur ce langage, allez voir l'annexe.
Comment commander un robot qui possède deux systèmes de motorisation, un à gauche et un à droite pour qu'il tourne sur lui-même ?
Avec le système Makeblock, c'est facile :
moteur_gauche.run(vitesse);
moteur_droit.run(vitesse);
moteur_gauche.run(-vitesse);
moteur_droit.run(-vitesse);
moteur_gauche.run(vitesse);
moteur_droit.run(-vitesse);
Et comment augmenter progressivement la vitesse de 1 toutes les 200 ms (soit 0.2s) ?
Simplement en faisant une boucle FOR partant de 0 et s'arrêtant à 499 par exemple :
En Python, ca donnerait cela :
for vitesse in range(0, 500, 1):
moteur_gauche.run(vitesse)
moteur_droit.run(-vitesse)
delay(200)
Mais en C++, ça donne ça :
for (byte vitesse = 0; vitesse < 500 ; vitesse++) {
moteur_gauche.run(vitesse);
moteur_droit.run(-vitesse);
delay(200);
}
On notera que la boucle FOR se code différement qu'en Python mais qu'on retrouve dans l'ordre :
L'une des grosses différences du C (et d'Arduino) par rapport à Python est qu'on doit impérativement fournir le type de la variable qu'on est en train de créer. Ici, j'ai choisi de stocker mes entiers dans une variable de type byte. Dans ce contexte, celui correspond à un octet. Nous verrons ce que cela représente dans cette activité.
Finalement, comment afficher la valeur de la variable vitesse lors de chaque bouclage ?
En lisant la documentation, on se rend compte qu'il existe une méthode permettant d'agir sur les afficheurs : la méthode display.
for (byte vitesse = 0; vitesse < 500 ; vitesse++) {
moteur_gauche.run(vitesse);
moteur_droit.run(-vitesse);
afficheur.display(vitesse);
delay(200);
}
Alors ça marche ce code ?
Si vous n'avez pas la possibilité d'avoir ce robot, voici un exemple de fonctionnement
Et oui. Ca ne marche pas !
La réalité physique vient d'interagir avec nos instructions qui sont censées fonctionner, mais non...
On constate que
Vous allez sans doute vous demander pourquoi revoir quelque chose d'aussi basique et trivial. Et bien, c'est justement cela le problème.
Vous avez acquis assez de maîtrise sur les calculs sur cette base pour les réaliser sans avoir à vous demander consciemment comment cela fonctionne.
Mais nous allons avoir besoin de ce fonctionnement interne de la base 10 pour comprendre
Voyons comment fonctionne le décodage d'un nombre en base 10 ainsi que l'addition.
Si on écrit M = 3 4 2 9 , on fait ceci en réalité :
| Nombre M = | 3 | 4 | 2 | 9 |
| Le poids de cette case est | 1000 | 100 | 10 | 1 |
| On obtient donc | 3000 | 400 | 20 | 9 |
D'où la valeur de M en base 10 : M = 3000 + 400 + 20 + 9 = 3429 .
On remarquera que :
IMPORTANT : la case de poids le plus faible ( 1 ) est située à droite.
Des chiffres.
Combien et lesquels ?
Base 10 donc 10 CHIFFRES :
On peut écrire le poids des cases en utilisant les puissances de 10 :
| Le poids de cette case est | 1000 | 100 | 10 | 1 |
| qu'on peut écrire sous la forme | 103 | 102 | 101 | 100 |
Comment fonctionne l'addition ? Pourquoi 9+1 donne 10 ?
En réalité, il y a une logique interne à toutes les additions.
Jusqu'à 8, il n'y a pas de difficulté, il suffit de connaître le successeur dans la liste des 10 chiffres disponibles en BASE 10.
Exemple visuel : quel est le successeur de 399 ?
Exemple 1 : le successeur de 8 ?
| Nombre de base | 8 | |
| Si on rajoute 1 à l'unité | +1 | |
| on obtient | 9 |
...EXPLICATION...
On peut augmenter le chiffre de l'unité 8 en le faisant juste passer au chiffre suivant : 9 .
Exemple 2 : le successeur de 9 ?
| Nombre de base | 9 | |
| Si on rajoute 1 à l'unité | +1 | +1 |
| on obtient | 1 | 0 |
...EXPLICATION...
On ne peut augmenter le chiffre de l'unité qui est déjà à 9 .
On la passe donc à 0 ET on incrémente la case juste à gauche.
La case des dizaines était initialement à 0 : elle passe donc à 1 .
Exemple 3 : le successeur de 13 ?
| Nombre de base | 1 | 3 |
| Si on rajoute +1 à l'unité | +1 | |
| on obtient | 1 | 4 |
...EXPLICATION...
On peut augmenter le chiffre de l'unité 3 en le faisant juste passer au chiffre suivant : 4 .
Exemple 4 : le successeur de 399 ?
| Nombre de base | 3 | 9 | 9 |
| Si on rajoute 1 à l'unité | +1 | +1 | +1 |
| on obtient | 4 | 0 | 0 |
...EXPLICATION...
On ne peut augmenter le chiffre qui est déjà à 9 .
On la passe donc à 0 ET on incrémente la case juste à gauche.
La case des dizaines était initialement à 9 : elle passe donc à 0 également et on va devoir augmenter de 1 la case suivante, la case des centaines.
Le chiffre des centaines 3 passe donc à 4 .
Si on ne possède qu'une case ? à remplir,
Si on dispose de 2 cases ?? à remplir,
Si on dispose de 3 cases ??? à remplir,
On voit bien qu'il y a une généralisation à trouver. Laquelle ?
Je vous laisse chercher un peu ...
Et la réponse est :
Exemple : si on dispose de 9 cases
On a donc un milliard de possibilités mais on ne peut pas compter jusqu'à précisément un milliard puisque le cas 0 existe.
Les 10 chiffres usuels.
| Le poids de cette case est | 1000 | 100 | 10 | 1 |
| qu'on peut écrire sous la forme | 103 | 102 | 101 | 100 |
Exemple avec 3 cases
Si vous avez compris comment fonctionne la base 10, vous avez compris la base 2 puisque c'est plus simple : il n'y a que deux chiffres possibles 0 ou 1 !
Si on ouvre une clé USB, on peut voir ceci : pas facile de voir les 0 ou les 1 .
Par contre, dans les premiers ordinateurs, les 0 et les 1 des programmes étaient stockés sur des cartes perforées : c'était plus simple à visualiser : c'est perforé ou non perforé. Deux états physiques bien visibles.
Voyons comment fonctionne le décodage d'un nombre en base 2 ainsi que l'addition.
Il suffit de transformer ce que nous avons vu avec la base 10.
Première modification : nom et contenu des cases
Chaque case se nomme un BIT, mot qui provient de la contraction de BINARY DIGIT.
Que peut-on placer dans un bit ? Des chiffres.
Combien et lesquels ? Base 2 donc 2 CHIFFRES :
Deuxième modification : le poids des cases
Le bit de poids faible est toujours à droite.
On peut facilement trouver le poids des cases en utilisant les puissances de 2 puisqu'on multiplie par deux à chaque fois qu'on décale vers la gauche :
| Le poids de cette case est | 8 | 4 | 2 | 1 |
| qu'on peut écrire sous la forme | 23 | 22 | 21 | 20 |
Exemple 1
Si j'écris un nombre à 4 bits M = 1 0 1 1 , je dois faire ceci pour trouver la valeur de ce nombre en base 10 :
| Nombre M = | 1 | 0 | 1 | 1 |
| Le poids de cette case est | 8 | 4 | 2 | 1 |
| On obtient donc | 8 | 0 | 2 | 1 |
D'où la valeur de M en base 10 : M = 8 + 0 + 2 + 1 = 11 .
Exemple 2
Si j'écris un nombre à 4 bits M = 1 1 0 0 , je dois faire ceci pour trouver la valeur de ce nombre en base 10 :
| Nombre M = | 1 | 1 | 0 | 0 |
| Le poids de cette case est | 8 | 4 | 2 | 1 |
| On obtient donc | 8 | 4 | 0 | 0 |
D'où la valeur de M en base 10 : M = 8 + 4 + 0 + 0 = 12 .
01° Déterminer la valeur en base 10 des nombres A, B, C, D fournis en binaire :
| Nombre A = | 1 | 0 | 0 | 0 |
| Le poids de cette case est | 8 | 4 | 2 | 1 |
| On obtient donc | ? | ? | ? | ? |
| Nombre B = | 0 | 0 | 1 | 0 |
| Le poids de cette case est | 8 | 4 | 2 | 1 |
| Nombre C = | 0 | 1 | 1 | 0 |
| Nombre D = | 1 | 1 | 1 | 0 |
...CORRECTION...
A = 8 + 0 + 0 + 0 = 8 en base 10
B = 0 + 0 + 2 + 0 = 2 en base 10
C = 0 + 4 + 2 + 0 = 6 en base 10
D = 8 + 4 + 2 + 0 = 14 en base 10
C'est un peu bizarre d'écrire que 1100 = 12 ou que 1011 = 11 non ?
Le problème vient du fait qu'un nombre en base 10 peut très bien ne contenir que des 1 et 0. Mille par exemple : 1000.
Or 1000 pourrait également représenter un nombre en base 2.
| Nombre M = | 1 | 0 | 0 | 0 |
| Le poids de cette case est | 8 | 4 | 2 | 1 |
| On obtient donc | 8 | 0 | 0 | 0 |
D'où la valeur de M en base 10 : M = 8 + 0 + 0 + 0 = 8 .
On voit donc qu'il faudrait noter (1000 en base 2) vaut (8 en base 10).
Pour rendre les choses plus claires, une notation courante consiste à indiquer la base en indice, avec ou sans parenthèses.
Le décimal (base 10) étant notre base naturelle, on la précise rarement lorsqu'on fournit un nombre dans cette base. On retrouve assez souvent cette façon de faire dans les textes :
Sous entendu, 8 en base 10 puisqu'on ne précise pas la base.
A titre d'exemple final, voilà la correction de l'exercice 1 en utilisant ces notations :
A = 1000 2 = ( 8 + 0 + 0 + 0 ) 10 = 8
B = 0010 2 = ( 0 + 0 + 2 + 0 ) 10 = 2
C = 0110 2 = ( 0 + 4 + 2 + 0 ) 10 = 6
C'est déjà plus clair.
Alors ça fonctionne comment l'addition ? Pourquoi 1 2 + 1 2 donne 10 2 ? On se le demande, non ?
Jusqu'à 1, il n'y a pas de difficulté, il suffit de suivre la liste des CHIFFRES disponibles : 0 puis 1 .
Lorsqu'on veut rajouter 1 dans une cases, la case a deux valeurs de départ, donc il y a deux cas à gérer.
Utiliser une base différente de 10 ne change rien à la "logique" des nombres.
Après ||| choses, il y a encore |||| choses quelque soit la façon dont on exprime le nombre de choses.
C'est comme l'idée d'un chat. Le fait de dire "cat" en anglais ne change rien à l'idée derrière "chat" en Français ou "gato" en Espagnol ou "Katze" en Allemand ou encore "猫" en Japonais...
Il s'agit juste d'un langage.
Exemple 1 : le successeur de 02 ?
| Nombre de base | 0 | |
| Si on rajoute +1 à l'unité | +1 | |
| on obtient | 1 |
...EXPLICATION...
On peut augmenter le chiffre de l'unité 0 en le faisant juste passer au chiffre suivant : 1 .
Exemple 2 le successeur de 12 ?
| Nombre de base | 1 | |
| Si on rajoute +1 à l'unité | +1 | +1 |
| on obtient | 1 | 0 |
...EXPLICATION...
On ne peut augmenter le chiffre de l'unité qui est déjà à 1 .
On le repasse donc à 0 ET on incrémente la case juste à gauche.
La case des "dizaines" était initialement à 0 : elle passe donc à 1 .
Exemple 3 le successeur de 102 ?
| Nombre de base | 1 | 0 |
| Si on rajoute +1 à l'unité | +1 | |
| on obtient | 1 | 1 |
...EXPLICATION...
On peut augmenter le chiffre de l'unité 0 en le faisant juste passer au chiffre suivant : 1 .
Exemple 4 le successeur de 112 ?
| Nombre de base | 1 | 1 | |
| Si on rajoute +1 à l'unité | +1 | +1 | +1 |
| on obtient | 1 | 0 | 0 |
...EXPLICATION...
On ne peut augmenter le chiffre du bit de poids faible qui est déjà à 1 .
On le passe donc à 0 ET on incrémente la case juste à gauche.
La case suivante était initialement à 1 : elle passe donc à 0 également et on va devoir augmenter de 1 la case suivante.
Le chiffre de la case la plus à gauche 0 passe donc à 1 .
02° Compléter la séquence de nombres binaires de 000 à 111 en incrémentant le nombre précédent de 1 à chaque fois (vous pouvez modifier les valeurs dans les cases vides ? en cliquant sur le caractère. Indiquer sur votre copie le nombre équivalent en base 10 dans la dernière colonne.
0 |
0 |
0 |
En base 10 ? |
0 |
0 |
1 |
En base 10 ? |
? |
? |
? |
En base 10 ? |
? |
? |
? |
En base 10 ? |
? |
? |
? |
En base 10 ? |
? |
? |
? |
En base 10 ? |
? |
? |
? |
En base 10 ? |
1 |
1 |
1 |
En base 10 ? |
...CORRECTION...
0 |
0 |
0 |
0 |
0 |
0 |
1 |
1 |
0 |
1 |
0 |
2 |
0 |
1 |
1 |
3 |
1 |
0 |
0 |
4 |
1 |
0 |
1 |
5 |
1 |
1 |
0 |
6 |
1 |
1 |
1 |
7 |
Si on possède une case ? à remplir, on peut donc définir 2 valeurs de 0 à 1 .
Comme le premier cas est numéroté 0, on a bien 1+1 = 2 valeurs possibles.
Si on dispose de 2 cases ?? à remplir, on peut définir des valeurs de 00 à 11 .
Comme le premier cas est numéroté 0, on a bien 3+1 = 4 valeurs possibles :
Si on dispose de 3 cases ??? à remplir, on peut définir des valeurs de 000 à 111 .
Comme le premier cas est numéroté 0, on a bien 7+1 = 8 valeurs possibles.
On voit bien qu'il y a une généralisation à trouver. Laquelle ?
Je vous laisse chercher un peu ...
Et la réponse est :
Exemple : si on dispose de 8 bits
Chaque case se nomme un BIT (contraction de BINARY DIGIT).
Les 2 CHIFFRES de la base 2 sont : 0 ou 1 .
| Le poids de cette case est | 8 | 4 | 2 | 1 |
| qu'on peut écrire sous la forme | 23 | 22 | 21 | 20 |
Exemple avec 3 bits :
Si on dispose de X cases/bits,
Exemple : si on dispose de 8 bits
Un octet est un ensemble de 8 bits successifs.
Un octet possède donc 28, soit 256 valeurs différentes, de 0 à 255.
Sous forme binaire, un octet est donc compris entre 0000 0000 2 et 1111 1111 2.
Partant d'un bit de poids faible valant 20, on obtient donc un bit de poids fort pesant 27, soit 128.
| Poids | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
| Poids | 27 | 26 | 25 | 24 | 23 | 22 | 21 | 20 |
Considérons l'octet M suivant, M = 1010 1011 .
| Nombre M = | 1 | 0 | 1 | 0 | 1 | 0 | 1 | 1 |
| Les bits codent | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
D'où la valeur de M en base 10 : M = 128 + 32 +8 + 2 + 1 = 171 .
On peut donc écrire que M = ( 171 ) 10 = ( 1010 1011 ) 2
Voici un convertisseur automatique d'OCTET que vous pourrez utiliser en cas de doute :
Votre nombre binaire M :
| Nombre M = | ||||||||
| Les bits codent | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
| On obtient donc |
D'où la valeur de M en base 10 : M = = .
03° Donner, en la justifant, la valeur décimale de ces octets dont on donne la valeur binaire :
0100 1000 1000 0011 1111 1111 ...CORRECTION...
0100 1000 2 = 72 10En effet : 64 + 8 = 72
1000 0011 2 = 131 10En effet : 128 + 2 + 1 = 131
1111 1111 2 = 255 10En effet : 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255
Dans l'autre sens, ce n'est pas plus compliqué lorsque le nombre n'est pas grand : il suffit d'activer progressivement les bits de poids forts nécessaire pour encoder le nombre.
Nous allons présenter ici la méthode de l'activation progressive.
On active progressivement les bits en commençant systématiquement par le bit le plus grand nécessaire pour encoder correctement le nombre entier.
Exemple avec 121
Pour obtenir une correction pas à pas étape par étape, vous pouvez suivre le déroulé ci-desous.
...Déroulé pas à pas...
| Nombre M = | ? | ? | ? | ? | ? | ? | ? | ? |
| Les bits codent | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
Le bit associé à 128 est inutile : on le place à 0.
On active par contre le bit associé à 64 qu'on place à 1.
Il nous reste donc 121 - 64 = 57 à encoder.
| Nombre M = | 0 | 1 | ? | ? | ? | ? | ? | ? |
| Les bits codent | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
On active donc le bit de 32. Et il reste 57 - 32 = 25 à encoder.
| Nombre M = | 0 | 1 | 1 | ? | ? | ? | ? | ? |
| Les bits codent | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
On active donc le bit de 16. Et il reste 25 - 16 = 9 à encoder.
On active donc le bit de 9. Et il reste 9 - 8 = 1 à encoder : il suffit d'activer le bit de poids faile et c'est fini. On sait qu'on peut placer les autres à 0.
| Nombre M = | 0 | 1 | 1 | 1 | 1 | 0 | 0 | 1 |
| Les bits codent | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
Sur une copie, on peut justifier de cette façon :
Pour encoder 121 :
04° En activant progressivement les bits de poids fort nécessaires, trouver l'encodage binaire des entiers suivants :
La méthode de la division euclidienne par deux est plus systématique. Elle consiste à diviser le nombre par deux jusqu'à atteindre un quotient de 0.
Les restes de la division euclidienne vont fournir les valeurs des bits.
On continue jusqu'à avoir un résultat de 0.
Comment obtenir la décomposition ?
En partant du bas pour le bit de poids fort et en remontant vers le haut jusqu'au bit de poids faible :
On peut alors écrire que 132 10 = 1000 0100 2.
05° En utilisant la méthode de la division par deux, trouver l'encodage binaire des entiers suivants :
Un octet possède 256 valeurs différentes.
Lorsqu'on veut mémoriser une information en machine, il suffit donc d'attribuer une valeur à une information.
Cela se nomme un encodage.
Les techniques d'encodage n'ont rien de secret : elles doivent être connues et diffusées de façon à pouvoir encoder puis à décoder.
Ne confondez pas encodage et chiffrement/cryptage.
La première utilisation de l'octet est bien entendu la mise en mémoire d'un nombre entier naturel de 0 à 255 inclus.
Un autre exemple: l'encodage de caractères, dont toutes les versions sont compatibles avec les valeurs de l'encodage ASCII pour les valeurs inférieures à 128.
En ASCII, la lettre A est encodé par un octet valant 65, le B par 66...
Voici un court extrait de cette table d'encodage :
| _0 | _1 | _2 | _3 | _4 | _5 | _6 | _7 | _8 | _9 | |
|---|---|---|---|---|---|---|---|---|---|---|
| 6_ | < | = | > | ? | @ | A | B | C | D | E |
| 7_ | F | G | H | I | J | K | L | M | N | O |
| 8_ | P | Q | R | S | T | U | V | W | X | Y |
| 9_ | Z | [ | \ | ] | ^ | _ | ` | a | b | c |
| 10_ | d | e | f | g | h | i | j | k | l | m |
| 11_ | n | o | p | q | r | s | t | u | v | w |
On voit que
Avec ce type d'encodage de caractères sur un octet, on ne peut donc représenter que 256 caractères différents.
Un dernier exemple : l'encodage des couleurs. Vous avez peut-être vu en seconde que les pixels sont composés d'une composant R pour Red, G pour Green et B pour Blue.
Chaque composante est une valeur qui est stockée dans un octet. On dispose donc de 256 nuances de la couleur, variant de 0 à 255.
Un pixel prend donc une place mémoire de 3 octets.
Si on rajoute une couche de transparence, on lui attribue également un octet, pour atteindre un poids de 4 octets par pixel.
Voici les intensités de rouge pour des valeurs comprises entre 0 et 255. Vous allez voir que cela suffit car l'oeil humain ne peut déjà pas distinguer des intensités de valeurs proches.
| Valeur | Visuel | Valeur | Visuel | Valeur | Visuel |
|---|---|---|---|---|---|
| 0 | 85 | 170 | |||
| 1 | 86 | 171 | |||
| 2 | 87 | 172 | |||
| 3 | 88 | 173 | |||
| 4 | 89 | 174 | |||
| 5 | 90 | 175 | |||
| 6 | 91 | 176 | |||
| 7 | 92 | 177 | |||
| 8 | 93 | 178 | |||
| 9 | 94 | 179 | |||
| 10 | 95 | 180 | |||
| 11 | 96 | 181 | |||
| 12 | 97 | 182 | |||
| 13 | 98 | 183 | |||
| 14 | 99 | 184 | |||
| 15 | 100 | 185 | |||
| 16 | 101 | 186 | |||
| 17 | 102 | 187 | |||
| 18 | 103 | 188 | |||
| 19 | 104 | 189 | |||
| 20 | 105 | 190 | |||
| 21 | 106 | 191 | |||
| 22 | 107 | 192 | |||
| 23 | 108 | 193 | |||
| 24 | 109 | 194 | |||
| 25 | 110 | 195 | |||
| 26 | 111 | 196 | |||
| 27 | 112 | 197 | |||
| 28 | 113 | 198 | |||
| 29 | 114 | 199 | |||
| 30 | 115 | 200 | |||
| 31 | 116 | 201 | |||
| 32 | 117 | 202 | |||
| 33 | 118 | 203 | |||
| 34 | 119 | 204 | |||
| 35 | 120 | 205 | |||
| 36 | 121 | 206 | |||
| 37 | 122 | 207 | |||
| 38 | 123 | 208 | |||
| 39 | 124 | 209 | |||
| 40 | 125 | 210 | |||
| 41 | 126 | 211 | |||
| 42 | 127 | 212 | |||
| 43 | 128 | 213 | |||
| 44 | 129 | 214 | |||
| 45 | 130 | 215 | |||
| 46 | 131 | 216 | |||
| 47 | 132 | 217 | |||
| 48 | 133 | 218 | |||
| 49 | 134 | 219 | |||
| 50 | 135 | 220 | |||
| 51 | 136 | 221 | |||
| 52 | 137 | 222 | |||
| 53 | 138 | 223 | |||
| 54 | 139 | 224 | |||
| 55 | 140 | 225 | |||
| 56 | 141 | 226 | |||
| 57 | 142 | 227 | |||
| 58 | 143 | 228 | |||
| 59 | 144 | 229 | |||
| 60 | 145 | 230 | |||
| 61 | 146 | 231 | |||
| 62 | 147 | 232 | |||
| 63 | 148 | 233 | |||
| 64 | 149 | 234 | |||
| 65 | 150 | 235 | |||
| 66 | 151 | 236 | |||
| 67 | 152 | 237 | |||
| 68 | 153 | 238 | |||
| 69 | 154 | 239 | |||
| 70 | 155 | 240 | |||
| 71 | 156 | 241 | |||
| 72 | 157 | 242 | |||
| 73 | 158 | 243 | |||
| 74 | 159 | 244 | |||
| 75 | 160 | 245 | |||
| 76 | 161 | 246 | |||
| 77 | 162 | 247 | |||
| 78 | 163 | 248 | |||
| 79 | 164 | 249 | |||
| 80 | 165 | 250 | |||
| 81 | 166 | 251 | |||
| 82 | 167 | 252 | |||
| 83 | 168 | 253 | |||
| 84 | 169 | 254 | |||
| 85 | 170 | 255 |
Nous retrouverons cette notion d'octets dans beaucoup d'activités. Nous verrons ainsi plus dans le détail l'encodage et la taille nécessaire pour placer en mémoire un texte, une image ou une vidéo.
Il existe deux types de sous-unités de l'octet mais seul le premier est couramment utilisé dans la description des produits.
| Sous-unité | Valeur en décimal | Pourquoi ? |
|---|---|---|
| Un kilo (k) représente 103 | 1 000 |
|
| Un Méga (M) représente 106 | 1 000 000 |
un million, soit 1000 x 1 000 |
| Un Giga (G) représente 109 | 1 000 000 000 |
un milliard, soit 1000 x 1 000 000 |
| Un Téra (T) représente 1012 | 1 000 000 000 000 |
mille milliards, soit 1000 x 1 000 000 000 |
On voit donc que chaque sous-unité représente 1000 fois plus que la précédente.
Avant 1998, un ko voulait dire 1024 octets. Aujourd'hui, 1 ko veut bien dire 1000 octets. Si on veut parler d'un kilo-octet valant 1024 octets, on parle de kio plutôt que de ko.
Aujourd'hui 1 ko = 1000 o
Aujourd'hui 1 kio = 1024 o
Le système précédent est basé sur la base 10. En informatique, on travaille en base 2 puisqu'on est en binaire. Il existe donc une façon plus 'naturelle' de définir les relations entre les unités. Naturelle pour un ordinateur, moins pour les humains...
Pour les distinguer des autres unités, on rajoute un i à la fin.
| Sous-unité | Valeur en décimal | Pourquoi ? |
|---|---|---|
| Un kilo (ki) représente 210 | 1 024 |
|
| Un Méga (Mi) représente 220 | 1 048 576 |
Presque un million, 1024 x 1024 |
| Un Giga (Gi) représente 230 | 1 073 741 824 |
Presque un milliard, soit 1024 x 1 048 576 |
| Un Téra (Ti) représente 240 | 1 099 511 627 776 |
Presque mille milliards, soit 1024 plus que 1 Gi |
On voit donc que chaque sous-unité représente 1024 fois plus que la précédente.
06° On considère un texte de 200 000 caractères. Calculer le nombre d'octets nécessaires à son stockage
...CORRECTION...
200 000 caractères donnent donc nbr_octets = 200 000 o.
Comme un octet est composé de 8 bits, nous obtenons :
nbr_bits = 200 000 * 8, soit nbr_bits = 1 600 000 b.
Pour obtenir le poids en ko, il suffit de diviser ce nombre par 1000 :
nbr_octets = 200 000 / 1000, soit nbr_octets = 200 ko.
Pour obtenir le poids en Mo, il suffit de diviser le nombre d'octets par 1 000 000 ou le nombre de ko par 1000 :
nbr_octets = 200 000 / 1 000 000, soit nbr_octets = 0.2 Mo.
nbr_octets = 200 ko / 1000, soit nbr_octets = 0.2 Mo.
Avant d'en montrer toute l'utilité, voyons comme fonctionne l'hexadécimal.
Voyons comment fonctionne le décodage d'un nombre en base 16 ainsi que l'addition.
Des chiffres.
Combien et lesquels ?
Base 16 donc 16 CHIFFRES : 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - A - B - C - D - E - F .
Pourquoi avoir pris des lettres plutôt que d'inventer de nouveaux symboles ? Parce que c'est plus facile ! En plus, les tables ne comportant que 128 symboles initialement, c'était plus rentable de recycler plutôt que d'en inventer de nouveaux. Il n'y avait déjà plus de place.
De 0 à 9, ce ne change pas :
N = 0 10 = 0 16
N = 1 10 = 1 16
N = 2 10 = 2 16
...
N = 9 10 = 9 16
Mais ensuite
N = 10 10 = A 16
N = 11 10 = B 16
N = 12 10 = C 16
N = 13 10 = D 16
N = 14 10 = E 16
N = 15 10 = F 16
La case de poids faible ( 1 ) est toujours située à droite.
On peut écrire facilement le poids des cases en utilisant les puissances de 16 :
| La case code | 4096 | 256 | 16 | 1 |
| qu'on peut écrire sous la forme | 163 | 162 | 161 | 160 |
Exemple
Si j'écris M= 3429 16, je fais ceci en réalité dans ma tête :
| Nombre M = | 3 | 4 | 2 | 9 |
| La case code | 4096 | 256 | 16 | 1 |
| On obtient donc | 4096*3 | 256*4 | 16*2 | 1*9 |
D'ou la valeur de M en base 10 : M = 4096*3 + 256*4 + 16*2 + 9 = 13353 .
On peut donc écrire N = 3429 16 = 13353 10.
L'exemple ne comporte aucun chiffre A à F volontairement. Difficile de savoir que 3429 est un nombre exprimé en hexadécimale si on ne l'indique pas par l'indice 16.
07° Montrer qu'on a bien N = 41 16 = 65 10. Il s'agit des deux valeurs rencontrées pour A en ASCII.
...CORRECTION...
Il suffit de calculer la valeur en base 10 avec 4 dans la case de droite et 1 dans la case de gauche..
On obtient N = 4 * 16 + 1 = 65.
08° Montrer que N = FF 16 = 255 10. Il s'agit de la valeur maximale pour un octet.
...CORRECTION...
Il suffit de calculer la valeur en base 10 avec F dans la case de droite et F dans la case de gauche.
Le chiffre F en base 16 correspond au nombre 15 en base 10.
On obtient N = 15 * 16 + 15 * 1 = 255.
09° Montrer que N = FE 16 = 254 10. Il s'agit de la valeur maximale pour un octet.
...CORRECTION...
Il suffit de calculer la valeur en base 10 avec F dans la case de droite et E dans la case de gauche.
Le chiffre E en base 16 correspond au nombre 14 en base 10.
On obtient N = 15 * 16 + 14 * 1 = 254.
Alors ça fonctionne comment l'addition ? Pourquoi F+1 donne 10 ? On se le demande non ?
Jusqu'à F, il n'y a pas de difficulté, il suffit de suivre la liste des CHIFFRES disponibles.
Base 16 donc 16 CHIFFRES : 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - A - B - C - D - E - F .
Exemple 1 :
| Si on rajoute 1 à | 9 | |
| on obtient | A |
...EXPLICATION...
On peut augmenter le chiffre de l'unité 9 en le faisant juste passer au chiffre suivant : A .
Exemple 2 :
| Si on rajoute 1 à | E | |
| on obtient | F |
...EXPLICATION...
On peut augmenter le chiffre de l'unité E en le faisant juste passer au chiffre suivant : F .
Exemple 3 : cette fois, on va devoir rajouter une case à droite (elle contient 0 initialement puisqu'elle n'apparaît pas)
| Si on rajoute 1 à | F | |
| on obtient | 1 | 0 |
...EXPLICATION...
On ne peut augmenter le chiffre de l'unité qui est déjà à F .
On la passe donc à 0 ET on incrémente la case juste à gauche.
La case de gauche était initialement à 0 : elle passe donc à 1 .
Exemple 4 :
| Si on rajoute 1 à | 1 | 3 |
| on obtient | 1 | 4 |
...EXPLICATION...
On peut augmenter le chiffre de l'unité 3 en le faisant juste passer au chiffre suivant : 4 .
Exemple 5 :
| Si on rajoute 1 à | F | 3 |
| on obtient | F | 4 |
...EXPLICATION...
On peut augmenter le chiffre de l'unité 3 en le faisant juste passer au chiffre suivant : 4 .
Exemple 6 :
| Si on rajoute 1 à | 3 | F | F |
| on obtient | 4 | 0 | 0 |
...EXPLICATION...
On ne peut augmenter le chiffre qui est déjà à F .
On la passe donc à 0 ET on incrémente la case juste à gauche.
La case juste à gauche était initialement à F : elle passe donc à 0 également et on va devoir augmenter de 1 la case suivante, la case la plus à gauche.
Le chiffre des centaines 3 passe donc à 4 .
Si on ne possède qu'une case ? à remplir, on peut donc définir 16 valeurs de 0 à 15 10 ( soit F 16).
Comme le premier cas est numéroté 0, on a bien 15+1 = 16 valeurs possibles.
Si on dispose de 2 cases ?? à remplir, on peut définir des valeurs de 00 à FF .
Comme le premier cas est numéroté 0, on a bien 255+1 = 256 valeurs possibles.
On voit bien qu'il y a une généralisation à trouver. Laquelle ?
En hexadécimal, si on dispose de X cases pouvant accueillir un des 16 chiffres de la base 16, le nombre de valeurs possibles est 16X 10.
Attention : dans la mesure où le premier cas est 0, la valeur maximale est donc 16X - 1 10
Exemple : si on dispose de 4 cases
Des chiffres. Combien et lesquels ?
Base 10 donc 10 CHIFFRES : 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - A - B - C - D - E - F .
| La case code | 4096 | 256 | 16 | 1 |
| qu'on peut écrire sous la forme | 163 | 162 | 161 | 160 |
En hexadécimal, si on dispose de X cases pouvant accueillir un des 10 chiffres de la base 16, le nombre de valeurs possibles est 16X.
Attention : dans la mesure où le premier cas est 0, la valeur maximale est donc 16X - 1
La carte mère de votre ordinateur possède deux types de mémoire :
Ces deux mémoires ont une taille limitée.
Si l'on veut stocker ou partager de grandes quantités de données, il faut donc un autre type de dispositif, une mémoire de masse : disques durs, clés USB... Nous allons parler de ces dispositifs, anciens et récents, dans cette partie.
Cette carte est l'héritière des bandes perforées utilisées dans les métiers à tisser, les pianos et les orgues de Barbarie. Le créateur initial du système de bandes est le français Basile Bouchon en 1725.
Les cartes perforées sont les premiers systèmes de mémoire de masse et de communication (entrée/sortie) qui ont été utilisés au début des systèmes informatiques.
En 1928, IBM dépose le brevet de la carte dite 80 colonnes qui sera la plus utilisée.
En 1950, l'apparition de la bande magnétique va rapidement mettre le stockage précédent à la retraite. La bande magnétique n'existe plus dans l'informatique domestique mais reste encore très utilisée dans les centres de stockage professionnels.
Il s'agit d'une bande plastique d'environ 1,5 cm de largeur sur laquelle on place une poudre d'oxyde de Fer (Fe2O3) qui a comme propriété de pouvoir rester aimantée une fois soumise à un champ magnétique. C'est ainsi qu'on créé le 1 et le 0 : en fonction de l'aimantation du petit secteur qu'on teste.
En 1951 l'UNIVAC était ainsi muni de bandes magnétiques.
Le principal problème ? Il faut dérouler la bande pour arriver à l'endroit voulu. On dit que l'accès est séquentiel : il faut parcourir la bande dans l'ordre. Ca peut être très long si l'information voulue est plutot en fin de bande !
La bande magnétique reste une référence en terme d'archivage de données car elle est moins chère qu'un disque dur. Autre avantage non négligeable : les erreurs d'écriture (un 0 qui se transforme en 1 ou inversement) sont 1000 fois moins nombreuses sur bande magnétique.
L'une des versions grand public de cette technologie est bien entendu la cassette :
Nous restons sur un principe de fonctionnement électro-magnétique avec stockage magnétique.
Comme pour les bandes magnétiques :
La différence fondamentale ? Il ne s'agit pas de bandes mais de disques qui tournent. L'information est répartie par secteur sur tout le disque : pour atteindre la zone voulue, il suffit donc au pire d'attendre que le disque ai fait un tour. C'est plus rapide que de rembobiner toute la bande.
En 1956, la société IBM crée un premier disque dur de 5 Mo. L’ensemble mesurait alors 1,52 x 1,73 x 0,74 m !
C'est à partir des années 1990 que le prix et la taille des disques durs leur permettent d'être présents dans tous les ordinateurs personnels. Et à l'époque, les disques durs étaient internes. Pour transporter un programme ou des informations d'un ordinateur à l'autre, il fallait donc autre chose...
Sans Internet, on utilisait... des disquettes pour transporter l'information d'un ordinateur à un autre.
Une petite révolution cette disquette : dès les années 1960 (et avant la démocratisation des disques durs) on cherche à remplacer le disque dur par un système moins cher et moins lourd.
En 1967, IBM crée la première disquette, capable de contenir environ 80 000 caractères. Elle devait permettre par exemple de transmettre des mises à jour sans Internet. Peu à peu, la disquette remplacera la bande perforée.
Belle révolution qui a permis le transfert d'informations de façon aisée.
Mais la disquette n'a pas survecu à la démocratisation des disques (CD, DVD, Blueray), d'Internet, des disques durs externes puis des clés USB.
Il s'agit de dispositifs optiques, tous basés à peu près sur le même principe d'un rayon laser qui parvient ou pas à traverser une zone opaque pour lui, ou pas.
Avec ces dispositifs, on change de technologie : jusqu'à présent, on avait un stockage de masse magnétique avec partie mécanique mobile pour enrouler ou faire tourner.
La technologie Flash est basée sur l'utilisation de transistors MOS, il s'agit donc d'un stockage purement électronique, sans aucune partie mobile.
La plupart des clés USB et les cartes SD sont issues de cette technologie.
Ces dispositifs sont extrémement pratiques car on peut en trouver une grande variété en terme de taille de stockage : de quelques centaines de Mo à 1 To.
Attention aux bonnes affaires apparentes : pensez toujours à vérifier la vitesse de lecture et d'écriture. Avoir une clé de grande capacité c'est bien. S'il faut 9 jours pour la remplir, c'est nettement moins pratique !
L'USB 2.0 peut avoir une vitesse autour de 25 Mo.s-1.
L'USB 3.0 peut avoir une vitesse autour de 300 Mo.s-1.
L'USB 4.0 peut avoir une vitesse autour de de 40 Go.s-1.
On trouve également des objets ayant la forme d'une clé USB mais contenant plutôt un mini disque dur. On parle alors de flash disk, de microdrive ou de disque dur externe.
Les escrocs ont su profiter de l'attrait de la clé USB. On peut y mettre ce qu'on veut et lancer des programmes automatiquement lorsqu'on connecte la clé sur un ordinateur. Sachant que la difficulté n°1 est d'infecter un premier ordinateur lorsqu'on veut rentrer illégalement sur un réseau, l'arnaque consiste à laisser par terre une clé USB infectée du virus voulu. Qui peut résister et tenter de voir à qui appartient la clé ? Rajoutez une petite étiquette intrigante et vous êtes presque certain que quelqu'un finira par brancher la clé sur son ordinateur. Le facteur humain est souvent le point faible du réseau informatique !
Combien d'entiers positifs ou nuls (entiers non signés) peut-on représenter en machine sur 32 bits ?
A 232 - 1
B 232
C 2 * 32
D 322
...CORRECTION...
B 232 possibilités donc c'est cette réponse.
Si on avait demandé le plus grand nombre entier encodable, il aurait fallu dire 232 - 1.
Voici le code en intégralité :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27 | /* 1 Importation de la biliothèque MeOrion */
#include "MeOrion.h"
/* 2 Instanciations des objets permettant de controler le robot */
MeDCMotor moteur_gauche(M1);
MeDCMotor moteur_droit(M2);
Me7SegmentDisplay afficheur(PORT_6);
/* 3 Fonction setup qui s'active une fois automatiquement au lancement */
void setup() {
for (byte vitesse = 0; vitesse < 500 ; vitesse++) {
moteur_gauche.run(vitesse);
moteur_droit.run(-vitesse);
afficheur.display(vitesse);
delay(200);
}
moteur_gauche.stop();
moteur_droit.stop();
}
/* 4 Fonction loop qui s'active en boucle une fois le setup effectué */
void loop() {
}
|
CLIQUEZ ICI POUR VOIR L'ANIMATION :
moteur_gauche :
moteur_droit :
afficheur :
vitesse :
Activité publiée le 28 08 2019
Dernière modification : 03 10 2024
Auteur : ows. h.