Memory game

Proiectul constă într-un joculeț de memorie care funcționează în felul următor: îți alegi modul de joc (easy/hard) prin apăsarea butonului corespunzător, iar o dată ce apeși pe unul din butoane, se va afișa o secvență de lumini, fiecare led având o culoare și un sunet diferit. Jucătorul va trebui să reproducă secvența apăsând pe butoanele corespunzătoare acestora, iar dacă nimerește trece la nivelul următor.

Ideea de la care am pornit este aceea de a crea un joc, ceva care să fie și distractiv, dar care este și util, având ca scop antrenarea memoriei.

Este un mod de a combina utilul cu plăcutul, trezind în jucător și un mic spirit de competitivitate, pentru a reuși să scoată un scor cât mai bun.

• Mediul de dezvoltare: Arduino IDE 2.3.2
• Librării folosite: Wire.h și LiquidCrystal_I2C.h pentru comunicarea I2C cu LCD display-ul.

• setup() și smallButtonISR(): aici inițializez toate LED-urile, butoanele, buzzer-ul, mesajul inițial de pe display, starea inițială a jocului și adaug o întrerupere pentru butonul de selectare a modului de joc (hard/normal). Aceasta modifică variabila volatilă hardModeChanged, folosind debouncing pentru că observasem că nu se selecta modul bine fără.

void smallButtonISR() {
  static unsigned long lastDebounceTime = 0;
  unsigned long debounceDelay = 100;

  if (millis() - lastDebounceTime > debounceDelay) {
    hardModeChanged = true;
    lastDebounceTime = millis();
  }
}

void setup() {
  pinMode(blueLED, OUTPUT);
  pinMode(yellowLED, OUTPUT);
  pinMode(redLED, OUTPUT);
  pinMode(greenLED, OUTPUT);
  pinMode(modeLED, OUTPUT);

  pinMode(blueButton, INPUT_PULLUP);
  pinMode(yellowButton, INPUT_PULLUP);
  pinMode(redButton, INPUT_PULLUP);
  pinMode(greenButton, INPUT_PULLUP);
  pinMode(smallButton, INPUT_PULLUP);

  pinMode(buzzerPin, OUTPUT);
  lcd.init();
  lcd.backlight();
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Memory Game!");
  lcd.setCursor(0, 1);
  lcd.print("Highest Score ");
  lcd.print(highestScore);

  randomSeed(analogRead(0));
  gameState = WAIT_FOR_START;
  attachInterrupt(digitalPinToInterrupt(smallButton), smallButtonISR, FALLING);
}

• WAIT_FOR_START: verifică 2 cazuri, dacă s-a produs o întrerupere cauzată de butonul de schimbare a jocului, sau dacă unul din celelalte butoane s-a apăsat, caz în care starea jocului devine GENERATE_SEQUENCE
• GENERATE_SEQUENCE: adaugă noul LED generat random la secvența curentă.

void generateSequence() {
  sequence[currentLevel] = random(0, 4);
  sequenceIndex = 0;
  gameState = hardMode ? HARD_DISPLAY_SEQUENCE : DISPLAY_SEQUENCE;
}

• DISPLAY_SEQUENCE/HARD_DISPLAY_SEQUENCE: ambele vor apela aceeași funcție, însă cu valoarea parametrului diferită. În funcție de modul de joc, luminozitatea și viteza cu care LED-urile sunt afișate se vor schimba, LED-urile luminându-se treptat cu PWM.

void fadeLED(int ledPin, int startBrightness, int endBrightness, int duration) {
  int stepDelay = duration / abs(endBrightness - startBrightness);
  for (int brightness = startBrightness; brightness != endBrightness; brightness += (startBrightness < endBrightness ? 1 : -1)) {
    analogWrite(ledPin, brightness);
    delay(stepDelay);
  }
  analogWrite(ledPin, endBrightness);
}

void displaySequence(bool hard) {
  int leds[] = {blueLED, yellowLED, redLED, greenLED};
  int brightness = hard ? max(255 - 30 * currentLevel, 0) : 255; // Adjust brightness for hard mode
  unsigned long currentMillis = millis();
  
  int basePauseDuration = 600;
  int minPauseDuration = 400;
  int pauseDuration = hard ? max(basePauseDuration - 20 * currentLevel, minPauseDuration) : basePauseDuration;

  if (displayState == 0 && currentMillis - lastMillis >= pauseDuration) {
    lastMillis = currentMillis;
    fadeLED(leds[sequence[sequenceIndex]], 0, brightness, 300);
    tone(buzzerPin, 1000 + (leds[sequence[sequenceIndex]] * 200), 300);
    displayState = 1;
  } else if (displayState == 1 && currentMillis - lastMillis >= 300) {
    lastMillis = currentMillis;
    fadeLED(leds[sequence[sequenceIndex]], brightness, 0, 300);
    sequenceIndex++;
    displayState = 0;
    if (sequenceIndex > currentLevel) {
      gameState = WAIT_FOR_BUTTON_PRESS;
      buttonPressIndex = 0;
    }
  }
}

• GAME_OVER: toate LED-urile se aprind și se va auzi un sunet produs de buzzer, display-ul afișeaza mesajul ”Game over!” și modul de joc revine la WAIT_FOR_START.
• LEVEL_UP: se mărește variabila currentLevel de fiecare dată când jucătorul ghicește ordinea corectă pentru acel nivel.

Laboratoare folosite:

1. Întreruperi, timere: https://ocw.cs.pub.ro/courses/pm/lab/lab2-2023
2. PWM, timere: https://ocw.cs.pub.ro/courses/pm/lab/lab3-2023-2024
3. I2C: https://ocw.cs.pub.ro/courses/pm/lab/lab6-2023-2024

A fost un proiect interesant, mereu am vrut să încerc să lucrez cu o plăcuță Arduino și mă bucur că am avut ocazia. Jocul chiar a ieșit drăguț după părerea mea. Unele din dificultățile pe care le-am întâmpinat au fost să îmi dau seama cum să fac butoanele să funcționeze, pentru că inițial nu se detecta nimic când se apăsau, sau cum să integrez laboratorul cu întreruperi. În final, am reușit să trec și peste ele și consider că a fost o experiență mișto.

Resurse Software:

• https://www.arduino.cc/reference/en/language/functions/external-interrupts/attachinterrupt/
• https://www.arduino.cc/reference/en/libraries/liquidcrystal-i2c/
• etc.

Resurse Hardware:

• http://cleste.ro
• http://optimusdigital.ro

Export to PDF