Compteur binaire 8 bits

De Wikidebrouillard.

Modèle:Vidéo

Sommaire 1 Présentation du projet arduino 2 Liste du matériel 3 Réalisation du projet 3.1 Explication 3.2 Schéma Fritzing 3.3 Code 4 Liens avec d'autres projets arduino 5 Pour aller plus loin 6 Liens avec le quotidien

Présentation du projet arduino

Ce programme Arduino réalise un affichage d'un compteur binaire sur 8 LEDs.

Chaque LED visualise directement l'état d'un bit de l'octet utilisé pour le comptage. On peut le faire manuellement ou automatiquement en utilisant un bouton, pour passer d'un mode à l'autre.

Liste du matériel

• Un ordinateur pour programmer
• Le logiciel Arduino
• La carte Arduino Uno
• Une plaque labdec ou Breadboard
• Du fil électrique (noir, rouge…)
• 8 leds
• Fichier:Résistance.jpg 8 résistances de 220 Ω
• 2 boutons poussoirs
• Fichier:Résistance.jpg 2 résistances de 10 kΩ
• 2 condensateurs de 10 nF

Réalisation du projet

Explication

Ce compteur binaire possède deux modes de fonctionnement qu'on sélectionne avec le bouton poussoir connecté sur la broche 2 de l'Arduino. Un mode manuel qui est sélectionné par défaut et qui incrémente le comptage à l'aide du bouton poussoir connecté sur la broche 11. Un mode automatique qu'on sélectionne/désélectionne par pression sur le bouton en question.

Schéma Fritzing

Les boutons ne sont pas des systèmes mécaniques parfaits. Du coup, lorsqu'un appui est fait dessus, le signal ne passe pas immédiatement et proprement de 5V à 0V (ou de 0V à 5V). En l'espace de quelques millisecondes, le signal va "sauter" entre 5V et 0V plusieurs fois avant de se stabiliser. Il se passe le même phénomène lorsque l'utilisateur relâche le bouton. Ce genre d'effet n'est pas désirable, car il peut engendrer des parasites au sein de votre programme (si vous voulez détecter un appui, les rebonds vont vous en générer une dizaine en quelques millisecondes, ce qui peut-être très gênant dans le cas d'un compteur par exemple).

Pour atténuer ce phénomène, nous allons utiliser un condensateur en parallèle avec le bouton. Ce composant servira ici "d'amortisseur" qui absorbera les rebonds (comme sur une voiture avec les cahots de la route). Le condensateur, initialement chargé, va se décharger lors de l'appui sur le bouton. S'il y a des rebonds, ils seront encaissés par le condensateur durant cette décharge. Il se passera le phénomène inverse (charge du condensateur) lors du relâchement du bouton.

Code

/*

************************************* Compteur binaire 8 bits *************************************

*/

//************************************ Déclaration des broches ************************************

const int btn_increment = 11;        // le bouton est connecté à la broche 11 de la carte arduino      
const int LED[8]={3,4,5,6,7,8,9,10}; // déclare un tableau de 8 constantes de broches
                             // la broche 3 correspond au bit de poids faible (index 0 du tableau)
                             // la broche 10 correspond au bit de poids fort (index 8 du tableau)

//****************************** Déclaration des variables globales ******************************

int compteur = 0;                      // variable de comptage
int etat_btn = HIGH;                   // variable qui enregistre l'état du bouton
int dernier_etat_btn = HIGH;           // variable qui enregiste le dernier état du bouton
int btn_mode = 1;                      // variable qui permet de passer d'un mode à l'autre

//*************************************** Fonction setup ***************************************
// La fonction setup() est exécutée en premier et une seule fois au démarrage du programme

void setup()   
{
  pinMode (btn_increment, INPUT);     // le bouton d'incrémentation est une entrée
  for (int i=0; i<=7; i++)            // met les 8 LEDs en sortie
  { 
    pinMode(LED[i], OUTPUT);           
  }
  attachInterrupt(0, changement_mode, RISING); // on initialise l'interruption
}

//********************************** Programme d'interruption **********************************
// La fonction void changement_mode() est exécutée à chaque pression du bouton qui permet de 
// changer de mode

void changement_mode()
{
  btn_mode = !btn_mode;               // change la variable par son opposé
}

//*************************************** Fonction loop ***************************************
// La fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension

void loop()                            // début de la fonction loop
{
  while (btn_mode == 1)                // tant que btn_mode = 1, on exécute cette boucle
  {
    etat_btn = digitalRead (11);       // lit l'état actuel du bouton poussoir et le mémorise dans 
                                       // la variable etat_btn

    if (etat_btn != dernier_etat_btn)  // si l'état du bouton est différent du dernier état, on exécute 
                                       // la boucle
    {
      if (etat_btn == LOW )            // si l'état du bouton est 0
      {
        compteur++;                    // on incrémente le compteur
       
        if (compteur>=256) compteur = 0; // RAZ de la variable compteur lorsque qu'on dépasse la 
                                         // valeur 255
      }

      for (int i=0; i<=7; i++) 
      { 
        digitalWrite(LED[i],bitRead(compteur,i));
      }
      dernier_etat_btn = etat_btn;
      delay (60);
    }
  }

  while (btn_mode == 0 )
  {
    for (int i=0; i<=7; i++) // boucle de défilement des 8 bits / broches    
    {   
      digitalWrite(LED[i],bitRead(compteur,i));// met la broche LED[i] dans l'état du bit de rang i 
                                               // de la variable compteur
    }

    compteur++;                      // on incrémente le compteur
     
    if (compteur>=256) compteur=  0; // RAZ de la variable compteur lorsque qu'on dépasse la valeur 255

    delay (250);                     // pause de 250ms fixant la vitesse du comptage
  }
}                                    // le programme recommence au début de la fonction loop()

Liens avec d'autres projets arduino

Explorez la Catégorie Arduino de Wikidébrouillard

Pour aller plus loin

Liens avec le quotidien

Le principe de comptage en binaire est très utilisé dans l'électronique. Il est donc nécessaire de comprendre son fonctionnement (bit de poids faible/fort)

Compteur binaire 8 bits