Z-i-G-Z-a-G

Convertisseur binaire vers décimal [1/2] — Arduino


Vous êtes dans la Section 17, ici vous pourrez suivre des tutoriels sur des logiciels de création ou sur des « bidouilles » électroniques. Cette section est plutôt destinée aux bidouilleurs curieux, qui ont quelques notions en programmation, qui aiment découvrir et tester, comme moi, des logiciels et/ou des programmes informatiques.

Pour ce premier tutoriel, je vous propose de créer un convertisseur de langage binaire vers du décimal, à l’aide de commutateurs (pour le binaire) et d’un afficheur digital (pour l’affichage de la conversion en décimal). Pour un récent projet, j’ai dû me pencher sur le sujet et je n’ai trouvé aucun tutoriel sur le web qui combinait ces deux caractéristiques. Je vous partage donc la solution que j’ai fini par obtenir.

Le principe est simple, avec 8 commutateurs à deux états : ouvert (0) et fermé (1), il est possible de créer 256 combinaisons possible allant de 00000000 à 11111111 (256 étant la valeur maximale contenue dans 1 octet (en réalité 255, plus le 0, 256 valeurs), l’équivalent de 8-bits, d’où nos 8 commutateurs. Ces suites de 1 et de 0 sont converties en valeurs décimales grâce à un programme et peuvent être lues sur 3 afficheurs digital 7-segments, un pour les centaines, un pour les dizaines et le dernier pour les unités. Les commutateur eux, enverront des informations aux broches d’entrée d’une carte Arduino (j’ai choisi le modèle d’entrée de gamme, l’Arduino Uno, qui suffit amplement), qui convertira ces informations avec le programme que je vais vous proposer puis enverra du courant sur les broches de sortis qui alimenteront successivement les segments nécessaires.

Pour cette semaine je vous propose de nous concentrer sur l’afficheur décimal en créant un simple compteur, nous verrons comment ajouter les commutateurs dans prochain post. Commençons alors par le branchement des 3 afficheurs, je ne vous expliquerais pas ici comment fonctionne une carte Arduino ou pourquoi j’ai choisi tel ou tel composant, libre à vous d’améliorer et d’adapter selon vos envies. Je vous avais prévenu il faut avoir quelques notions et il existe de nombreux sujets sur la toile ou vous pourrez trouver réponses à vos questions (je peux toutefois tenter d’y répondre via les commentaires si vous éprouvez des difficultés).

7-segments

Je branche donc mes afficheurs sur une plaque d’essai et je relie en parallèle chacune des 7 broches de mes 3 composants (les broches A ensembles, les broches B et ainsi de suite… voir le schéma ci-dessous), j’amène les 7 fils vers des résistances (220Ω) puis je ressors pour les relier aux sorties digitales des broches 3 à 9 de ma carte Arduino. Les broches 0 à 2 quant à elles, sont reliées à 3 résistance (1kΩ) puis aux broches de commande (celle du milieu, la base) des transistors bipolaires (NPN). Les broches de droite (la broche de sortie, l’émetteur) sont reliées à la masse de chaque afficheur et les broches de gauche (broche d’entrée, collecteur) au 5v de la carte Arduino.

7-segments

Voilà pour les branchements, passons maintenant à la partie plus complexe, la programmation. Dans le logiciel Arduino je commence par attribuer les différentes broches de ma carte à l’aide de la fonction #define comme ceci, suivant le circuit intégré du boitier de l’afficheur:

#define A 4
#define B 3
#define C 7
#define D 8
#define E 9
#define F 5
#define G 6

Et la même chose pour les broches 0 à 2 :

#define COM1 0
#define COM2 1
#define COM3 2

Ensuite je rassemble mes différents segments dans un tableau que je nomme segs, en respectant l’ordre des 7 segments, A B C D E F G. Puis un deuxième de type « byte » (binaire), pour alimenter ou non (avec les valeurs 0 ou 1) chaque segment de mon afficheur afin de former nos 10 chiffres. Noter qu’il suffit d’inverser les 0 ou les 1, si votre afficheur est à cathode commune ou à anode commune.

const int segs[7] = {4, 3, 7, 8, 9, 5, 6};

const byte chiffres[10] = { 
  0b1000000, // 0
  0b1111001, // 1
  0b0100100, // 2
  0b0110000, // 3
  0b0011001, // 4
  0b0010010, // 5
  0b0000010, // 6
  0b1111000, // 7
  0b0000000, // 8
  0b0010000  // 9
};

Dans le setup(), j’indique simplement avec l’appellation pinMode que mes différents connecteurs sont des sorties (OUTPUT). comme ceci:

void setup() {
  pinMode(A, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(C, OUTPUT);
  pinMode(D, OUTPUT);
  pinMode(E, OUTPUT);
  pinMode(F, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(COM1, OUTPUT);
  pinMode(COM2, OUTPUT);
  pinMode(COM3, OUTPUT);
}

Voyons maintenant ce que nous allons mettre dans notre loop(). Je commence par créer trois boucles les une dans les autres à l’aide de for(), pour attribuer un compteur croissant allant de 0 à 9 (<10) sur chaque afficheur. J’ajoute ensuite une quatrième boucle qui se servira de la fonction millis() pour incrémenter notre startTime et qui aura pour effet d’initialiser un compteur partant de 0 à 999 (la valeur maximale possible avec trois afficheurs). Je termine par ajouter dans cette dernière boucle trois déclarations qui contiennent notre tableau chiffre[] avec les différents compteurs: centaine, dizaine et unité. Après chaque déclaration je met en pause la boucle avec delay(). Le but de l’opération et d’allumer qu’un seul afficheur sur les trois en permanence, j’allume chaque afficheur l’un après l’autre mais de façon très rapide (ce qui à pour effet de les faire clignoter), et grâce à la persistance rétinienne, les trois afficheurs donnent l’impression d’être alimentés simultanément (ce principe est très utile car sans lui, il nous aurait fallu pas loin du triple de broches sur notre carte Arduino pour alimenter indépendamment tous les segments de nos trois afficheurs). Voici la méthode:

void loop() {  
  for(int centaine=0; centaine < 10; centaine++) {
    for(int dizaine=0; dizaine < 10; dizaine++) {
      for(int unite=0; unite < 10; unite++) {
        unsigned long startTime = millis();
        for(unsigned long compteur=0; compteur < 1000; compteur = millis()-startTime) {
          chiffreLux1(chiffres[centaine]);
          delay(5);
          chiffreLux2(chiffres[dizaine]);
          delay(5);
          chiffreLux3(chiffres[unite]);
          delay(5);
        }
      }
    }
  } 
}

Créons tout de suite les trois déclarations appelées précédemment, elles permettent d'alimenter notre chiffre sur le premier afficheur (COM1) avec digitalWrite() avec une valeur de 5 volts (HIGH) et rien sur les deux autres (LOW). Je fais la même chose avec les deux autres afficheurs en prenant soin d'alimenter celui concerné.

void chiffreLux1(byte chiffre) {
  digitalWrite(COM1, LOW);
  digitalWrite(COM2, LOW);
  digitalWrite(COM3, HIGH);
  segmentsLux(chiffre);
}

void chiffreLux2(byte chiffre) {
  digitalWrite(COM1, LOW);
  digitalWrite(COM2, HIGH);
  digitalWrite(COM3, LOW);
  segmentsLux(chiffre);
}

void chiffreLux3(byte chiffre) {
  digitalWrite(COM1, HIGH);
  digitalWrite(COM2, LOW);
  digitalWrite(COM3, LOW);
  segmentsLux(chiffre);
}

Pour terminer, il ne reste plus qu'à définir la déclaration segmentsLux(), en lisant dans une boucle la valeur binaire de i pour l'inscrire dans le tableau segs[] comme suit:

void segmentsLux(byte chiffre) {
  for(int i = 0; i < 7; i++) {
    int bit = bitRead(chiffre, i);
    digitalWrite(segs[i], bit);
  }
}

Voilà c'est terminé vous pouvez vérifier votre code et le téléverser sur votre carte Arduino afin de vérifier si tout fonctionne parfaitement. Je croise les doigts.
Nous verrons la prochaine fois comment ajouter les commutateurs et faire correspondre notre afficheur décimale au code binaire défini par ceux-ci.

NOTE: Une grande partie de ce code n'est pas de moi, on le trouve très facilement sur de nombreux sites traitant du sujet, cependant il est disponible pour seulement 2 afficheurs 7 segments (pour afficher des nombres de 0 à 99). Je l'ai donc adapté à mon besoin, c'est à dire pour 3 afficheurs. Surtout soyez indulgent, vous avez lu mon tout premier tutoriel et je ne connais pas la qualité de la compréhension de mes explications, vos critiques seront surement constructives et je tenterais de les appliquer.

Suite : Convertisseur binaire vers décimal [2/2] — Arduino

Share Button

Rubrique: Section 17 | 4 Commentaires




4 Commentaires

  1. NOTE: Il peux arriver que dans certain cas, la constante F amène un message d’erreur (j’ignore la raison), remplacez alors la ligne #define F 5 par const int F = 5; qui veut dire strictement la même chose 😉

  2. Bonjour,
    Super montage très bien détaillé et expliqué !
    Je m’amuse à modifier les valeurs pour apprendre la programmation,
    on peux modifier la vitesse du compteur, la luminosité des afficheurs (22 mm pour mon montage), on peut décompter, limiter le comptage à une valeur précise, le faire compter en binaire, de 2 en 2 etc, tout cela juste en modifiant des lignes !!!
    Dans les années 80 il fallait des heures de travail pour un tel résultat et encore… Je cherche à réaliser un compteur de vitesse pour ma Mini Austin, il me faut un comptage avec affichage et RAZ toute les secondes. Encore bravo !!!

  3. Bonjour Régis, merci pour ce commentaire agréable.
    Je suis trop jeune pour avoir connu les années 80 mais j’imagine que cela devait être beaucoup plus laborieux en effet pour réaliser ces choses.

  4. Bonjour
    Je vous dis la même chose super montage et explication détaillée. Mais j ai remarqué que ce programme fais le comptage de 0 a 999
    Peux tu m envoyer la suite de ce travail (2/2) je veux la conversion du binaire vers le décimal sur 3 afficheur 7 segments et merci

Laissez un commentaire