Fonctionnement

Un afficheur 7 segments est constitué de sept LED, généralement identifiées par les lettres :

En allumant certaines combinaisons de segments, il est possible de représenter les chiffres de 0 à 9.

Dans notre montage, chaque segment est commandé directement par une sortie numérique de l'Arduino Uno.

Le projet utilise les broches :

Chaque segment est protégé par une résistance de 330 Ω.

Composants

• 1 × Arduino Uno Rev3
• 1 × afficheur 7 segments rouge à cathode commune
• 1 × plaque d'essai (breadboard)
• 7 × résistances de 330 Ω
• Plusieurs fils de connexion
• 1 × câble USB pour programmer l'Arduino

Schéma de câblage

Le principe consiste à relier chaque segment de l'afficheur à une sortie numérique de l'Arduino à travers une résistance de 330 Ω.

Attention : le câblage présenté correspond à un afficheur à cathode commune. Il faut vérifier le type d'afficheur utilisé avant de réaliser le montage.

Programme Arduino

Le programme utilise un tableau contenant les différentes combinaisons de segments.

// Définition des broches reliées à chaque segment de notre afficheur 7 segments
const int a = 4;
const int b = 5;
const int c = 6;
const int d = 7;
const int e = 8;
const int f = 9;
const int g = 10;

// Définition du tableau des segments de l'afficheur dans l'ordre alphabétique
int segments[] = {a, b, c, d, e, f, g};

// Déclaration de la matrice des états de chaque segment pour chaque affichage de chaque chiffre de 0 à 9
// Pour cela, nous définissons 1 pour un segment allumé et 0 pour un segment éteint
byte chiffres[10][7] = {
  // a, b, c, d, e, f, g, dp
  {1,1,1,1,1,1,0}, // 0
  {0,1,1,0,0,0,0}, // 1
  {1,1,0,1,1,0,1}, // 2
  {1,1,1,1,0,0,1}, // 3
  {0,1,1,0,0,1,1}, // 4
  {1,0,1,1,0,1,1}, // 5
  {1,0,1,1,1,1,1}, // 6
  {1,1,1,0,0,0,0}, // 7
  {1,1,1,1,1,1,1}, // 8
  {1,1,1,1,0,1,1}  // 9
};

void setup() {
  // Définition de toutes les broches nécessaires pour notre programme comme pin de sortie
  for (int i = 0; i < 7; i++) {
    pinMode(segments[i], OUTPUT);
  }
}

void loop() {
  // Boucle de 0 à 9
  for (int n = 0; n <= 9; n++) {
    afficherChiffre(n);
    delay(2000); // attendre 2 seconde
  }
}

// Fonction pour afficher un chiffre à partir de la matrice de définition de segments
void afficherChiffre(int n) {
  for (int i = 0; i < 8; i++) {
    digitalWrite(segments[i], chiffres[n][i]);
  }
}

Test

Après avoir câblé le circuit et téléversé le programme dans l'Arduino Uno, l'afficheur doit présenter successivement :

0 → 1 → 2 → 3 → 4 → 5 → 6 → 7 → 8 → 9

Chaque chiffre reste affiché pendant environ 2 secondes, puis le compteur recommence.

Ce que permet d'apprendre ce projet

Ce petit montage permet notamment de découvrir :

• le fonctionnement d'un afficheur 7 segments ;
• les sorties numériques d'un Arduino ;
• l'utilisation de pinMode() et digitalWrite() ;
• les boucles for ;
• les tableaux en programmation C/C++ ;
• la représentation d'un chiffre à l'aide de plusieurs sorties numériques ;
• le rôle des résistances de limitation de courant.

Améliorations possibles

Une fois le montage fonctionnel, plusieurs améliorations peuvent être envisagées :

• ajouter un bouton pour incrémenter le compteur manuellement ;
• modifier la vitesse de comptage ;
• réaliser un compteur de 0 à 99 avec deux afficheurs ;
• utiliser un registre à décalage 74HC595 pour réduire le nombre de broches utilisées ;
• ajouter un bouton de remise à zéro ;
• remplacer delay() par une gestion du temps avec millis() ;
• transformer le montage en véritable compteur d'impulsions.

Conclusion

Ce projet constitue une première approche simple...