Ce cours donne les bases théoriques et pratiques nécessaires à une bonne compréhension et utilisation des microcontrôleurs. De nombreux exemples seront abordés. Des exercices seront proposés, compatibles avec les cartes à microcontrôleurs Arduino ou LaunchPad MSP430G.
1.6 Représentation binaire
Loading...
En provenance du cours de École Polytechnique Fédérale de Lausanne
Comprendre les Microcontroleurs
46 notes
À partir de la leçon
Semaine 1 : électronique et logique
Durant cette première semaine, nous allons poser quelques bases nécessaires à la suite du cours. Ceux qui sont déjà familiers avec l'électronique n'auront aucune peine à comprendre : nous n'allons qu'effleurer quelques sujets. Mais prenez la peine de suivre en détail les explications. En effet, elles seront orientées vers les concepts dont nous aurons impérativement besoin pour comprendre les Microcontrôleurs.Que ceux qui ont de la peine avec l'électronique et pour qui ces notions sont nouvelles ne s'inquiètent pas : en effet, il leur sera possible de continuer le MOOC même sans avoir maîtrisé ces bases. Ils auront l'occasion de les assimiler progressivement lorsqu'ils feront de la pratique durant les semaines qui viennent.
Rencontrer les enseignants
Jean-Daniel NicoudHon. Prof.
Informatique
Pierre-Yves RochatChargé de cours
EPFL, Génie mécanique
Nous continuons le cours "Comprendre les
microcontrôleurs" Lorsque nous avons parlé de système logique, nous avons vu
qu'on utilisait des 1 et des 0, et
on sentait bien qu'on utilisait le fameux système binaire.
Il est temps qu'on en parle un petit peu plus sérieusement.
Nous allons regarder un peu comment fonctionne le système de
numération binaire.
Nous allons voir aussi comment on peut représenter
des nombres binaires dans des registres, dans des,
objets de taille limitée, d'un nombre de bits
limités, nous allons voir également comment représenter des
nombres positifs et négatifs, donc des nombres signés,
finalement on parlera encore un peu d'hexadécimal, qui
est beaucoup utilisé dans le monde des microcontrôleurs,
de BCD, et également de codage de caractères.
Tout le monde connaît
le système de numération binaire, je ne vais pas en parler avec beaucoup de
détails, on se souvient qu'on a deux
chiffres à disposition, lorsqu'on les a mis les
deux on est obligé d'introduire un rang supplémentaire pour le nombre 10 qui
correspond au 2 du monde décimal, on passe ensuite à 11, on a ensuite besoin d'un
troisième rang ici, pour exprimer 100, c'est-à-dire
le nombre 4, et cetera. On peut remarquer que chaque colonne
représente un poids, ici le poids 1, exprimé en décimal, le
poids 2, le poids 4, le poids 8, qui correspondent d'ailleurs
à 2 à la puissance 0, 2 à la puissance 1, 2 à la
puissance 2, et cetera.
Lorsqu'on souhaite passer du binaire au décimal, c'est relativement simple, il
suffit d'additionner les poids, donc ici on va dire qu'on a zéro fois le poids 1,
qu'on a une fois le poids 2, qu'on a zéro fois le poids 4,
on a une fois le poids 8, le résultat nous donne 8 plus 2,
c'est-à-dire 10 en décimal. Le système binaire c'est très facile.
Le problème qui se pose, c'est que dans le système binaire
des nombres, on peut avoir des nombres aussi grands qu'on le souhaite.
Or, dans la réalité, on va avoir des objets binaires de
taille limitée, et c'est là que les problèmes commencent à se présenter.
On a vu qu'une bascule peut mémoriser une valeur
binaire, un bit, on parle de registre lorsqu'on est en face d'un ensemble de
plusieurs bascules, un registre contient un mot binaire, remarquez que je n'ai
pas écrit un nombre binaire, ce mot binaire peut avoir une signification a
priori quelconque, et dans certaines situations,
ce mot binaire va représenter un nombre.
Essayons d'y voir un petit peu plus clair.
On donne souvent un numéro à chacun des bits, ici j'ai présenté
un octet, un mot de 8 bits, on va donner des numéros qui commencent par zéro,
les informaticiens ont toujours l'habitude de commencer
par zéro, on termine ici au bit
7, prenons un exemple concret: on a une valeur binaire placée dans un registre.
La seule chose qu'on
peut affirmer, c'est que ce bit est à 1, ce bit
est à 1, et que les autres bits sont à zéro.
Il n'est pour le moment pas question de nombres.
D'ailleurs, nous aurons l'occasion de voir dans un
dispositif que nous allons utiliser très souvent dans ce
cours "Comprendre les microcontrôleurs" que, à cet endroit-là,
d'un certain registre, se trouvera une led rouge connectée,
qu'à cet endroit se connectera une led verte, donc on
peut dire qu'avec ce mot binaire dans le registre en
question, on va allumer la lampe rouge et on va
éteindre la lampe verte, on ne peut rien dire d'autre.
Par contre, si ce mot est considéré comme un nombre binaire, alors on
peut faire ce qu'on a fait tout à l'heure, calculer sa valeur en décimal, ici une
fois 1, zéro fois 2, fois 4, fois 8,
fois 16, une fois 32, ça nous donne donc le résultat 33.
La question c'est que ce mot binaire qui représente un
nombre binaire, est-ce que c'est possible de travailler avec lui?
Et en fait c'est tout le problème de l'arithmétique modulaire qu'on va essayer
d'effleurer maintenant.
Prenons pour simplifier un exemple, qui n'est pas
très utilisé, mais les mots de 3 bits.
Chaque mots de 3 bits peut représenter 8 nombres différents.
C'est en effet la valeur de 2 à la puissance 3.
On peut par exemple décider de représenter les nombres
positifs allant de zéro à 7, c'est-à-dire de zéro
à 2 à la puissance 3 moins 1. Est-ce que l'addition,
dont on a l'habitude en arithmétique, peut fonctionner?
Prenons un exemple: 10 plus 1.
Comme il s'agit de nombres de 3 bits, je devrais écrire ici clairement les
valeurs des deux autres bits. je vais faire le calcul, zéro plus
1 me donne 1, 1 plus zéro, me donne
1, zéro plus zéro me donne zéro, le nombre écrit
en binaire, ici c'était la valeur 2, ici c'était la
veleur 1, le résultat c'est 3, tout semble parfaitement correct.
Prenons un second exemple.
On va additionner la valeur 3 à la valeur 3.
Le total sera: 1 plus 1, ça me
donne zéro, j'ai une retenue de 1. 1 plus 1 plus 1, ça va me
donner 1, avec une retenue de 1, et ici j'ai donc un 1.
Et maintenent je mets les valeurs en binaire, j'avais le nombre
3, j'avais le nombre 3, ici j'ai la valeur zéro fois 1,
plus une fois 2, plus une fois 4, c'est donc bien égal à la
valeur 6, c'est donc tout à fait correct. Prenons un dernier
exemple, la valeur 6 auquel j'additionne
la valeur 3. Et au total j'obtiens:
zéro plus 1 me donne un, 1 plus 1 me donne
zéro, je retiens 1, 1 plus 1 me donne zéro, et
j'ai encore une retenue. Là il se pose effectivement un
problème. J'avais ici le nombre 6,
j'avais ici le nombre 3, et mon résultat est égal à 1.
Pourquoi?
Parce qu'en réalité j'ai perdu le 1 qui devrait
se trouver là, puisque, je vous le rappelle, nous
avons décidé de travailler des mots de 3 bits.
On est arrivé à ce qu'on appelle le dépassement de capacité.
Donc, comme on l'a vu, on obtient un dépassement
de capacité, le résultat est en fait privé du bit
de poids 8 qui n'existe pas sur une notation à
trois bits, et en fait, du point de vue arithmétique,
le résultat c'est vraiment 6 plus 3, modulo 8, je rappelle que le modulo,
c'est le reste de la division entière, une opération arithmétique très importante.
Essayons de mieux comprendre ces nombres modulaires positifs.
Et il y a deux représentations qui vont nous aider à mieux les comprendre,
d'une part de cercle, et d'autre part cette fonction que nous allons voir ici.
Qu'est-ce qui se passe?
Lorsque je pars de zéro, l'incrémentation, l'ajout de 1, va me passer à 1, à 2, à 3,
à 4, à 5, à 6, à 7, avec
les valeurs binaires correspondantes que vous avez pu lire ici.
Lorsque je rajoute 1 à 7, je retombe sur zéro,
donc cette notation en cercle semble tout à fait cohérente.
Mais qu'est-ce qui s'est passé?
J'ai eu en réalité un dépassement de capacité.
Cette frontière qui se trouve là correspond au dépassement de
capacité, correspond à ce qu'on pourrait appeler une erreur de calcul.
C'est un calcul juste modulo, mais ce n'est
pas un calcul juste au sens habituel du terme.
dans cette représentation, on va représenter les
nombres sur une droite, qui est évidemment infinie,
par contre, la fonction correspondante ne peut prendre que les huit valeurs
qu'on peut exprimer avec 3 bits, et de nouveau on a ce phénomène
de dépassement de capacité qui va se produire lors du passage de la
valeur 7 à la valeur zéro, à chaque fois qu'on franchit cette ligne-là.
Il reste encore un problème important, c'est la possibilité
de représenter des nombres négatifs, on est très souvent intéressé
d'avoir à la fois des nombres positifs et négatifs, et
de ne pas devoir les traiter séparément au niveau d'un
programme, et il existe plusieurs
solutions pour représenter ces nombres négatifs.
je ne vais pas toutes vous les énumérer, évidemment, utilisons plutôt celle qui est
la plus utilisée, qu'on appelle la notation à complément à deux.
En fait j'ai repris les deux dessins de tout à l'heure, mais cette
fois on a décidé d'attribuer, bon, la même chose pour le
zéro, pour le 1, pour le 2, pour le 3, mais ici on a décidé de faire une
frontière qui sera la frontière du dépassement de capacité, et
les nombres qui suivent seront moins 4, moins 3,
moins 2, moins 1, et puis ici zéro.
Alors ça ce n'est pas vraiment une frontière
on passe simplement des nombres négatifs aux nombres positifs,
ou des nombres positifs aux nombres négatifs, je mets
quand même ici une petite ligne, mais c'est une
ligne en quelques sortes correcte du point de
vue des calculs, par contre, la ligne qui est
dangereuse, le dépassement de capacité, qui avant se trouvait
dns cette région-là, se trouve maintenent dans cette région-là.
Et on voit bien sur
l'autre diagramme que on a le même problème lorsqu'on passe ici
de 3 à moins 4, on a un dépassement de capacité.
Alors, il est à noter que la plupart des microcontrôleurs sont capables
de faire du calcul sur ces nombres négatifs, sans qu'on leur
dise rien de spécial, le problème c'est que par exemple le langage C n'est
pas capable de signaler ces dépassements de capacité.
Le processeur qui est à l'intérieur du microcontrôleur sait le faire,
mais le C ne donne pas, en quelques sortes, cet accès.
Donc, ces nombres négatifs, très souvent, on les utilise en 8 bits, en 16 bits ou en
32 bits, avec 4 bits ils vont seulement de zéro à 15, donc de moins 8 à plus 7,
heu, on va de zéro à 255 pour 8 bits, avec des nombres négatifs
ici, la même chose pour 16 bits, la même chose pour 32 bits, à noter que même en
nombres positifs et négatifs, vous voyez que pour
32 bits on arrive déjà à des nombres
extrêmement importants, et ces nombres de 32 bits
peuvent être tout à fait manipulés par des microcontrôleurs.
Les noms qu'on donne à ces nombres
de taille limitée, alors le byte et l'octet c'est effectivement
des noms connus et bien standardisés, byte à l'anglaise, octet est
bien souvent utilisé en français, pour les autres valeurs, il
existe des standardisations, mais qui ne sont malheureusement pas du tout
suivies, on voit souvent le terme de nibble pour des
mots de 4 bits, mais pour les mots de16 bits et
de 32 bits, je n'ai même pas osé mettre une
valeur parce que c'est relativement incohérent, et en particulier les langages
de programmation ne sont pas toujours très clairs à ce sujet, il faudra être
extrêmement prudent avec le langage C à
propos des types correspondants à ces valeurs arithmétiques.
L'écriture de nombres en binaire est fastidieuse.
C'est trop long.
Si vous avez des mots de16 bits, c'est difficile
de reconnaître les 1 et les zéros là, au milieu.
La conversion en décimal est aussi
quelque chose de relativement compliqué. C'est la
raison pour laquelle on utilise très souvent une notation en
hexadécimal simplement pour exprimer des nombres binaires
plus faciles à écrire. Quelle va être la méthode?
Et bien on va simplement ici regrouper par morceaux de 4 bits et ensuite donner un
code pour chacun de ces morceaux de 4 bits.
Voilà le code qui est à disposition.
Zéro, 1, 2, 3, 4, 5, 6, 7,
8, 9, évidemment, comme le système décimal, comme
il a fallu rajouter des caractères, et bien
ici on a rajouté les premières lettres de l'alphabet.
Alors ces nombres hexadécimaux, on les reconnaît facilement, parce qu'ils
ont souvent, non seulement des chiffres, mais également, les premières lettres
de l'alphabet, et, je rappelle, il faut couper
le nombre binaire en tranches de 4 bits, bien
entendu depuis la droite, et ensuite bien sûr coder
chaque groupe avec ces chiffres de zéro à F.
Un autre système qui n'a strictement rien à voir
mais que parfois les gens confondent, c'est le système BCD.
Alors le système BCD il n'est plus beaucoup utilisé, mais il est
encore parfois utilisé, par exemple pour les circuits horloges.
Il s'agit bien dans ce cas-là de nombres décimaux, il faut s'en souvenir.
Chaque chiffre décimal est codé sur 4 bits.
Par exmple, un mode 16 bits peut coder des nombres BCD de zéro jusqu'à
seulement 9'999. Prenons un exemple.
Voilà une valeur horaire,
21h35 codée en BCD 2, 1,
codés chaque fois sur 4 bits, 3, 5, de la même
manière, mais il ne s'agit pas d'hexadécimal,
et il faut bien comprendre que le passage du binaire au BCD
nécessite de nombreuses opérations, que c'est
cette fameuse conversion du binaire au décimal,
et c'est encore plus compliqué pour passer du décimal au binaire.
Terminons ce chapitre par parler du codage des caractères, on a certainement
entendu parler du code ASCII, qui
est effectivement extrêmement ancien, il date de
1963, il était codé à l'époque sur 7 bits, ce qui ne nous
arrange pas du tout, et ce qui est dramatique pour nous autres, francophones,
c'est qu'il ne contient pas de lettres accentuées.
Voilà ce code tel qu'il est, tel qu'il a été standardisé, prenons
par exemple la lettre T pour regarder comment est-ce qu'on la code,
ici sur la ligne on a la valeur 4, donc ça signifie
qu'on aura la valeur zéro, 1, zéro,
zéro pour les bits de poids faibles, et là ici j'ai la valeur 5 qui va coder les
bits de poids forts, 1, zéro, 1, donc ici la lettre T correspond
bien à cette valeur binaire 1010100, donc un mot de 7 bits.
Il est à noter qu'il existe
beaucoup d'extensions du code ASCII qui malheureusement
ne sont pas compatibles les unes avec les autres, et c'est
une jungle relativement compliquée, même
sur internet plusieurs codes cohabitent, on
utilise assez souvent un code qui s'appelle l'UTF et en particulier sa
version 8 bits UTF-8, mais d'autres codes sont également utilisés.
En ce qui concerne les microcontrôleurs, disons qu'on n'a pas
très souvent besoin de lettres accentuées, et qu'on peut assez
bien s'en sortir avec le système ASCII traditionnel.
Donc je vous rappelle que dans ce chapitre, nous avons parlé de
numération binaire, nous avons parlé de nombres binaires de taille limitée, nous
avons parlé du codage des nombres négatifs, et nous avons également abordé
la question de l'hexadécimal, du BCD et également du codage des caractères.
Explorer notre catalogue
Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.
Coursera propose un accès universel à la meilleure formation au monde,
en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.
© 2018 Coursera Inc. Tous droits réservés.
