Carte LED et Boutons avec Arduino Mega 2560 : Projets interactifs et mini-jeux faciles

Sommaire

Présentation de la carte LED & boutons pour Arduino

La carte LED + Boutons, compatible Arduino, ESP32 et Raspberry Pi, est un module simple et polyvalent conçu pour l’apprentissage et les prototypes rapides.
Elle réunit 8 boutons poussoirs et 8 LED, idéale pour des projets ludiques comme un chenillard, un dé électronique ou un jeu de mémoire.

Les boutons sont regroupés sur un connecteur 10 broches comprenant :

  • VCC (alimentation)
  • GND (masse)
  • 8 broches d’entrée distinctes (une par bouton)

Les LED sont accessibles via un connecteur 9 broches :

  • GND partagé
  • 8 broches de sortie dédiées (une par LED)

Grâce à ce format, la carte se branche facilement sur une carte Arduino (par exemple une Arduino Mega) sans soudure : alimentez la carte, reliez la masse et connectez les lignes de commande — et c’est prêt.

C’est une excellente plateforme pédagogique pour découvrir la gestion des entrées/sorties numériques, la lecture de boutons, le pilotage de LED et la création de petits projets interactifs.

Carte LED et Boutons pour le prototypage électronique
Carte LED et Boutons pour le prototypage électronique

Le Montage

Dans cette section, nous listons le matériel nécessaire et présentons le câblage entre une Arduino Mega 2560 et la carte LED & boutons. Le montage est simple : il suffit de connecter les entrées boutons, les sorties LED, l’alimentation 5V et la masse.

Matériel nécessaire

  • 1 Carte Arduino Mega 2560
  • 1 carte LED & Boutons
  • 1 câble USB Type-C
  • Câbles de connexion M-F 20 cm

Câblage Arduino Mega → Carte LEDs & Boutons

Le tableau ci-dessous indique la correspondance entre les broches numériques de l’Arduino Mega et les boutons / LEDs de la carte.

 

Arduino MEGACarte Leds et Boutons
D22BT1
D23BT2
D24BT3
D25BT4
D26BT5
D27BT6
D28BT7
D29BT8
D30L8
D31L7
D32L6
D33L5
D34L4
D35L3
D36L2
D37L1
5VVCC
GNDGND

Programmation Arduino de la carte LEDs & Boutons (Arduino Mega 2560)

Nous allons configurer et programmer la carte LEDs & boutons avec une Arduino Mega 2560 pour réaliser plusieurs applications interactives :

  • Mode Instantané : chaque LED s’allume dès que l’on appuie sur son bouton et s’éteint immédiatement lorsqu’on le relâche.
  • Mode Bascule : un appui sur un bouton inverse l’état de la LED associée (ON ⇄ OFF).
  • Chenillard : un effet lumineux dynamique où les LED s’allument successivement, avec une vitesse réglable grâce aux boutons.
  • Simon Game : un jeu de mémoire où l’utilisateur doit reproduire une séquence lumineuse en appuyant sur les bons boutons.
  • Dé électronique : un outil pratique pour les jeux de plateau et les jeux de rôle, affichant un résultat aléatoire de 1 à 6 via les LED.

Librairies

Aucune librairie externe n’est nécessaire pour ces exemples — tout fonctionne avec les fonctions standards de l’IDE Arduino.


Mode instantané

Dans ce mode, chaque LED s’allume tant que son bouton est pressé et s’éteint au relâchement.

				
					const int buttonPins[8] = {22, 23, 24, 25, 26, 27, 28, 29};
const int ledPins[8]    = {37, 36, 35, 34, 33, 32, 31, 30};

void setup() {
  for (int i = 0; i < 8; i++) {
    pinMode(buttonPins[i], INPUT);       // Boutons en entrée
    pinMode(ledPins[i], OUTPUT);         // LED en sortie
  }
}

void loop() {
  for (int i = 0; i < 8; i++) {
    int state = digitalRead(buttonPins[i]);
    digitalWrite(ledPins[i], state);     // LED ON si bouton appuyé
  }
}

				
			

Mode bascule

Dans le mode bascule, chaque bouton agit comme un interrupteur : la LED change d’état (allumée ou éteinte) à chaque fois qu’on appuie et relâche le bouton qui lui correspond .

				
					const int buttonPins[8] = {22, 23, 24, 25, 26, 27, 28, 29};
const int ledPins[8]    = {37, 36, 35, 34, 33, 32, 31, 30};

bool ledState[8] = {0};
bool prev[8] = {0};

void setup() {
  for (int i = 0; i < 8; i++) {
    pinMode(buttonPins[i], INPUT);  // Pull-down externe
    pinMode(ledPins[i], OUTPUT);
  }
}

void loop() {
  for (int i = 0; i < 8; i++) {

    bool reading = digitalRead(buttonPins[i]);

    if (reading == HIGH && prev[i] == LOW) {
      ledState[i] = !ledState[i];  
      digitalWrite(ledPins[i], ledState[i]);
      delay(200); // anti-rebond simple
    }

    prev[i] = reading;
  }
}

				
			

Chenillard (vitesse contrôlée par boutons)

Le chenillard est l’un des effets lumineux les plus emblématiques en électronique. Il consiste à faire s’allumer les LEDs l’une après l’autre, créant un mouvement visuel fluide et dynamique.

Dans cette version, chaque bouton joue un rôle précis :

  • Il permet de choisir la vitesse de défilement du chenillard.
  • Plus le bouton choisi est “haut” (bouton 1 → bouton 8), plus le chenillard défile rapidement.
				
					const int buttonPins[8] = {22, 23, 24, 25, 26, 27, 28, 29};
const int ledPins[8]    = {30, 31, 32, 33, 34, 35, 36, 37};

// vitesses associées à chaque bouton (ms)
int speeds[8] = {
  400,  // bouton 1 : le plus lent
  300,  // bouton 2
  220,  // bouton 3
  160,  // bouton 4
  120,  // bouton 5
  80,   // bouton 6
  50,   // bouton 7
  25    // bouton 8 : le plus rapide
};

int speedDelay = 400;   // vitesse initiale
int indexLed = 0;
int direction = 1;

void setup() {
  for (int i = 0; i < 8; i++) {
    pinMode(buttonPins[i], INPUT);  // pull-down
    pinMode(ledPins[i], OUTPUT);
  }
}

void loop() {

  // --- Détection du bouton pressé ---
  for (int i = 0; i < 8; i++) {
    if (digitalRead(buttonPins[i]) == HIGH) {
      speedDelay = speeds[i];   // vitesse = bouton
    }
  }

  // --- Chenillard ---
  for (int i = 0; i < 8; i++)
    digitalWrite(ledPins[i], LOW);

  digitalWrite(ledPins[indexLed], HIGH);

  indexLed += direction;

  // changement de sens aux extrémités
  if (indexLed == 7 || indexLed == 0) {
    direction = -direction;
  }

  delay(speedDelay);
}

				
			

Simon Game (jeu de mémoire)

Le Simon Game est un grand classique des jeux électroniques de mémoire, popularisé depuis les années 80.

Le principe est simple :

  • Le système affiche une séquence lumineuse en allumant certaines LEDs, puis le joueur doit la reproduire en appuyant sur les boutons correspondants.
  • À chaque tour, la séquence s’allonge d’un élément, rendant le défi de plus en plus difficile. C’est un jeu idéal pour tester ses réflexes, sa mémoire visuelle et sa concentration.
				
					// ---------------------------------------
// SIMON GAME - Arduino Mega (8 LEDs + 8 boutons)
// ---------------------------------------

const int NB_BUTTONS = 8;

// Pins des boutons (pull-down)
const int buttonPins[NB_BUTTONS] = {22, 23, 24, 25, 26, 27, 28, 29};

// Pins des LEDs
const int ledPins[NB_BUTTONS] = {37, 36, 35, 34, 33, 32, 31, 30};

// Tableau contenant la séquence
int sequence[100];
int sequenceLength = 0;

bool waitRelease = false;

void setup() {

  // Initialisation entrées / sorties
  for (int i = 0; i < NB_BUTTONS; i++) {
    pinMode(buttonPins[i], INPUT);       // pull-down externe
    pinMode(ledPins[i], OUTPUT);
    digitalWrite(ledPins[i], LOW);
  }

  Serial.begin(9600);
  randomSeed(analogRead(A0)); // random vraiment aléatoire

  startNewGame();
}

void loop() {

  // 1) Montrer la séquence
  showSequence();

  // 2) Lire la réponse du joueur
  if (!playerTurn()) {
    // Échec -> animation de perte
    loseAnimation();
    delay(1000);
    startNewGame();
  }

  // 3) Succès → on ajoute un élément
  sequence[sequenceLength] = random(0, NB_BUTTONS);
  sequenceLength++;

  delay(700);
}


// ---------------------------------------
// Lancer un nouveau jeu
// ---------------------------------------
void startNewGame() {
  sequenceLength = 1;
  sequence[0] = random(0, NB_BUTTONS);
  Serial.println("Nouveau jeu !");
}


// ---------------------------------------
// Affiche la séquence complète
// ---------------------------------------
void showSequence() {

  delay(500);

  for (int i = 0; i < sequenceLength; i++) {
    int idx = sequence[i];

    // LED ON
    digitalWrite(ledPins[idx], HIGH);
    delay(500);

    // LED OFF
    digitalWrite(ledPins[idx], LOW);
    delay(200);
  }
}


// ---------------------------------------
// Tour du joueur - Retourne true si correct
// ---------------------------------------
bool playerTurn() {

  for (int i = 0; i < sequenceLength; i++) {

    int expected = sequence[i];
    int pressed = waitForButtonPress();

    if (pressed != expected) {
      return false; // joueur s'est trompé
    }
  }

  return true; // joueur a tout réussi
}


// ---------------------------------------
// Attend que le joueur appuie sur un bouton
// Retourne l’index du bouton
// ---------------------------------------
int waitForButtonPress() {

  while (true) {

    for (int i = 0; i < NB_BUTTONS; i++) {

      if (digitalRead(buttonPins[i]) == HIGH) {

        // Effet visuel : LED s'allume tant qu'on appuie
        digitalWrite(ledPins[i], HIGH);
        delay(100);
        digitalWrite(ledPins[i], LOW);

        // Anti-rebond / attente du relâchement
        while (digitalRead(buttonPins[i]) == HIGH);
        delay(100);

        return i;
      }
    }
  }
}


// ---------------------------------------
// Animation d'échec
// ---------------------------------------
void loseAnimation() {

  for (int n = 0; n < 3; n++) {
    for (int i = 0; i < NB_BUTTONS; i++)
      digitalWrite(ledPins[i], HIGH);
    delay(200);

    for (int i = 0; i < NB_BUTTONS; i++)
      digitalWrite(ledPins[i], LOW);
    delay(200);
  }
}

				
			

Dé électronique (1–6)

Le dé électronique réalisé avec votre carte LED + boutons est une excellente alternative aux dés physiques traditionnels pour les jeux de plateau ou de rôles (Monopoly, Risk, Cluedo, Donjon et Dragons, etc…)

Grâce à un simple appui sur un bouton, l’Arduino génère un nombre aléatoire entre 1 et 6 et l’affiche instantanément sous forme de LED allumées :

  • 1 LED pour le chiffre 1, 2 LEDs pour le chiffre 2… jusqu’à 6 LEDs pour le chiffre 6.
				
					const int buttonPin = 22; // bouton en pull-down

// 8 LEDs pour l'animation
const int ledPinsAnim[8] = {30, 31, 32, 33, 34, 35, 36, 37};

// 6 LEDs pour afficher le résultat du dé
const int ledPinsResult[6] = {37, 36, 35, 34, 33, 32};

bool lastButton = LOW;
int result = 1;

void setup() {
  pinMode(buttonPin, INPUT);

  for (int i = 0; i < 8; i++) {
    pinMode(ledPinsAnim[i], OUTPUT);
    digitalWrite(ledPinsAnim[i], LOW);
  }

  randomSeed(analogRead(A0));
}

void loop() {

  bool reading = digitalRead(buttonPin);

  if (reading == HIGH && lastButton == LOW) {

    // ---------------------------------------------------
    //    ANIMATION LONGUE SUR LES 8 LEDS
    // ---------------------------------------------------
    for (int cycle = 0; cycle < 3; cycle++) {  // 3 tours complets
      for (int i = 0; i < 8; i++) {

        // éteint tout
        for (int j = 0; j < 8; j++)
          digitalWrite(ledPinsAnim[j], LOW);

        // allume une LED à la fois
        digitalWrite(ledPinsAnim[i], HIGH);

        delay(90 - cycle * 20);  // accélère progressivement
      }
    }

    // ---------------------------------------------------
    //    RÉSULTAT FINAL (1 à 6) — sur les 6 PREMIÈRES LEDs
    // ---------------------------------------------------

    result = random(1, 7); // 1 à 6

    // éteint toutes les LEDs
    for (int i = 0; i < 8; i++)
      digitalWrite(ledPinsAnim[i], LOW);

    // allume *n* LEDS pour représenter la valeur du dé
    for (int i = 0; i < result; i++)
      digitalWrite(ledPinsResult[i], HIGH);

    delay(300); // anti-rebond
  }

  lastButton = reading;
}

				
			

Exploitez la carte LEDs & Boutons avec Arduino Mega 2560

Grâce à la carte LEDs et Boutons associée à une Arduino Mega 2560, nous avons exploré de nombreuses applications interactives : des plus simples (mode instantané, bascule) aux plus ludiques et avancées (chenillard, Simon Game, dé électronique). Ces exemples démontrent la polyvalence de la carte pour apprendre à manipuler les entrées/sorties, développer sa logique de programmation et créer des mini-jeux électroniques.

Mais ce n’est qu’un début ! Cette carte peut servir de base à de nombreux projets, par exemple :

  • Le jeu de la taupe (Whack-a-Mole) : appuyer rapidement sur les boutons dont les LEDs s’allument.
  • Des quiz ou QCM lumineux.
  • Des jeux de réflexes où le joueur doit réagir le plus vite possible.
  • Des animations lumineuses avancées : aller-retour, vagues, patterns aléatoires.
  • Des interfaces utilisateur simples : sélection de modes, menus, mini-tableaux de bord.
  • Des prototypes pédagogiques pour l’enseignement de l’électronique.

La carte LEDs + Boutons est donc un excellent support pour laisser libre cours à sa créativité : expérimenter, apprendre et imaginer de nouveaux jeux ou systèmes interactifs. Avec seulement quelques lignes de code, elle se transforme en console miniature, outil éducatif ou module d’animation.

Il ne vous reste plus qu’à continuer d’explorer, tester et inventer vos propres applications… Les possibilités sont quasiment infinies !

Bonjour ! 🌟 Rejoignez notre newsletter pour ne rien manquer.

Recevez nos offres spéciales et les derniers articles directement dans votre boîte de réception

Nous ne faisons pas de spam, promis ! Consultez notre politique de confidentialité pour en savoir plus.

Panier
Retour en haut