Les points à développer :

C’est quoi un afficheur 7 Segment ?

Les afficheurs 7 segments sont des afficheurs à LEDs hérités d’une époque maintenant révolue où chacun pouvait acheter son kit électronique à monter soi même à la boutique d’électronique du coin ou en envoyant son formulaire découpé dans les magazines d’électronique de l’époque. On trouve aujourd’hui de moins en moins d’afficheurs 7 segments dans les appareils du commerce. C’est bien dommage, car il s’agit d’une technologie simple et efficace.

Aucun film d’action ne serait complet sans un vilain méchant avec une bombe affichant le temps restant avant l’explosion sur un afficheur 7 segments et bipant chaque seconde, pour que le héros puisse arrêter le compteur à 00:00:01.

Les afficheurs 7 segments sont des afficheurs à LEDs constitués de 7 segments (une LED par segment), qui permettent d’afficher des chiffres et même parfois des lettres en fonction de l’application.

Il y a encore quelques années, les afficheurs 7 segments étaient partout : radio, réveil, montre, calculatrice, micro-onde, four, minuteur, systèmes industriels, outil de mesure, etc. Aujourd’hui, les afficheurs 7 segments ont pour la plupart été replacés par des afficheurs LCD ou des écrans graphiques plus haut de gamme. On ne trouve des afficheurs 7 segments que dans des cas d’usage très particuliers : voltmètre pour modélisme, carte électronique DIY ou pour un marché de niche, outils de mesure low cost, etc.

Les afficheurs 7 segments ont été oubliés, car trop sobres, les temps changent, les goûts aussi. Mais comme il s’agit simplement d’une série de LEDs dans un même boitier, au final, c’est une technologie très simple à mettre en œuvre. Et comme on dit, souvent, la solution la plus simple est la meilleure.

Les afficheurs 7 segments sont constitués de 7 segments, d’où leur nom. Ces segments sont nommés A, B, C, D, E et F par convention, et ils se présentent dans l’ordre illustré ci-dessus.

Chaque segment correspond à une LED qu’il est possible d’allumer ou d’éteindre pour former des chiffres, des lettres et même des caractères spéciaux rudimentaires. En général, les afficheurs disposent de 7 segments et d’un « point décimal » qui peut être utilisé pour afficher des nombres à virgule ou des sous-unités (dixième de seconde par exemple).

Câblage avec Arduino

Pour comprendre comment utiliser un afficheur 7 segments, le plus simple est d’en mettre un en application dans un montage de test

Pour réaliser ce premier montage, il va nous falloir :

  • Une carte Arduino UNO (et son câble USB),
  • Un afficheur 7 segments à cathode commune,
  • Huit résistances de 1K ohms – code couleur marron / noir / rouge,
  • Une plaque d’essai et des fils pour câbler notre montage.

Vue schématique

Le simple code pour tester 

/** * Exemple de code pour un unique afficheur 7 segments. */ /* Broches des différents segments de l’afficheur */

const byte PIN_SEGMENT_A = 2;

const byte PIN_SEGMENT_B = 3;

const byte PIN_SEGMENT_C = 4;

const byte PIN_SEGMENT_D = 5;

const byte PIN_SEGMENT_E = 6;

const byte PIN_SEGMENT_F = 7;

const byte PIN_SEGMENT_G = 8;

const byte PIN_SEGMENT_DP = 9;

/* Décommenter si utilisation d’un afficheur 7 segments à ANODE commune */

//#define _7SEG_COMMON_ANODE

/* Table de correspondance valeur -> états des segments de l’afficheur */

const byte LUT_ETATS_SEGMENTS[] = {

0b00111111,

0b00000110,

0b01011011,

0b01001111,

0b01100110,

0b01101101,

0b01111101,

0b00000111,

0b01111111,

0b01101111,

0b01110111,

0b01111100,

0b00111001,

0b01011110,

0b01111001,

0b01110001

};

/** Fonction setup() */

void setup() {

/* Toutes les broches en sorties */

pinMode(PIN_SEGMENT_A, OUTPUT);

digitalWrite(PIN_SEGMENT_A, LOW);

pinMode(PIN_SEGMENT_B, OUTPUT);

digitalWrite(PIN_SEGMENT_B, LOW);

pinMode(PIN_SEGMENT_C, OUTPUT);

digitalWrite(PIN_SEGMENT_C, LOW);

pinMode(PIN_SEGMENT_D, OUTPUT);

digitalWrite(PIN_SEGMENT_D, LOW);

pinMode(PIN_SEGMENT_E, OUTPUT);

digitalWrite(PIN_SEGMENT_E, LOW);

pinMode(PIN_SEGMENT_F, OUTPUT);

digitalWrite(PIN_SEGMENT_F, LOW);

pinMode(PIN_SEGMENT_G, OUTPUT);

digitalWrite(PIN_SEGMENT_G, LOW);

pinMode(PIN_SEGMENT_DP, OUTPUT);

digitalWrite(PIN_SEGMENT_DP, LOW);

}

/** Fonction loop() */

void loop() {

static byte chiffre = 0;

static byte etat_dp = 0;

/* Affiche le chiffre */

affiche_chiffre_7seg(chiffre, etat_dp);

/* Incrémente le chiffre de 0 à 15 */

if (++chiffre == 16)

{

chiffre = 0;

}

/* Fait clignoter le point décimal (inverse l’état à chaque fois) */

etat_dp = !etat_dp;

/* Délai pour la démo */

delay(1000); }

/** Fonction permettant d’afficher un chiffre sur un afficheur 7 segments */

void affiche_chiffre_7seg(byte chiffre, byte dp)

{

/* Simple sécurité */

if (chiffre > 15)

return;  // Accepte uniquement des valeurs de 0 à 15.

/* Conversion chiffre -> états des segments */

byte segments = LUT_ETATS_SEGMENTS[chiffre];

/* Affichage */

#ifndef _7SEG_COMMON_ANODE

digitalWrite(PIN_SEGMENT_A, bitRead(segments, 0));

digitalWrite(PIN_SEGMENT_B, bitRead(segments, 1));

digitalWrite(PIN_SEGMENT_C, bitRead(segments, 2));

digitalWrite(PIN_SEGMENT_D, bitRead(segments, 3));

digitalWrite(PIN_SEGMENT_E, bitRead(segments, 4));

digitalWrite(PIN_SEGMENT_F, bitRead(segments, 5));

digitalWrite(PIN_SEGMENT_G, bitRead(segments, 6));

digitalWrite(PIN_SEGMENT_DP, dp);

#else

digitalWrite(PIN_SEGMENT_A, !bitRead(segments, 0));

digitalWrite(PIN_SEGMENT_B, !bitRead(segments, 1));

digitalWrite(PIN_SEGMENT_C, !bitRead(segments, 2));

digitalWrite(PIN_SEGMENT_D, !bitRead(segments, 3));

digitalWrite(PIN_SEGMENT_E, !bitRead(segments, 4));

digitalWrite(PIN_SEGMENT_F, !bitRead(segments, 5));

digitalWrite(PIN_SEGMENT_G, !bitRead(segments, 6));

digitalWrite(PIN_SEGMENT_DP, !dp);

#endif

Les détails ne sont pas renseignés

0.00 average based on 0 ratings

5 Star
0%
4 Star
0%
3 Star
0%
2 Star
0%
1 Star
0%

Course Features

  • Duration : 10 week
  • Max Students : 1000
  • Enrolled : 0
  • Assessments : Self
Price :
Gratuit

Rating

Average Rating: 0.00

Star
0%
Star
0%
Star
0%
Star
0%
Star
0%