Construisez un jeu Simon Says avec Arduino sur Velxio

Introduction

Vous vous souvenez du jeu classique Simon Says ? C’est le projet parfait pour apprendre les tableaux, les machines d’état et la gestion des entrées utilisateur sur Arduino. Dans ce tutoriel, nous allons construire un jeu Simon Says entièrement fonctionnel utilisant quatre LEDs et quatre boutons poussoirs, le tout simulé directement dans votre navigateur avec Velxio. Aucun matériel nécessaire !

Présentation du circuit

Examinons les composants et leurs connexions.

Composants

Câblage

L’anode (A) de chaque LED est connectée à une broche numérique de l’Arduino, et sa cathode (C) va à GND via une résistance de limitation de courant (simulée en interne). Les boutons sont câblés avec une patte (1.l) sur une broche numérique et l’autre patte (2.l) sur GND, en utilisant les résistances de tirage internes de l’Arduino.

• LED Rouge : Broche 8 (fil rouge) à l’anode, cathode à GND (fil noir).
• LED Verte : Broche 9 (fil vert) à l’anode, cathode à GND.
• LED Bleue : Broche 10 (fil bleu) à l’anode, cathode à GND.
• LED Jaune : Broche 11 (fil jaune) à l’anode, cathode à GND.
• Bouton Rouge : Broche 2 (fil bleu clair) à 1.l, 2.l à GND.
• Bouton Vert : Broche 3 (fil bleu clair) à 1.l, 2.l à GND.
• Bouton Bleu : Broche 4 (fil bleu clair) à 1.l, 2.l à GND.
• Bouton Jaune : Broche 5 (fil bleu clair) à 1.l, 2.l à GND.

Toutes les connexions de masse partagent la broche GND de l’Arduino.

Présentation du code

Ouvrez l’éditeur de code dans Velxio pour voir le sketch complet.

Constantes et variables

const int LED_PINS[] = {8, 9, 10, 11};
const int BUTTON_PINS[] = {2, 3, 4, 5};
const int NUM_LEDS = 4;

int sequence[100];
int sequenceLength = 0;
int currentStep = 0;

Nous définissons des tableaux pour les broches des LEDs et des boutons, correspondant au câblage. sequence stocke le motif aléatoire (jusqu’à 100 étapes). sequenceLength suit le nombre d’étapes que le joueur doit répéter, et currentStep suit la progression du joueur.

Configuration

void setup() {
  Serial.begin(9600);

  for (int i = 0; i < NUM_LEDS; i++) {
    pinMode(LED_PINS[i], OUTPUT);
    pinMode(BUTTON_PINS[i], INPUT_PULLUP);
  }

  randomSeed(millis());
  newGame();
}

Nous configurons les broches des LEDs en sorties et les broches des boutons en entrées avec résistances de tirage internes (les boutons lisent LOW lorsqu’ils sont pressés). randomSeed(millis()) garantit une séquence différente à chaque partie. newGame() démarre le premier tour.

Logique du jeu

newGame() réinitialise la longueur de la séquence à 1, ajoute une étape aléatoire et joue la séquence.

void newGame() {
  sequenceLength = 1;
  currentStep = 0;
  addToSequence();
  playSequence();
}

void addToSequence() {
  sequence[sequenceLength - 1] = random(0, NUM_LEDS);
}

void playSequence() {
  for (int i = 0; i < sequenceLength; i++) {
    flashLED(sequence[i]);
    delay(500);
  }
}

void flashLED(int led) {
  digitalWrite(LED_PINS[led], HIGH);
  delay(300);
  digitalWrite(LED_PINS[led], LOW);
}

playSequence() parcourt la séquence stockée, en faisant clignoter chaque LED pendant 300ms avec un intervalle de 500ms.

Boucle principale

void loop() {
  for (int i = 0; i < NUM_LEDS; i++) {
    if (digitalRead(BUTTON_PINS[i]) == LOW) {
      flashLED(i);

      if (i == sequence[currentStep]) {
        currentStep++;
        if (currentStep == sequenceLength) {
          delay(1000);
          sequenceLength++;
          currentStep = 0;
          addToSequence();
          playSequence();
        }
      } else {
        // Mauvais bouton - fin de partie
        for (int j = 0; j < 3; j++) {
          for (int k = 0; k < NUM_LEDS; k++) {
            digitalWrite(LED_PINS[k], HIGH);
          }
          delay(200);
          for (int k = 0; k < NUM_LEDS; k++) {
            digitalWrite(LED_PINS[k], LOW);
          }
          delay(200);
        }
        newGame();
      }

      delay(300);
      while (digitalRead(BUTTON_PINS[i]) == LOW);
    }
  }
}

La boucle vérifie en continu tous les boutons. Lorsqu’un bouton est pressé (LOW), elle fait clignoter la LED correspondante. Si le bouton pressé correspond à l’étape attendue (sequence[currentStep]), nous avançons. Si le joueur termine la séquence, nous ajoutons une nouvelle étape et jouons la séquence plus longue. En cas d’erreur, toutes les LEDs clignotent trois fois et une nouvelle partie commence.

Concepts clés

• Tableaux : L’utilisation de tableaux pour stocker les numéros de broches et la séquence de jeu rend le code évolutif et propre.
• Résistances de tirage internes : INPUT_PULLUP élimine le besoin de résistances externes ; les boutons lisent LOW lorsqu’ils sont pressés.
• Anti-rebond : Le delay(300) et la boucle while(digitalRead(...)==LOW) fournissent un anti-rebond simple.
• Aléatoire : randomSeed(millis()) et random() génèrent des séquences imprévisibles.
• Machine d’état : Le jeu suit currentStep et sequenceLength pour gérer la progression.

Pièges courants et conseils de débogage

• Les boutons ne répondent pas ? Vérifiez que les broches des boutons sont configurées en INPUT_PULLUP et câblées correctement (1.l à la broche, 2.l à GND).
• Les LEDs ne s’allument pas ? Vérifiez que les broches des LEDs sont en OUTPUT et que les connexions anode/cathode sont correctes.
• Séquence trop rapide ? Ajustez les valeurs delay() dans flashLED() et playSequence().
• La partie se réinitialise de manière inattendue ? Assurez-vous que randomSeed(millis()) n’est appelé qu’une seule fois dans setup().
• Utilisez le moniteur série : Ajoutez des instructions Serial.println() pour déboguer les valeurs de la séquence.

Extensions suggérées

• Ajoutez un buzzer : Jouez une tonalité pour chaque couleur de LED.
• Niveaux de difficulté : Augmentez la vitesse à mesure que la séquence s’allonge.
• Meilleur score : Suivez la séquence la plus longue réalisée.
• Multijoueur : Alternez les tours entre deux joueurs.
• Retour visuel : Utilisez différentes luminosités ou motifs de LEDs.

Essayez par vous-même !

Prêt à jouer ? Ouvrez l’exemple en direct sur Velxio et démarrez la simulation. Appuyez sur les boutons pour répéter la séquence. Jusqu’où pouvez-vous aller ?

Lancer Simon Says sur Velxio

Bon montage !