Minuterie décompte réglable DIY avec Arduino Mega 2560 et afficheur 7 segments 4 digits

Composants et fournitures

À propos du projet

La minuterie à décompte est LE projet classique pour un afficheur 7 segments 4 digits. En cherchant en ligne, j'ai trouvé plusieurs réalisations, mais aucune ne correspondait à mon idée : une minuterie autonome, réglable facilement par boutons (sans recompiler le code). Je l'ai donc créée.

J'ai passé du temps à écrire un code simple à utiliser et à régler, pour un usage pratique réel. Le code inclus est aussi réutilisable dans d'autres projets avec afficheur 4 digits 7 segments. Il contient notamment une fonction PrintNumber qui affiche un nombre donné (0-9999) pendant un temps donné — très pratique car piloter cet afficheur est délicat (un seul digit à la fois en multiplexage).

Code

Minuterie décompte sur afficheur 4 digits 7 segments (C/C++)

Le code contient la fonction de décompte et la fonction utilitaire PrintNumber pour afficher un nombre 4 digits pendant une durée donnée (réutilisable).

#include <math.h>

int digit_pin[] = {6, 9, 10, 11}; // Pins PWM des digits (gauche à droite)
int speakerPin = 15;
#define DIGIT_ON  LOW
#define DIGIT_OFF HIGH

int segA = 2, segB = 3, segC = 4, segD = 5;
int segE = A0; // pin 6 utilisée par digit 1 pour PWM
int segF = 7, segG = 8;

int button1 = 13; // Start/Stop
int button2 = 12; // Annuler/Reset
int button3 = 16; // Décrémenter
int button4 = 17; // Incrémenter

int countdown_time = 60; // Valeur par défaut (secondes)

struct struct_digits { int digit[4]; };

void setup() {
  pinMode(segA, OUTPUT); pinMode(segB, OUTPUT); pinMode(segC, OUTPUT);
  pinMode(segD, OUTPUT); pinMode(segE, OUTPUT); pinMode(segF, OUTPUT);
  pinMode(segG, OUTPUT);
  for (int i = 0; i < 4; i++) pinMode(digit_pin[i], OUTPUT);
  pinMode(speakerPin, OUTPUT);
  pinMode(button1, INPUT_PULLUP);
  pinMode(button2, INPUT_PULLUP);
  pinMode(button3, INPUT_PULLUP);
  pinMode(button4, INPUT_PULLUP);
}

void playTone(int tone, int duration) {
  for (long k = 0; k < duration * 1000L; k += tone * 2) {
    digitalWrite(speakerPin, HIGH);
    delayMicroseconds(tone);
    digitalWrite(speakerPin, LOW);
    delayMicroseconds(tone);
  }
}

void lightNumber(int numberToDisplay) {
  #define SEGMENT_ON  HIGH
  #define SEGMENT_OFF LOW
  switch (numberToDisplay) {
    case 0: digitalWrite(segA, SEGMENT_ON);  digitalWrite(segB, SEGMENT_ON);  digitalWrite(segC, SEGMENT_ON);
            digitalWrite(segD, SEGMENT_ON);  digitalWrite(segE, SEGMENT_ON);  digitalWrite(segF, SEGMENT_ON);
            digitalWrite(segG, SEGMENT_OFF); break;
    case 1: digitalWrite(segA, SEGMENT_OFF); digitalWrite(segB, SEGMENT_ON);  digitalWrite(segC, SEGMENT_ON);
            digitalWrite(segD, SEGMENT_OFF); digitalWrite(segE, SEGMENT_OFF); digitalWrite(segF, SEGMENT_OFF);
            digitalWrite(segG, SEGMENT_OFF); break;
    case 2: digitalWrite(segA, SEGMENT_ON);  digitalWrite(segB, SEGMENT_ON);  digitalWrite(segC, SEGMENT_OFF);
            digitalWrite(segD, SEGMENT_ON);  digitalWrite(segE, SEGMENT_ON);  digitalWrite(segF, SEGMENT_OFF);
            digitalWrite(segG, SEGMENT_ON);  break;
    case 3: digitalWrite(segA, SEGMENT_ON);  digitalWrite(segB, SEGMENT_ON);  digitalWrite(segC, SEGMENT_ON);
            digitalWrite(segD, SEGMENT_ON);  digitalWrite(segE, SEGMENT_OFF); digitalWrite(segF, SEGMENT_OFF);
            digitalWrite(segG, SEGMENT_ON);  break;
    case 4: digitalWrite(segA, SEGMENT_OFF); digitalWrite(segB, SEGMENT_ON);  digitalWrite(segC, SEGMENT_ON);
            digitalWrite(segD, SEGMENT_OFF); digitalWrite(segE, SEGMENT_OFF); digitalWrite(segF, SEGMENT_ON);
            digitalWrite(segG, SEGMENT_ON);  break;
    case 5: digitalWrite(segA, SEGMENT_ON);  digitalWrite(segB, SEGMENT_OFF); digitalWrite(segC, SEGMENT_ON);
            digitalWrite(segD, SEGMENT_ON);  digitalWrite(segE, SEGMENT_OFF); digitalWrite(segF, SEGMENT_ON);
            digitalWrite(segG, SEGMENT_ON);  break;
    case 6: digitalWrite(segA, SEGMENT_ON);  digitalWrite(segB, SEGMENT_OFF); digitalWrite(segC, SEGMENT_ON);
            digitalWrite(segD, SEGMENT_ON);  digitalWrite(segE, SEGMENT_ON);  digitalWrite(segF, SEGMENT_ON);
            digitalWrite(segG, SEGMENT_ON);  break;
    case 7: digitalWrite(segA, SEGMENT_ON);  digitalWrite(segB, SEGMENT_ON);  digitalWrite(segC, SEGMENT_ON);
            digitalWrite(segD, SEGMENT_OFF); digitalWrite(segE, SEGMENT_OFF); digitalWrite(segF, SEGMENT_OFF);
            digitalWrite(segG, SEGMENT_OFF); break;
    case 8: digitalWrite(segA, SEGMENT_ON);  digitalWrite(segB, SEGMENT_ON);  digitalWrite(segC, SEGMENT_ON);
            digitalWrite(segD, SEGMENT_ON);  digitalWrite(segE, SEGMENT_ON);  digitalWrite(segF, SEGMENT_ON);
            digitalWrite(segG, SEGMENT_ON);  break;
    case 9: digitalWrite(segA, SEGMENT_ON);  digitalWrite(segB, SEGMENT_ON);  digitalWrite(segC, SEGMENT_ON);
            digitalWrite(segD, SEGMENT_ON);  digitalWrite(segE, SEGMENT_OFF); digitalWrite(segF, SEGMENT_ON);
            digitalWrite(segG, SEGMENT_ON);  break;
    case 10: // Eteint
            digitalWrite(segA, SEGMENT_OFF); digitalWrite(segB, SEGMENT_OFF); digitalWrite(segC, SEGMENT_OFF);
            digitalWrite(segD, SEGMENT_OFF); digitalWrite(segE, SEGMENT_OFF); digitalWrite(segF, SEGMENT_OFF);
            digitalWrite(segG, SEGMENT_OFF); break;
  }
}

void SwitchDigit(int digit) {
  for (int i = 0; i < 4; i++) {
    digitalWrite(digit_pin[i], (i == digit) ? DIGIT_ON : DIGIT_OFF);
  }
}

struct struct_digits IntToDigits(int n) {
  struct struct_digits dig;
  int zeros = 0, d;
  for (int i = 0; i < 4; i++) {
    d = n / pow(10, 3 - i);
    zeros += d;
    n -= d * pow(10, 3 - i);
    dig.digit[i] = (zeros != 0 || i == 3) ? d : 10; // 10 = éteint (leading zeros)
  }
  return dig;
}

void PrintNumber(int n, int time) {
  struct struct_digits dig = IntToDigits(n);
  for (int i = 0; i <= time / 20; i++) {
    if (digitalRead(button2) == LOW) return; // Annulation
    for (int j = 0; j < 4; j++) {
      SwitchDigit(j);
      lightNumber(dig.digit[j]);
      delay(5);
    }
  }
}

bool Countdown(int n, int del) {
  for (int q = n; q > 0; q--) {
    PrintNumber(q, del);
    if (digitalRead(button2) == LOW) return false; // Annulé
  }
  PrintNumber(0, 0);
  playTone(1519, 1000); // Bip final
  return true;
}

void reset() {
  int pressed3 = 0, pressed4 = 0;
  struct struct_digits dig = IntToDigits(countdown_time);
  
  while (digitalRead(button1) == HIGH) { // Attend appui sur Start
    for (int j = 0; j < 4; j++) {
      SwitchDigit(j);
      lightNumber(dig.digit[j]);
      delay(5);
    }
    // Incrémentation/décrémentation avec répétition auto (maintien > 30 boucles)
    if (digitalRead(button3) == LOW) {
      if (pressed3 == 0 || pressed3 > 30) {
        if (countdown_time > 0) countdown_time--;
        dig = IntToDigits(countdown_time);
      }
      pressed3++;
    } else if (digitalRead(button4) == LOW) {
      if (pressed4 == 0 || pressed4 > 30) {
        if (countdown_time < 9999) countdown_time++;
        dig = IntToDigits(countdown_time);
      }
      pressed4++;
    }
    if (digitalRead(button3) == HIGH) pressed3 = 0;
    if (digitalRead(button4) == HIGH) pressed4 = 0;
  }
}

void loop() {
  reset();                    // Phase de réglage
  while (!Countdown(countdown_time, 962)) { // Décompte (962ms ≈ 1s avec multiplexage)
    reset();                  // Si annulé, retour au réglage
  }
  while (digitalRead(button2) == HIGH) {}; // Attend relâchement bouton annuler
}

Schémas