Le compteur binaire est un concept très utile pour compter des choses. Il est très pratique pour compter des choses qui sont en grand nombre et qui sont difficiles à compter à la main. Dans ce tutoriel, nous allons apprendre à construire un compteur binaire à l’aide de 8 LEDs. Nous allons voir comment connecter les LEDs et comment les programmer pour qu’elles fonctionnent correctement. Nous verrons également comment utiliser le compteur binaire pour compter des choses. Enfin, nous verrons comment le compteur binaire peut être utilisé pour résoudre des problèmes mathématiques.
8 LEDs en Compteur binaire
1. Présentation
Ce programme réalise un affichage en compteur binaire sur 8 LEDs. Chaque LED visualise directement l’état d’un bit de l’octet utilisé pour le comptage. Ce programme est à visée purement didactique afin de comprendre ce qui se passe à l’intérieur d’un octet du microcontrôleur lorsque l’on réalise un comptage.
2. Note théorique
Un octet est un ensemble de 8 « cases » mémoire pouvant chacune contenir 0 ou 1. Chaque case est appelée un bit. Dans un octet, il y a un bit de poids fort et un bit de poids faible.
| bit 7 | bit 6 | bit 5 | bit 4 | bit 3 | bit 2 | bit 1 | bit 0 |
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
A l’aide d’un octet, on peut compter de 0 (tous les bits à 0 soit 00000000) à 255 (tous les bits à 1 soit 11111111). Voici le comptage binaire pour les nombres de 0 à 15 :
| Décimal | Binaire |
| 0 | 0000 |
| 1 | 0001 |
| 2 | 0010 |
| 3 | 0011 |
| 4 | 0100 |
| 5 | 0101 |
| 6 | 0110 |
| 7 | 0111 |
| 8 | 1000 |
| 9 | 1001 |
| 10 | 1010 |
| 11 | 1011 |
| 12 | 1100 |
| 13 | 1101 |
| 14 | 1110 |
| 15 | 1111 |
| .. | .. |
| 255 | 11111111 |
| 256 | 00000000 |
- Noter que le comptage binaire correspond en fait à une division de fréquence par 2 d’un bit à l’autre (autrement le bit de poids faible « clignote » 1/2, le bit de poids 1 clignote 1/4, etc…
- Remarquer que si on ajoute 1 à une variable dont tous les bits sont à 1, elle passe à 0 (ceci donne des effets aberrants dans un programme si vous essayez de compter avec une variable trop « petite » pour la valeur que vous voulez mettre dedans.
- Dans le langage Arduino, on peut utiliser les notations binaire, décimale ou hexadécimales. Pour plus de détails, voir : Les valeurs numériques entières
- Concernant les différents types de variables disponibles dans le langage Arduino, voir : Synthèse des types de données du langage Arduino
3. Matériel Nécessaire
3.1 L’espace de développement Arduino
- … pour éditer, compiler le programme et programmer la carte Arduino.
3.2 Le matériel suivant pour réaliser le montage associé
- une plaque d’essai pour montage sans soudures,
- des straps,
- 8 LEDs rouge 5mm,
- 8 résistances 1/4w de 270 Ohms,
4. Instructions de montage
- Connecter sur la broche 4 (configurée en sortie) une LED et sa résistance 270 en série connectée au 0V
- Connecter sur la broche 5 (configurée en sortie) une LED et sa résistance 270 en série connectée au 0V
- Connecter sur la broche 6 (configurée en sortie) une LED et sa résistance 270 en série connectée au 0V
- Connecter sur la broche 7 (configurée en sortie) une LED et sa résistance 270 en série connectée au 0V
- Connecter sur la broche 8 (configurée en sortie) une LED et sa résistance 270 en série connectée au 0V
- Connecter sur la broche 9 (configurée en sortie) une LED et sa résistance 270 en série connectée au 0V
- Connecter sur la broche 10 (configurée en sortie) une LED et sa résistance 270 en série connectée au 0V
- Connecter sur la broche 11 (configurée en sortie) une LED et sa résistance 270 en série connectée au 0V
5. Le schéma théorique du montage
Le schéma théorique du montage
6. Le circuit du montage
Le schéma du montage à réaliser
7. Explication du programme
7.1 Structure globale du programme
Ce programme simple comprend :
- une entête déclarative
- une partie « configuration » qui ne sera exécutée qu’une fois (fonction setup( ) )
- une partie constituée d’une boucle sans fin que le programme répètera à l’infini ( fonction loop( ) ) : c’est le coeur du programme.
7.2 Déroulement du programme
Le programme se déroule de la façon suivante :
- Après avoir pris en compte les instructions de la partie déclarative,
- puis après avoir exécuté la partie configuration ( fonction setup( ) ),
- le programme bouclera sans fin ( fonction loop ( ) ), exécutant de façon répétée le code compris dans la boucle sans fin.
Le déroulement du programme
8. Au niveau de la partie déclarative :
Déclaration des constantes de broches
- Déclaration des constantes pour les broches utilisées dans le programme : on déclare ici un tableau de constantes dont chaque valeur correspond aux broches utilisées.
Il est pratique d’utiliser un tableau dès lors que l’on va utiliser une action répétée sur plusieurs broches. Chaque broche sera ainsi accessible à l’aide de l’index du tableau, avec l’index 0 pour la première valeur. Un truc de programmation qui vous fera écrire des programmes propres.
// la broche 4 correspond au bit de poids faible (index 0 du tableau)
// la broche 11 correspond au bit de poids fort (index 8 du tableau)
Déclaration des variables globales
- Déclaration des variables globales du programmes : on déclare une variable pour le comptage.
Déclarations des objets utiles pour les fonctionnalités utilisées
- Déclaration des objets utiles pour les fonctionnalités utilisées :
9. Au niveau de la fonction d’initialisation setup( ) :
configuration des broches utilisées :
- Configuration des broches en sortie : on met les 8 broches en sortie à l’aide d’une boucle for :
for (int i=0; i<=7; i++) { // boucle de défilement des 8 broches
pinMode(LED[i], OUTPUT); //met la broche en sortie
}
10. Au niveau de la boucle principale, la fonction loop ( ) :
- Au sein d’une boucle, on passe en revue les 8 bits de la variable de comptage à l’aide de l’instruction bitRead et on met la broche correspondante dans le même état à l’aide de l’instruction digitalWrite
// met la broche LED[i] dans l’état du bit de rang i de la variable compteur
digitalWrite(LED[i],bitRead(compteur,i));
}
- On incrémente la variable de comptage, que l’on remet à 0 lorsqu’elle vaut 256. En effet, on utilise ici une variable de comptage de type int et pour éviter des comportements inattendus, il est préférable de la remettre à 0 (en fait çà n’est même pas obligatoire… si vous réfléchissez un petit peu… mais passons… )
- Une instruction delay vient assurer un pause entre chaque incrémentation.
if (compteur>=256) compteur=0; // RAZ variable compteur 255 ==> 0
delay (250); // pause fixant la vitesse du comptage
- Le programme recommence en boucle les instructions de la fonction loop( ).
Se reporter aux commentaires présents dans le programme pour plus de détails.
11. Mise en oeuvre du programme
11.1 Préparation du montage et programmation de la carte Arduino :
- Commencer par réaliser le montage indiqué sur plaque d’expérimentation
- Ensuite, programmer la carte Arduino avec ce programme (en bas de page) selon la procédure habituelle
11.2 Fonctionnement
- Les LEDs affichent un comptage binaire du 8 bits de 0 à 255 (soit de 00000000 à 11111111).
12. Le programme complet en langage Arduino :
A copier/coller directement dans l’éditeur Arduino
// Copyright X. HINAULT – Créé le 05/05/2010
// www.mon-club-elec.fr
// Code sous licence GNU GPL :
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// — Que fait ce programme ? —
/* 8 LEDs en compteur binaire. */
// — Fonctionnalités utilisées —
// — Circuit à réaliser —
// Connecter sur la broche 4 (configurée en sortie) une LED et sa résistance 270 Ohms en série connectée au 0V
// Connecter sur la broche 5 (configurée en sortie) une LED et sa résistance 270 Ohms en série connectée au 0V
// Connecter sur la broche 6 (configurée en sortie) une LED et sa résistance 270 Ohms en série connectée au 0V
// Connecter sur la broche 7 (configurée en sortie) une LED et sa résistance 270 Ohms en série connectée au 0V
// Connecter sur la broche 8 (configurée en sortie) une LED et sa résistance 270 Ohms en série connectée au 0V
// Connecter sur la broche 9 (configurée en sortie) une LED et sa résistance 270 Ohms en série connectée au 0V
// Connecter sur la broche 10 (configurée en sortie) une LED et sa résistance 270 Ohms en série connectée au 0V
// Connecter sur la broche 11 (configurée en sortie) une LED et sa résistance 270 Ohms en série connectée au 0V
//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables…
// — Inclusion des librairies utilisées —
// — Déclaration des constantes —
// — constantes des broches —
const int LED[8]={4,5,6,7,8,9,10,11}; // déclare un tableau de 8 constantes de broches
// la broche 4 correspond au bit de poids faible (index 0 du tableau)
// la broche 11 correspond au bit de poids fort (index 8 du tableau)
// — Déclaration des variables globales —
int compteur=0; //variable de comptage
// — Déclaration des objets utiles pour les fonctionnalités utilisées —
//**************** FONCTION SETUP = Code d’initialisation *****
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme
void setup() { // debut de la fonction setup()
// — ici instructions à exécuter au démarrage —
// ——- Broches en sortie ——-
// met les 8 broches en sortie
for (int i=0; i<=7; i++) { // boucle de défilement des 8 broches
pinMode(LED[i], OUTPUT); //met la broche en sortie
}
} // fin de la fonction setup()
// ********************************************************************************
//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension
void loop(){ // debut de la fonction loop()
for (int i=0; i<=7; i++) { // boucle de défilement des 8 bits / broches
// met la broche LED[i] dans l’état du bit de rang i de la variable compteur
digitalWrite(LED[i],bitRead(compteur,i));
}
compteur=compteur+1; //incrémente i
if (compteur>=256) compteur=0; // RAZ variable compteur 255 ==> 0
delay (250); // pause fixant la vitesse du comptage
} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
//*************** Autres Fonctions du programme *************
// — Fin programme —
