Afin d’obtenir des informations provenant de l’Arduino sans le brancher à l’ordinateur, il est courant d’utiliser une interface comme l’afficheur 4×7 segments. Nous allons voir dans ce tutoriel comment brancher et programmer l’Arduino afin de faire apparaitre des informations sur l’afficheur.

Il est possible de brancher directement l’afficheur 7 segments sur les broches de l’Arduino. Afin de conserver des broches libres pour d’autres fonctionnalités, nous utilisons un registre à décalages 74HC595.

Matériel

• Ordinateur
• Arduino UNO
• Afficheur 4×7 segments
• Registre à décalage 74HC595
• Câble Dupont
• Breadboard

Principe de fonctionnement

Les afficheurs 7 segments consiste en une série de LED placé pour former des chiffres. Ces LEDS sont gérer via les broches de l’afficheur(1-12).

Les groupements de LED ou digits sont activés via les broches D1,D2,D3,D4 et les leds sont allumées via les broches A,B,C,D,E,F,G et DP pour le point décimal.

Il existe deux types d’afficheurs, avec cathode commune (série A en Haut) ou avec anode commune (série B en bas). Pour la série anode, il faut connecté le commun à 5V pour activer le digit et passer la broche à l’état BAS pour allumer une LED. Dans le cas d’une cathode commune, il faut connecter les communs à la masse et passer la broche à l’état HAUT pour allumer la LED.

Vérifiez bien le modèle que vous avez. Dans ce tutoriel, nous utilisons l’afficheur 4×7 segments 5461BS avec anode commune.

Schéma

Nous utilisons un registre à décalage 74HC595 dont nous connectons les sorties Q0-6 et Q7 aux entrées de l’afficheur A-F et DP respectivement.

Code

#define NUM_OF_DIGITS 4

int latch = 4; //74HC595  pin 9 STCP
int cs = 5; //74HC595  pin 10 SHCP
int data = 3; //74HC595  pin 8 DS
int dPins[4] = {11, 10, 9, 8};

//  DP G F E D C B A
//0: 1 1 0 0 0 0 0 0 0xc0
//1: 1 1 1 1 1 0 0 1 0xf9
//2: 1 0 1 0 0 1 0 0 0xa4
//3: 1 0 1 1 0 0 0 0 0xb0
//4: 1 0 0 1 1 0 0 1 0x99
//5: 1 0 0 1 0 0 1 0 0x92
//6: 1 0 0 0 0 0 1 0 0x82
//7: 1 1 1 1 1 0 0 0 0xf8
//8: 1 0 0 0 0 0 0 0 0x80
//9: 1 0 0 1 0 0 0 0 0x90
unsigned char table[] =
{0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90};

void setup() {
  Serial.begin(115200);
  pinMode(latch, OUTPUT);
  pinMode(cs, OUTPUT);
  pinMode(data, OUTPUT);
  for (int j = 0; j < NUM_OF_DIGITS; j++) pinMode(dPins[j], OUTPUT);
}

void loop() {
  //Count from 0 to 9 on each digit
  for (int i = 0; i < NUM_OF_DIGITS; i++) {
    for (int j = 0; j < 10; j++) {
      Display(i, j);
      delay(500);
      Serial.println(j);
    }
    delay(500);
  }
}

void Display(int id, unsigned char num)
{
  digitalWrite(latch, LOW);
  shiftOut(data, cs, MSBFIRST, table[num]);
  digitalWrite(latch, HIGH);
  for (int j = 0; j < NUM_OF_DIGITS; j++) digitalWrite(dPins[j], LOW);
  digitalWrite(dPins[id], HIGH);
}

Une fois le code téléversé, l’afficheur devrait compter de 0 à 9 sur chaque digit.

Bonus: Affichage sur les 4 digits

Afin d’afficher un nombre sur les 4 digits, nous allons convertir le nombre en 4 chiffre de base 10 en utilisant les instructions suivantes:

      number = k;
      for (int i = 0; i < NUM_OF_DIGITS; i++)
      {
        digit_data[i] = number % 10;
        number /= 10;
      }

Nous allons aussi utiliser la fonction millis() afin de s’assurer que l’affichage est rafrachit correctement.

#define NUM_OF_DIGITS 4

int latch = 4; //74HC595  pin 9 STCP
int cs = 5; //74HC595  pin 10 SHCP
int data = 3; //74HC595  pin 8 DS

int dPins[4] = {11, 10, 9, 8};

//  DP G F E D C B A
//0: 1 1 0 0 0 0 0 0 0xc0
//1: 1 1 1 1 1 0 0 1 0xf9
//2: 1 0 1 0 0 1 0 0 0xa4
//3: 1 0 1 1 0 0 0 0 0xb0
//4: 1 0 0 1 1 0 0 1 0x99
//5: 1 0 0 1 0 0 1 0 0x92
//6: 1 0 0 0 0 0 1 0 0x82
//7: 1 1 1 1 1 0 0 0 0xf8
//8: 1 0 0 0 0 0 0 0 0x80
//9: 1 0 0 1 0 0 0 0 0x90
unsigned char table[] =
{0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90};


int digit_data[NUM_OF_DIGITS] = {0};

unsigned int number = 0;
unsigned long previousUpdate = 0, updateTime = 200;

void setup() {
  Serial.begin(115200);
  pinMode(latch, OUTPUT);
  pinMode(cs, OUTPUT);
  pinMode(data, OUTPUT);

  for (int j = 0; j < NUM_OF_DIGITS; j++) pinMode(dPins[j], OUTPUT);
}

void loop() {
  //Count from 0 to 999 on each digit
  unsigned int k = 0;
  while (k < 1000) {
    updateDigits();
    if (millis() - previousUpdate > updateTime) {
      k++;
      previousUpdate = millis();
      number = k;
      Serial.print(k); Serial.print(" (");
      for (int i = 0; i < NUM_OF_DIGITS; i++)
      {
        digit_data[i] = number % 10;
        number /= 10;
        Serial.print(digit_data[i]);
      }
      Serial.println(")");
    }
  }
}

void Display(int id, unsigned char num)
{
  digitalWrite(latch, LOW);
  shiftOut(data, cs, MSBFIRST, table[num]);
  digitalWrite(latch, HIGH);
  for (int j = 0; j < NUM_OF_DIGITS; j++) digitalWrite(dPins[j], LOW);
  digitalWrite(dPins[id], HIGH);
}

void updateDigits() {
  for (int j = 0; j < NUM_OF_DIGITS; j++)
  {
    Display(j, digit_data[j]);
    delay(5);
  }
}

Le nombre devrait s’incrémenter toutes les 200 millisecondes et s’afficher sur les 4 digits.

Sources

• Utilisation d’un registre à décalage