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 :
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.
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).
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 :
- Initialisation du tirage aléatoire
- Affichage d’un chenillard à l’écran
- Simulation du dé qui roule
- 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 :
