Tutoriel éclair sur les nombres binaires et hexadécimaux

Le binaire

D’où vient il ?

Les processeurs et microcontrôleurs qui nous entourent utilisent entre plusieurs centaines et plusieurs milliers de milliards de transistors. Un transistor et un composant à 3 broches (collecteur, base et émetteur), qui se contente de retenir le courant entre le collecteur et l’émetteur, tant que la base n’atteint pas un seuil de tension caractéristique. Cela a permis de développer des portes logiques, qui assemblées entre-elles, constituent les unités principales de calcul des processeurs.

Le concept même du transistor impose donc l’utilisation d’opération sur un ensemble binaire ; le courant passe ou ne passe pas, la valeur est 1 ou 0. Cela conduit donc à définir au sein des processeurs, des ensembles de uns et de zéros. Un chiffre binaire (0 ou 1) est appelé un bit.

Comment le lire ?

Un nombre binaire va se lire comme un nombre décimal, le chiffre le plus à gauche est le plus important. Pour retrouver la valeur décimal d’un nombre binaire de forme  \displaystyle a_{n} \cdots a_{2} a_{1} a_{0} où chaque  \displaystyle a_{i} est un bit, il faut appliquer la formule suivante :

 \displaystyle \sum_{i=0}^{n} a_{i} \times 2^{i}

Par exemple, le nombre 11000101 va se convertir en décimal ainsi : 1\times 2^{7}+ 1\times 2^{6}+ 0\times 2^{5}+ 0\times 2^{4}+ 0\times 2^{3}+ 1\times 2^{2}+ 0\times 2^{1}+ 1\times 2^{0}
Soit :
 128+64+4+1 = 197

Rassurez-vous il est très rare que l’on ait besoin de convertir un nombre binaire en décimal et vice versa. Par contre la conversion entre binaire et hexadécimal est une pratique courante.

L’hexadécimal

Pourquoi utiliser l’hexadécimal ?

Les suites de 0 et de 1 que forment les bits d’un nombre binaire n’est pas du tout pratique pour un œil humain habitué à un système décimal. De la même façon, les nombres décimaux ne sont pas manipulables sous cette forme par des processeurs qui ne sont capables d’identifier que deux états.

La meilleure alternative est donc d’utiliser une base, dont le nombre de chiffres est une puissance de deux. On a d’abord pensé à utilisé l’octal (en base 8, les chiffres de 0 à 7), mais cette base n’utilise 3 bits, ce qui implique d’être en décalage permanent avec la base 2 ; par exemple 3 chiffres octaux représentent 9 bits, ce qui dépasse d’un bit pour un système 8 bits, et gaspille de la mémoire.

Le choix s’est donc fixé sur l’écriture en base 16, l’hexadécimal, qui en plus d’être relativement proche de 10, permet de lire les bits par groupe de 4 de façon commode.

Comment l’écrire ?

Un quartet, appelé aussi nibble en anglais, est un ensemble de 4 bits que l’on peut écrire avec un seul chiffre hexadécimal. Voici les 16 formes possibles d’un quartet :

Les 16 chiffres hexadécimaux
Binaire Hexadécimal
0000 0
0001 1
0010 2
0011 3
0100 4
0101 5
0110 6
0111 7
1000 8
1001 9
1010 A
1011 B
1100 C
1101 D
1110 E
1111 F

Quel est le bénéfice dans notre cas ?

Ainsi, 8 bits peuvent se lire sur deux chiffres hexadécimaux, ce qui est un confort indiscutable comparé aux écritures décimale et octale. Il suffit par exemple d’écrire [cci]FF[/cci] pour s’assurer que tous les bits d’un registre passe à un.

Dans mon code, comment différencier le binaire, le décimal, l’octal et l’hexadécimal ?

Il existe des conventions pour chaque langage. Puisqu’ici on va utiliser principalement du C, voici les conventions :

  • Un nombre binaire commence par [cci]0b[/cci] et est suivi des bits (0 ou 1). Vu que l’on travaille avec une architecture au moins égale à 8 bits, il est conseillé de faire des paquets de 8 bits. Cela facilite la lecture.
  • Un nombre décimal s’écrit de façon naturelle, mais ne doit pas commencer par 0.
  • Un nombre octal doit s’écrire avec un [cci]0[/cci] devant. Vu que cette écriture est peu utilisée, nous n’en parlerons plus dans la suite des tutoriels.
  • Un nombre hexadécimal est précédé de [cci]0x[/cci]. Comme pour les nombres binaires, il est plus naturel d’écrire ces nombres par paquet de deux chiffres.
Binaire Décimal Octal Hexadécimal
[cci]0b11000101[/cci] [cci]197[/cci] [cci]0305[/cci] [cci]0xC5[/cci]
[cci]0b00001101[/cci] [cci]13[/cci] [cci]015[/cci] [cci]0x0D[/cci]
[cci]0b11111111[/cci] [cci]255[/cci] [cci]0377[/cci] [cci]0xFF[/cci]

AVR – Chapitre 0 – Découverte de l’ATtiny et amorce du tutoriel

Pour la petite histoire…

Depuis quelque mois maintenant, je m’intéresse au monde des microcontrôleurs et à leurs applications pratiques. J’ai commencé par Arduino (le plus médiatique) pour ensuite m’intéresser au MSP430 de Texas Instruments.

Ça à l’air cool !

J’ai fini par me rendre compte que j’avais ici des plate-formes très intéressantes, mais qui ne m’encourageaient pas réellement à me plonger dans les détails. Je me résignais donc à utiliser des librairies écrites pas plus érudits, à copier/coller des morceaux de code que je ne comprenais pas entièrement, et même si les résultats obtenus étaient ceux attendus, je buttais parfois sur la situation du «cas particulier».

L’enfer du «cas particulier»

Celui sur lequel on ne trouve aucun sujet, aucune aide. Celui sur lequel on planche pendant des heures, et des soirées entières, avant d’abandonner lâchement, car «je ne sais plus comment faire» malgré toute la documentation que j’ai épluchée ; malgré tous ces forums en anglais, en allemand, en espagnol, en chinois, en russe (Merci à Google Translate) que j’ai écumés.

Notez que j’ai pour habitude de ne jamais poser de questions sur les forums. Les sujets finissent souvent par dériver, et par être pollués par des débats d’experts, des questions stupides ou opportunes.

De plus, j’ai peur de poser des questions simplettes, de recevoir des réponses d’abord inquisitrices puis pointues et enfin condescendantes (pour quoi faire ? — t’as juste à faire ça <insérer un bloc de code sans commentaire>. — Apprend les bases et on reparlera.). Je suis trop curieux pour le niveau de base, mais pas assez expérimenté pour le niveau supérieur.

Rarement, j’y trouve une solution qui me convient, et quand j’en trouve une, elle est désuète, hors-sujet ou non-documentée. Ou tout simplement, elle ne fonctionne pas pour mon «cas particulier».

Et puis un jour…

J’ai donc fait une pause, en tout cas sur les arcanes des microcontrôleur, pour attaquer un projet basé sur Arduino, que je n’ai pas encore publié.  Et totalement par hasard, souhaitant ajouter des composants à ce projet, en passant une commande, je suis tombé sur une bestiole qui m’a attendri ; l’ATtiny85.

8 pattes, 8bit, 5 entrées-sorties à un prix minuscule (l’euro symbolique). En butinant un petit peu, je crois comprendre qu’il s’agit, pour schématiser, d’un Arduino épuré ; pas d’amorçage, pas de connexion série, mémoires de taille réduite,… Largement suffisant selon moi pour les projets de base (jeux de lumières, capteurs, …).

Pour la partie programmation, il y a une longue liste d’articles dans toutes les langues, qui vous présentent comment, avec un simple Arduino, quelques câbles et un condensateur, on peut flasher ses ATtiny avec du code Arduino.

Hop ! Dans le panier et c’est commandé !

Coucou, toi !

Quelques jours après, je reçois 10 microcontrôleurs. Je dédie donc un de mes Arduino (Duemlianove) au rôle de programmateur AVR (sans savoir ce que celà signifie). Je configure mon IDE, je programme, je branche, je reprogramme, et voilà ; au bout de vingt minutes d’installation, ma diode clignote : mon premier Hello world sur ATtiny fonctionne.

Je note toutefois que la notion de « delay » n’est pas la même que pour l’Arduino, je bidouille un peu, et c’est bon. Je continue mes bricolages ; je teste une diode RGB, un bouton, un buzzer, … je redécouvre l’Arduino, mais sur ATtiny.

Motivé par ces petites bêtes, je m’intéresse alors à la communication. Et ici, la dichotomie entre le code Arduino joli-mais-ça-ne-marche-pas et le code C bas niveau puissant-mais-illisible refait son apparition. Mais cette fois, je ne vais pas m’arrêter.

RTFM

Première idée ; lire la documentation. 234 pages, je passe mon tour pour cette fois. Alors je cherche… d’abord ATtiny85, ensuite ATtiny et enfin, je comprend ce qu’AVR signifie : l’architecture. Et là tout s’éclaire. Je me remémore mes cours de fac, à propos des jeux d’instructions, des registres, …

Après plusieurs jours de recherches sur le sujet, je me suis aperçu d’une chose. Une fois sorti des sentiers battus par Arduino et sa communauté, les tutoriels pour programmer un microcontrôleur AVR avec du code C sont rares, et d’autant plus si on s’évertue à les chercher en français (je me débrouille très bien en anglais, mais c’est parfois plus pratique quand on parle la même langue que l’auteur).

Alors c’est parti, je commence le mien !

ATtiny85 : un microcontrôleur parfait pour débuter avec AVR

Il s’agit d’un microcontrôleur 8-bit, sorti en 2005 et fabriqué par Atmel proposant un jeu d’instructions réduits (RISC), 8192 octets de mémoire Flash, 512 octets de RAM, et autant d’EEPROM. Son unité de calcul tourne de 1 à 20 MHz. Il est possible d’utiliser jusqu’à 6 entrées-sorties numériques, 2 sorties analogiques, 2 horloges 8-bit, 4 entrées analogiques 10-bit. Pour plus de détails, je vous renvoie à la documentation sur le site d’Atmel.

Plusieurs broches (ou pin) cumulant certaines fonctionnalités, il ne sera pas possible de tout utiliser en même temps.

L’ATtiny85 fonctionne avec une tension continue de 2,7 à 5,5 volts. Deux piles LR6/AA peuvent donc suffire pour l’alimenter. Pour ce tutoriel, je vous conseille l’utilisation d’un des ports USB de votre ordinateur.

Prérequis

Comme pour tous les tutoriels, il est important de fixer quelques prérequis ; rien de bien méchant mais il est important de :

Il y a déjà des tas d’articles à ce sujet sur Internet, mais j’en ferai sûrement quelques-uns ici à terme.

Pour le matériel je vous conseille d’avoir à porter de main :

  • des ATtiny85 : sans blague ?
  • des résistances de différentes valeurs ; il existe des boîtes regroupant une quinzaine de valeurs avec 10 à 20 unités par référence. C’est très bien pour débuter.
  • des condensateurs ; en avoir quelques un de plusieurs références peut être utile. Je vous conseille toutefois d’en récupérer quelques-uns de 10 uF (micro-farad), pour fabriquer votre programmateur AVR pour Arduino.
  • des plaques de prototypage sans soudure (et des câbles) ; ça coute entre 5 et 10€ et ça vous permet de faire des prototypes très rapidement, sans rien souder. Prenez en plusieurs, cela vous évitera de tout démonter entre chaque montage.
  • des diodes lumineuses, cela permet de réaliser des schémas de base, et de vérifier qu’ils fonctionnent.
  • un Arduino ; qui vous servira de programmateur. Il n’y a pas besoin d’un modèle en particulier.

Objectifs

Ce tutoriel va vous permettre de faire l’inverse de l’Arduino ; aller du plus bas niveau, jusqu’au plus haut.

Pour éviter de papillonner je vais rapidement vous décrire les objectifs de ce tutoriel.

  1. Faire clignoter une LED
  2. Comprendre les registres et accéder aux broches
  3. Utiliser les compteurs
  4. Fabriquer des valeurs analogiques
  5. Lire et écrire les mémoires

 Avertissement

Bien entendu, comme je vous l’ai expliqué avant dans ma litanie ; je ne suis pas un expert de ces microcontrôleurs, je découvre même parfois en même temps que j’écris ces lignes… Alors je souhaite vous demander votre attention quant au contenu de ces articles. Je n’y prétend pas tout connaître sur l’architecture AVR et il m’arrivera surement de me tromper.

Ces tutoriels reflètent mon expérience, et ce qui a marché pour moi marchera très probablement pour vous. Si jamais ce n’est pas le cas, où si jamais je me suis trompé, je vous invite à me le signaler en commentaire ou en privé.

De plus, et vous le comprendrez surement, je ne peux pas être tenu responsable en cas de défaillance de vos réalisations, même si celles-ci endommagent vos biens ou ceux d’un tiers, ou pire encore blesse quelqu’un. De mon point de vue, l’électronique s’apprend par l’expérience, et il arrivera à tout le monde d’endommager des composants lors de ses réalisations.

 

Présentation du Launchpad MSP430

Le MSP430 est un micro-contrôleur conçu par Texas Instruments. Très économe en énergie, très accessible, il est idéal pour commencer sérieusement en programmation électronique. Par sérieusement, j’entend s’approcher un peu plus du bas niveau.

En effet, les micro-contrôleurs MSP430 ne sont pas «assistés» comme le sont les Arduino ; il faut se sentir à l’aise avec le C et ses particularités ; essentiellement les types primitifs, les pointeurs et les opérations binaires.

Voici un exemple qui montre la différence notable entre Arduino et MSP430 : le Hello World de l’électronique : faire clignoter une diode.

Code pour arduino :

[cce lang= »c »]
int led = 13; //On déclare une variable contenant le numéro de pin que l’on utilise

void setup() {
pinMode(led, OUTPUT);//on initialise le pin en sortie
}

void loop() {
digitalWrite(led, HIGH);   // on allume la diode
delay(1000);               // on attend une seconde
digitalWrite(led, LOW);    // on éteint la diode
delay(1000);               // on attend une seconde
}[/cce]

Et maintenant en code MSP430 (ici pour un MSP430G2553).

[cce lang= »c »]#include <msp430g2553.h>

unsigned int i = 0; //On déclare une variable pour itérer plus tard

void main(void){
WDTCTL = WDTPW + WDTHOLD; // On coupe le watchdog
P1DIR |= 0x01; // On déclare le pin 0 du port 1 en sortie
for (;;){
P1OUT ^= 0x01; //On bascule la valeur binaire du pin 0 du port 1 en sortie
for(i=0; i< 20000; i++); // On attend 20000 cycles pour simuler une attente
}
}[/cce]

La différence est assez nette ; le code MSP430 est plus concis, mais nécessite de sérieuses bases en C et en programmation de micro-contrôleur.