You are currently viewing Dé numérique sur un afficheur 7 segments avec Arduino
Dé numérique sur un afficheur 7 segments avec Arduino

Dé numérique sur un afficheur 7 segments avec Arduino

Cet article décrit la création d’un dé en utilisant Arduino, un afficheur 7 segments 5161BS et quelques composants.

Matériel utilisé

Les produits suivants ont été utilisés pour rédiger cet article :

Carte Arduino UNO Rev 3 Présentation de l'afficheur 7 segments 5161BS Résistance de 220 Ohm
Carte Arduino Afficheur 7 segments 5161BS Résistance 220 ohm

Commutateur momentané 6x6x9,5mm (bouton poussoir)

 Câbles de connexion Arduino Platine d'essai 400 points
Bouton poussoir Câbles mâle/mâle Plaque d’essai
Présentation du buzzer actif TMB12A05    
Buzzer actif 5V    

Montage

Le 5161BS ne possède pas de circuit intégré de pilotage des segments lumineux. Les bornes de cet afficheur alimentent directement les LEDs des segments. Comme l’indique la fiche produit, ces LEDS ont une tension maximale de 2,8V. Nous utilisons des résistances 220ohms qui permettent d’abaisser la tension 5V des sorties de la carte Arduino et d’obtenir un peu moins de 2,7V aux bornes de l’afficheur.

Le bouton poussoir permet de lancer le dé, le buzzer actif signale que le dé a fini de rouler sur la table.

Câblage de l'afficheur 5161BS, du bouton poussoir et du buzzer actif avec l'Arduino Uno
Câblage de l’afficheur 5161BS, du bouton poussoir et du buzzer actif avec l’Arduino Uno

Le câblage de l’afficheur 5161BS :

  • Fil jaune, la broche G de l’afficheur à la sortie 2 de l’Arduino par le biais d’une résistance 220 Ohm.
  • Fil marron, la broche F à la sortie 3 par le biais d’une résistance 220 ohm.
  • Fil bleu, la broche A à la sortie 4 par le biais d’une résistance 220 ohm.
  • Fil violet, la broche B à la sortie 5 par le biais d’une résistance 220 ohm.
  • Fil orange, la broche E à la sortie 12 par le biais d’une résistance 220 ohm.
  • Fil vert, la broche D à la sortie 11 par le biais d’une résistance 220 ohm.
  • Fil rouge, la broche VCC est à relier au +5v de l’Arduino Uno.
  • Fil jaune, la broche C à la sortie 9 par le biais d’une résistance 220 ohm.
  • Fil violet, la broche DP à la sortie 8 par le biais d’une résistance 220 ohm.
Brochage de l'afficheur 7 segments 5161 BS
Brochage de l’afficheur 7 segments 5161 BS

Pour le bouton-poussoir :

  • Fil noir, une broche est à la masse (GND) de l’Arduino Uno.
  • Fil gris, l’autre broche à l’entrée 7 de l’Arduino Uno. Cette entrée 7 sera configurée en Pull-Up (résistance de tirage) dans le code Arduino.

Câblage du buzzer :

  • Fil noir, la broche dépourvue du signe “+” est branchée à la masse (GND) de l’Arduino Uno par le biais du bouton poussoir.
  • Fil vert, la broche “+” est reliée à la sortie 6 de l’Arduino Uno.

Pour information, le montage suivant est aussi possible. Cependant, il n’est pas visuellement très agréable à utiliser du fait de la variation d’intensité des LEDS en fonction du nombre de segments utilisés (loi d’ohm).

Câblage économique de l'afficheur 5161BS, du bouton poussoir et du buzzer actif avec l'Arduino Uno
Câblage économique de l’afficheur 5161BS, du bouton poussoir et du buzzer actif avec l’Arduino Uno

Programme

Gestion des LEDs de l’afficheur

Afin de faciliter la lisibilité du code, les 8 LEDs de l’afficheur (7 segments + 1 pour le point) sont gérées sous forme de tableau en ordre alphabétique (A, B, C, D, E, F, G, DP).

Le tableau tabPortAfficheur_g[8] déclaré en global, permet d’accéder au numéro d’identification de la sortie associée à chaque LED.

// Brochage de l'afficheur
#define PORT_AFFICHEUR_A  4
#define PORT_AFFICHEUR_B  5
#define PORT_AFFICHEUR_C  9
#define PORT_AFFICHEUR_D  11
#define PORT_AFFICHEUR_E  12
#define PORT_AFFICHEUR_F  3
#define PORT_AFFICHEUR_G  2
#define PORT_AFFICHEUR_DP 8

int tabPortAfficheur_g[8] = { PORT_AFFICHEUR_A,
                              PORT_AFFICHEUR_B,
                              PORT_AFFICHEUR_C,
                              PORT_AFFICHEUR_D,
                              PORT_AFFICHEUR_E,
                              PORT_AFFICHEUR_F,
                              PORT_AFFICHEUR_G,
                              PORT_AFFICHEUR_DP};

L’afficheur 5161BS est à anode commune, aussi les identifiants OFF et ON sont utilisés pour ne pas être perturbé à la lecture du code par la logique inversée.

// Etat des leds de l'afficheur
#define OFF true
#define ON false

Fonctions d’affichage

Selon la valeur passée en paramètre, la fonction afficherChiffre(uint8_t chiffre_p) éteint ou allume les 8 LEDs de l’afficheur à l’aide de l’instruction Arduino digitalWrite. Cette fonction est capable de gérer tous les chiffres arabes, même si seul l’intervalle 1 à 6 est nécessaire pour ce projet.

La fonction effacerEcran(void) éteint toutes les LEDs.

Avertissement sonore

La fonction sonner(int dureeMillisecondes_p) génère un bip d’une durée paramétrable à la milliseconde, par la mise sous tension du buzzer actif.

Simulation d’un lancé de dé

La fonction traiterLancer(void) passe par 4 étapes :

  1. Initialisation du tirage aléatoire
  2. Affichage d’un chenillard à l’écran
  3. Simulation du dé qui roule
  4. Avertissement du tirage obtenu

L’utilisation du générateur de nombres pseudo-aléatoires d’Arduino nécessite de l’initialiser au préalable avec une valeur qui va varier à chaque exécution en utilisant l’instruction randomSeed(). La valeur variable utilisée pour cette initialisation est le nombre de secondes écoulées entre le démarrage du programme et l’appui bouton de lancé du dé (instruction millis()).

Le chenillard est affiché en allumant et en éteigant l’un après l’autre les segments A à F de l’afficheur.

Le dé qui roule est simulé par l’affichage de chiffres aléatoires entre 1 et 6 avec une pause de plus en plus grande entre les affichages. Le chiffre pseudo-aléatoire est obtenu par l’instruction Arduino random().

Le lanceur du dé est informé que le chiffre obtenu est le définitif par un clignotement du résultat et 2 bips sonores.

Gestion de l’appui bouton

La fonction loop() scrute l’état du bouton poussoir. Un appuis puis un relâchement de ce bouton provoque un appel à la fonction traiterLancer(void).

Code source complet

Voici la totalité du code source de ce projet :

/* Déclaration des bibliothèques utilisées */

/* Constantes */
// Durées
#define DELAI_FILTRE_PARASITES  50

// Brochage de l'afficheur
#define PORT_AFFICHEUR_A  4
#define PORT_AFFICHEUR_B  5
#define PORT_AFFICHEUR_C  9
#define PORT_AFFICHEUR_D  11
#define PORT_AFFICHEUR_E  12
#define PORT_AFFICHEUR_F  3
#define PORT_AFFICHEUR_G  2
#define PORT_AFFICHEUR_DP 8

// Etat des leds de l'afficheur
#define OFF true
#define ON false

// Brochage du bouton poussoir
#define PORT_BOUTON_START 7

// Brochage du buzzer
#define PORT_BUZZER 6

/* Déclaration globales */

int tabPortAfficheur_g[8] = { PORT_AFFICHEUR_A,
                              PORT_AFFICHEUR_B,
                              PORT_AFFICHEUR_C,
                              PORT_AFFICHEUR_D,
                              PORT_AFFICHEUR_E,
                              PORT_AFFICHEUR_F,
                              PORT_AFFICHEUR_G,
                              PORT_AFFICHEUR_DP};


/* Fonction de démarrage, s'exécute une seule fois: */
void setup()
{
  for(int ii_l=0; ii_l<8; ii_l++)
  {
    pinMode(tabPortAfficheur_g[ii_l],OUTPUT);
  }
  effacerEcran();

  pinMode(PORT_BUZZER, OUTPUT);
  pinMode(PORT_BOUTON_START, INPUT_PULLUP);
}

/* Fonction principale du programme, s'exécute en boucle: */
void loop()
{
  if(digitalRead(PORT_BOUTON_START) == LOW)
  {
    delay(DELAI_FILTRE_PARASITES);
    while(digitalRead(PORT_BOUTON_START) == LOW); // Attente de relachement du bouton poussoir
    traiterLancer();
  }
}

void afficherChiffre(uint8_t chiffre_p)
{
  bool tabAffichageChiffres_l[10][8] = {
    {  ON,  ON,  ON,  ON,  ON,  ON, OFF, OFF},    // 0
    { OFF,  ON,  ON, OFF, OFF, OFF, OFF, OFF},    // 1
    {  ON,  ON, OFF,  ON,  ON, OFF,  ON, OFF},    // 2
    {  ON,  ON,  ON,  ON, OFF, OFF,  ON, OFF},    // 3
    { OFF,  ON,  ON, OFF, OFF,  ON,  ON, OFF},    // 4
    {  ON,  OFF, ON,  ON, OFF,  ON,  ON, OFF},    // 5
    {  ON,OFF,   ON,  ON,  ON,  ON,  ON, OFF},    // 6
    {  ON,  ON,  ON, OFF, OFF, OFF, OFF, OFF},    // 7
    {  ON,  ON,  ON,  ON,  ON,  ON,  ON, OFF},    // 8
    {  ON,  ON,  ON, OFF, OFF,  ON,  ON, OFF}     // 9
  };

  for(uint8_t ii_l=0; ii_l< 8; ii_l++)
  {
    digitalWrite(tabPortAfficheur_g[ii_l],tabAffichageChiffres_l[chiffre_p][ii_l]);
  }
}

void traiterLancer(void)
{
  uint8_t chiffre_L;
  uint8_t ii_L, jj_L;
    
  randomSeed(millis());
  
  // Affichage d'un chenillard
  effacerEcran();
  for(jj_L=0; jj_L<3; jj_L++)
  {
    for(ii_L=0; ii_L<6; ii_L++)
    {
      digitalWrite(tabPortAfficheur_g[ii_L],ON);
      delay(60);
      digitalWrite(tabPortAfficheur_g[ii_L],OFF);
    }
  }
  
  // Simule le dé qui roule
  for(ii_L=0; ii_L<7; ii_L++)
  {
    chiffre_L = random(1, 6+1);
    afficherChiffre(chiffre_L);
    delay(ii_L*20+300);
  }

  // Le résultat clignotte avec bips
  for(ii_L=0; ii_L<2; ii_L++)
  {
    effacerEcran();
    delay(300);
    afficherChiffre(chiffre_L);
    sonner(300);
  }
}

void effacerEcran(void)
{
  for(uint8_t ii_l=0; ii_l< 8; ii_l++)
  {
    digitalWrite(tabPortAfficheur_g[ii_l],OFF);
  }
}

void sonner(int dureeMillisecondes_p)
{
  digitalWrite(PORT_BUZZER, true);
  delay(dureeMillisecondes_p);
  digitalWrite(PORT_BUZZER, false);
}

Résutat

Une fois votre programme compilé et transféré dans la carte Arduino Uno, voici ce que vous devez obtenir :

S’abonner
Notification pour
guest
0 Commentaires
Le plus ancien
Le plus récent Le plus populaire
Commentaires en ligne
Afficher tous les commentaires