Build Instructions

Collapse

• 1

  Code for our game

  #include <LiquidCrystal_I2C.h>
  
  // Définition de l'adresse I2C de l'écran LCD
  LiquidCrystal_I2C lcd(0x27, 20, 4);
  
  unsigned long previousMillis = 0;  // Stocke le dernier moment où l'écran a été mis à jour
  unsigned long interval = 1000;     // Intervalle de mise à jour du timer (1 seconde)
  int timer = 30;                   // Timer commençant à 100 secondes
  
  // Variables de jeu
  const int ledBlue1 = 2;
  const int ledBlue2 = 3;
  const int ledRed1 = 4;
  const int ledRed2 = 5;
  const int ledYellow1 = 6;
  const int ledYellow2 = 7;
  
  const int buttonBlue = 8;
  const int buttonRed = 9;
  const int buttonYellow = 10;
  
  const int buttonSpecialYellow1 = 11;
  const int buttonSpecialYellow2 = 12;
  const int buttonSpecialBlue = 13;
  
  const int potPin = A0;  // Pin pour le potentiomètre
  
  int currentLed1, currentLed2;
  int prevPotValue, potValue;  // Valeur précédente du potentiomètre
  int potThreshold = 50;  // Seuil pour une rotation significative du potentiomètre
  
  // Variables de score
  int score = 0;  // Score initial
  unsigned long lastResponseTime = 0; // Temps de réponse pour le calcul du score
  
  void setup() {
    lcd.init();              // Initialisation de l'écran LCD
    lcd.clear();             // Effacer l'écran
    lcd.backlight();         // Allumer le rétroéclairage
  
    lcd.setCursor(0, 0);     // Définir le curseur à la première ligne
    lcd.print("Time: ");     // Afficher le texte "Time:"
      lcd.setCursor(0, 3);     // Définir le curseur pour afficher le score
    lcd.print("Score: 0");
  
    pinMode(ledBlue1, OUTPUT);
    pinMode(ledBlue2, OUTPUT);
    pinMode(ledRed1, OUTPUT);
    pinMode(ledRed2, OUTPUT);
    pinMode(ledYellow1, OUTPUT);
    pinMode(ledYellow2, OUTPUT);
  
    pinMode(buttonBlue, INPUT_PULLUP);
    pinMode(buttonRed, INPUT_PULLUP);
    pinMode(buttonYellow, INPUT_PULLUP);
    pinMode(buttonSpecialYellow1, INPUT_PULLUP);
    pinMode(buttonSpecialYellow2, INPUT_PULLUP);
    pinMode(buttonSpecialBlue, INPUT_PULLUP);
  
    randomSeed(analogRead(0));
    newRound();
    Serial.begin(9600);  // Dans setup()
  }
  
  bool anyOtherAction(int correctButton1 = -1, int correctButton2 = -1) {
    return (digitalRead(buttonBlue) == LOW && buttonBlue != correctButton1 && buttonBlue != correctButton2) ||
           (digitalRead(buttonRed) == LOW && buttonRed != correctButton1 && buttonRed != correctButton2) ||
           (digitalRead(buttonYellow) == LOW && buttonYellow != correctButton1 && buttonYellow != correctButton2) ||
           (digitalRead(buttonSpecialYellow1) == LOW && buttonSpecialYellow1 != correctButton1 && buttonSpecialYellow1 != correctButton2) ||
           (digitalRead(buttonSpecialYellow2) == LOW && buttonSpecialYellow2 != correctButton1 && buttonSpecialYellow2 != correctButton2) ||
           (digitalRead(buttonSpecialBlue) == LOW && buttonSpecialBlue != correctButton1 && buttonSpecialBlue != correctButton2);
  }
  
  void loop() {
    if (timer <= 0) {
      // Afficher le score final
      lcd.clear();
      lcd.setCursor(0, 1);
      lcd.print("Final Score: ");
      lcd.print(score);
      delay(10000); // Attendre 10 secondes
  
      // Réinitialiser le jeu
      resetGame();
      return;
    }
  
    unsigned long currentMillis = millis();  // Obtenir le temps écoulé depuis le démarrage de l'Arduino
  
    // Vérifier si une seconde s'est écoulée
    if (currentMillis - previousMillis >= interval) {
      previousMillis = currentMillis;  // Sauvegarder le temps actuel
      timer--;  // Décrémenter le timer
  
      // Effacer l'ancienne valeur du timer sur l'écran
      lcd.setCursor(6, 0);  // Se positionner à la position après "Time: "
      lcd.print("    ");     // Effacer l'affichage précédent (espaces pour effacer)
  
      // Afficher le timer actuel
      lcd.setCursor(6, 0);
      lcd.print(timer);    // Afficher le nombre de secondes restantes
    }
  
    prevPotValue = potValue;
    delay(100);
    potValue = analogRead(potPin);
    int potChange = abs(potValue - prevPotValue);  // Calculer l'écart de rotation du potentiomètre
    Serial.println(potChange);  // Dans loop()
  
    if (isDoubleYellow()) {
      if (digitalRead(buttonSpecialYellow1) == LOW && digitalRead(buttonSpecialYellow2) == LOW) {
        correctAnswer();
      } else if (anyOtherAction(buttonSpecialYellow1, buttonSpecialYellow2) || potChange > potThreshold) {
        wrongAnswer();
      }
    } else if (isDoubleBlue()) {
      if (digitalRead(buttonSpecialBlue) == LOW) {
        correctAnswer();
      } else if (anyOtherAction(buttonSpecialBlue) || potChange > potThreshold) {
        wrongAnswer();
      }
    } else if (isDoubleRed()) {
      // Si le potentiomètre a changé de façon significative (écart > 50), c'est une réponse correcte
      if (potChange > 100) {
        correctAnswer();
      } else if (anyOtherAction()) {
        wrongAnswer();
      }
    } else {
      checkRegularButtons();
      if (potChange > 100) {
        wrongAnswer();
      }
    }
  
     // Mettre à jour la valeur précédente du potentiomètre
  }
  
  void newRound() {
    turnOffAllLeds();
  
    int line1Leds[] = {ledBlue1, ledRed1, ledYellow1};
    currentLed1 = line1Leds[random(0, 3)];
  
    int line2Leds[] = {ledBlue2, ledRed2, ledYellow2};
    currentLed2 = line2Leds[random(0, 3)];
  
    digitalWrite(currentLed1, HIGH);
    digitalWrite(currentLed2, HIGH);
    lastResponseTime = millis();  // Réinitialiser le temps de réponse
  }
  
  void checkRegularButtons() {
    int correctButton = determineCorrectButton();
  
    if (digitalRead(correctButton) == LOW) {
      correctAnswer();
    } else if (anyOtherAction(correctButton)) {
      wrongAnswer();
    }
  }
  
  int determineCorrectButton() {
    if ((isRedLed(currentLed1) && isYellowLed(currentLed2)) ||       (isYellowLed(currentLed1) && isRedLed(currentLed2))) {
      return buttonBlue;
    }
    if ((isBlueLed(currentLed1) && isYellowLed(currentLed2)) ||       (isYellowLed(currentLed1) && isBlueLed(currentLed2))) {
      return buttonRed;
    }
    if ((isBlueLed(currentLed1) && isRedLed(currentLed2)) ||       (isRedLed(currentLed1) && isBlueLed(currentLed2))) {
      return buttonYellow;
    }
    if (isBlueLed(currentLed1) || isBlueLed(currentLed2)) {
      return buttonBlue;
    }
    if (isRedLed(currentLed1) || isRedLed(currentLed2)) {
      return buttonRed;
    }
    return buttonYellow;
  }
  
  bool isDoubleBlue() {
    return isBlueLed(currentLed1) && isBlueLed(currentLed2);
  }
  
  bool isDoubleRed() {
    return isRedLed(currentLed1) && isRedLed(currentLed2);
  }
  
  bool isDoubleYellow() {
    return isYellowLed(currentLed1) && isYellowLed(currentLed2);
  }
  
  bool isBlueLed(int led) {
    return (led == ledBlue1 || led == ledBlue2);
  }
  
  bool isRedLed(int led) {
    return (led == ledRed1 || led == ledRed2);
  }
  
  bool isYellowLed(int led) {
    return (led == ledYellow1 || led == ledYellow2);
  }
  
  void correctAnswer() {
    unsigned long reactionTime = millis() - lastResponseTime;  // Calcul du temps de réaction
    int points = 333 - reactionTime / 10;  // Réduction : 10 ms = -1 point, maximum 300 points
    points = max(0, points);  // Assurer que le score ne tombe pas en dessous de 0
  
    score += points;
  
    blinkAllLeds(5);  // Clignotement des LEDs pour signaler une réponse correcte
    newRound();       // Commencer un nouveau tour
    updateScore();    // Mettre à jour l'affichage du score
  }
  
  void wrongAnswer() {
    turnOnAllLeds();
    delay(2000);
    newRound();
  }
  
  void turnOffAllLeds() {
    digitalWrite(ledBlue1, LOW);
    digitalWrite(ledBlue2, LOW);
    digitalWrite(ledRed1, LOW);
    digitalWrite(ledRed2, LOW);
    digitalWrite(ledYellow1, LOW);
    digitalWrite(ledYellow2, LOW);
  }
  
  void turnOnAllLeds() {
    digitalWrite(ledBlue1, HIGH);
    digitalWrite(ledBlue2, HIGH);
    digitalWrite(ledRed1, HIGH);
    digitalWrite(ledRed2, HIGH);
    digitalWrite(ledYellow1, HIGH);
    digitalWrite(ledYellow2, HIGH);
  }
  
  void blinkAllLeds(int times) {
    for (int i = 0; i < times; i++) {
      turnOffAllLeds();
      delay(200);
      turnOnAllLeds();
      delay(200);
    }
  }
  
  void updateScore() {
    lcd.setCursor(7, 3);  // Se positionner sur la ligne 4 (index 3)
    lcd.print("    ");     // Effacer l'affichage précédent
    lcd.setCursor(7, 3);  // Repositionner le curseur
    lcd.print(score);      // Afficher le score actuel
  }
  
  void resetGame() {
    timer = 30;  // Réinitialiser le timer
    score = 0;    // Réinitialiser le score
    lcd.clear();  // Effacer l'écran
    lcd.setCursor(0, 0);
    lcd.print("Time: 30");  // Réafficher le timer initial
    lcd.setCursor(0, 3);
    lcd.print("Score: 0");  // Réinitialiser l'affichage du score
    newRound();   // Recommencer un nouveau tour
  }

• 2

  Step 2

View all instructions