/* * SEQUENCE — Simon-Says Memory Game with Heat Mode * Hack Club Breadboard submission * * HARDWARE: * - 4x LEDs (D2, D3, D4, D5, each through a 220ohm resistor) * - 4x pushbuttons (D6, D7, D8, D9, INPUT_PULLUP, one per LED) * - 16x2 I2C LCD (SDA=A4, SCL=A5) * - Passive buzzer (D10, plays a distinct musical note per button) * - DHT11 temperature/humidity sensor (D11) * * BEHAVIOR: * - The DHT11 is polled continuously every 2 seconds in the background * and the latest valid reading is cached. * - NOTE: this simulator's DHT11 emulation reports exactly half the real * temperature, so DHT_SIM_CALIBRATION doubles the raw reading before * use. Set this to 1.0 on real hardware, where no such correction is * needed. * - The LCD always shows the live temperature in the top-right corner * and the current difficulty mode (Heat/Normal) in the bottom-right * corner, regardless of what other status text is on screen. * - When a new game starts, the cached DHT11 reading decides Heat Mode: * at/above the threshold -> LEDs flash shorter, genuinely harder to * follow. Below it -> normal speed. * - Correct round -> sequence grows by one step and plays back faster. * - Wrong button, or no input within the timeout -> game over, score shown. * - High score is stored in EEPROM per mode (Normal / Heat), so it * survives power loss. * * Libraries needed (Arduino Library Manager): * - LiquidCrystal_I2C * - Adafruit Unified Sensor * - DHT sensor library by Adafruit * - EEPROM (built-in) */ #include #include #include #include #include // ---------- Pin map ---------- const int LED_PINS[4] = {2, 3, 4, 5}; const int BUTTON_PINS[4] = {6, 7, 8, 9}; #define BUZZER_PIN 10 #define DHT_PIN 11 // ---------- Musical notes per button (classic Simon-style) ---------- const int NOTE_FREQ[4] = {262, 330, 392, 494}; // C4, E4, G4, B4 // ---------- Heat Mode threshold ---------- const float HEAT_MODE_THRESHOLD_C = 27.0; // room reads at/above this -> Heat Mode // ---------- Simulator calibration ---------- // This simulator's DHT11 reports exactly half the real value. Set to 1.0 // on real hardware, where this correction is not needed. const float DHT_SIM_CALIBRATION = 2.0; // ---------- Objects ---------- LiquidCrystal_I2C lcd(0x27, 16, 2); // change to 0x3F if your backpack uses that address DHT dht(DHT_PIN, DHT11); // ---------- State machine ---------- enum State { IDLE, SHOW_SEQUENCE, WAIT_INPUT, CORRECT_PAUSE, GAME_OVER, NEW_HIGH_SCORE }; State state = IDLE; // ---------- Game data ---------- const int MAX_LEVEL = 32; int sequence[MAX_LEVEL]; int currentLevel = 0; int inputIndex = 0; const int EEPROM_HIGH_SCORE_NORMAL_ADDR = 0; const int EEPROM_HIGH_SCORE_HEAT_ADDR = sizeof(int); int highScoreNormal = 0; int highScoreHeat = 0; bool heatModeThisGame = false; // ---------- Continuous DHT11 polling ---------- unsigned long previousDHT = 0; const unsigned long DHT_POLL_INTERVAL_MS = 2000; float lastReadTemp = NAN; float lastReadHumidity = NAN; // ---------- Sequence playback (non-blocking) ---------- int playbackIndex = 0; bool ledOnPhase = true; unsigned long stepStartTime = 0; // ---------- Button feedback flash (non-blocking) ---------- int feedbackLed = -1; unsigned long feedbackStart = 0; const unsigned long FEEDBACK_DURATION_MS = 300; // ---------- Input timeout ---------- unsigned long lastInputAt = 0; const unsigned long INPUT_TIMEOUT_MS = 5000; // ---------- Debounce (edge-triggered, release-based) ---------- bool lastRawState[4] = {HIGH, HIGH, HIGH, HIGH}; bool stableState[4] = {HIGH, HIGH, HIGH, HIGH}; bool armed[4] = {false, false, false, false}; unsigned long lastChangeTime[4] = {0, 0, 0, 0}; const unsigned long DEBOUNCE_MS = 40; // ---------- Misc timing ---------- unsigned long stateEnteredAt = 0; void setup() { Serial.begin(9600); for (int i = 0; i < 4; i++) { pinMode(LED_PINS[i], OUTPUT); pinMode(BUTTON_PINS[i], INPUT_PULLUP); digitalWrite(LED_PINS[i], LOW); } pinMode(BUZZER_PIN, OUTPUT); dht.begin(); Wire.begin(); lcd.init(); lcd.backlight(); EEPROM.get(EEPROM_HIGH_SCORE_NORMAL_ADDR, highScoreNormal); EEPROM.get(EEPROM_HIGH_SCORE_HEAT_ADDR, highScoreHeat); if (highScoreNormal < 0 || highScoreNormal > MAX_LEVEL) highScoreNormal = 0; if (highScoreHeat < 0 || highScoreHeat > MAX_LEVEL) highScoreHeat = 0; randomSeed(analogRead(A0)); showIdleScreen(); } void loop() { unsigned long now = millis(); pollDHT(now); updateFeedbackFlash(now); drawTempCorner(); drawDifficultyCorner(); switch (state) { case IDLE: handleIdle(); break; case SHOW_SEQUENCE: handleShowSequence(now); break; case WAIT_INPUT: handleWaitInput(now); break; case CORRECT_PAUSE: handleCorrectPause(now); break; case GAME_OVER: handleGameOver(now); break; case NEW_HIGH_SCORE: handleNewHighScore(now); break; } } // ---------------- Continuous DHT11 polling ---------------- void pollDHT(unsigned long now) { if (now - previousDHT < DHT_POLL_INTERVAL_MS) return; previousDHT = now; float temp = dht.readTemperature(); float hum = dht.readHumidity(); if (isnan(temp) || isnan(hum)) { Serial.println("DHT read failed this cycle (keeping last known value)"); return; } lastReadTemp = temp * DHT_SIM_CALIBRATION; lastReadHumidity = hum; Serial.print("Temp: "); Serial.print(lastReadTemp); Serial.print(" C, Humidity: "); Serial.print(lastReadHumidity); Serial.println(" %"); } // ---------------- Persistent LCD corners ---------------- void drawTempCorner() { lcd.setCursor(11, 0); if (isnan(lastReadTemp)) { lcd.print(" --C "); } else { char buf[6]; dtostrf(lastReadTemp, 4, 1, buf); // e.g. "24.5", always 4 chars wide lcd.print(buf); lcd.print("C"); } } void drawDifficultyCorner() { lcd.setCursor(11, 1); bool inHeatRange = !isnan(lastReadTemp) && (lastReadTemp >= HEAT_MODE_THRESHOLD_C); lcd.print(inHeatRange ? "Heat " : "Norml"); } // ---------------- State handlers ---------------- void handleIdle() { for (int i = 0; i < 4; i++) { if (buttonPressed(i)) { startNewGame(); return; } } } void handleShowSequence(unsigned long now) { if (playbackIndex >= currentLevel) { inputIndex = 0; lastInputAt = now; changeState(WAIT_INPUT); return; } unsigned long onDuration = playbackSpeed(); unsigned long gapDuration = onDuration / 2; if (ledOnPhase) { digitalWrite(LED_PINS[sequence[playbackIndex]], HIGH); tone(BUZZER_PIN, NOTE_FREQ[sequence[playbackIndex]]); if (now - stepStartTime >= onDuration) { digitalWrite(LED_PINS[sequence[playbackIndex]], LOW); noTone(BUZZER_PIN); ledOnPhase = false; stepStartTime = now; } } else { if (now - stepStartTime >= gapDuration) { playbackIndex++; ledOnPhase = true; stepStartTime = now; } } } void handleWaitInput(unsigned long now) { if (now - lastInputAt > INPUT_TIMEOUT_MS) { endGame(); return; } for (int i = 0; i < 4; i++) { if (buttonPressed(i)) { lastInputAt = now; flashFeedback(i, now); if (i == sequence[inputIndex]) { inputIndex++; if (inputIndex >= currentLevel) { changeState(CORRECT_PAUSE); } } else { endGame(); } return; } } } void handleCorrectPause(unsigned long now) { if (now - stateEnteredAt > 500) { addRandomStep(); playbackIndex = 0; ledOnPhase = true; stepStartTime = now; changeState(SHOW_SEQUENCE); } } void handleGameOver(unsigned long now) { if (now - stateEnteredAt > 3000) { int score = currentLevel - 1; int *highScore = heatModeThisGame ? &highScoreHeat : &highScoreNormal; if (score > *highScore) { *highScore = score; int addr = heatModeThisGame ? EEPROM_HIGH_SCORE_HEAT_ADDR : EEPROM_HIGH_SCORE_NORMAL_ADDR; EEPROM.put(addr, *highScore); changeState(NEW_HIGH_SCORE); } else { changeState(IDLE); } } } void handleNewHighScore(unsigned long now) { if (now - stateEnteredAt > 3000) { changeState(IDLE); } } // ---------------- Game logic helpers ---------------- void startNewGame() { heatModeThisGame = !isnan(lastReadTemp) && (lastReadTemp >= HEAT_MODE_THRESHOLD_C); Serial.print("Starting game. Cached temp: "); Serial.print(isnan(lastReadTemp) ? -999 : lastReadTemp); Serial.print(" C, Heat Mode: "); Serial.println(heatModeThisGame ? "ON" : "off"); currentLevel = 0; addRandomStep(); playbackIndex = 0; ledOnPhase = true; stepStartTime = millis(); changeState(SHOW_SEQUENCE); } void addRandomStep() { if (currentLevel < MAX_LEVEL) { sequence[currentLevel] = random(0, 4); currentLevel++; } } void endGame() { changeState(GAME_OVER); } unsigned long playbackSpeed() { long speed = 1200 - (currentLevel * 15); long floorSpeed = heatModeThisGame ? 350 : 500; if (heatModeThisGame) { speed = (long)(speed * 0.7); } if (speed < floorSpeed) speed = floorSpeed; return (unsigned long)speed; } // ---------------- Input helpers ---------------- bool buttonPressed(int i) { unsigned long now = millis(); bool raw = digitalRead(BUTTON_PINS[i]); if (raw != lastRawState[i]) { lastChangeTime[i] = now; lastRawState[i] = raw; } if ((now - lastChangeTime[i]) > DEBOUNCE_MS && raw != stableState[i]) { stableState[i] = raw; if (stableState[i] == LOW) { armed[i] = true; } else if (armed[i]) { armed[i] = false; return true; } } return false; } void flashFeedback(int i, unsigned long now) { digitalWrite(LED_PINS[i], HIGH); tone(BUZZER_PIN, NOTE_FREQ[i], FEEDBACK_DURATION_MS); feedbackLed = i; feedbackStart = now; } void updateFeedbackFlash(unsigned long now) { if (feedbackLed != -1 && (now - feedbackStart) >= FEEDBACK_DURATION_MS) { digitalWrite(LED_PINS[feedbackLed], LOW); feedbackLed = -1; } } // ---------------- Display ---------------- void changeState(State newState) { state = newState; stateEnteredAt = millis(); switch (newState) { case IDLE: showIdleScreen(); break; case SHOW_SEQUENCE: lcd.clear(); lcd.setCursor(0, 0); lcd.print("Watch... "); lcd.setCursor(0, 1); lcd.print("Lv:"); lcd.print(currentLevel); lcd.print(" "); break; case WAIT_INPUT: lcd.clear(); lcd.setCursor(0, 0); lcd.print("Your turn! "); lcd.setCursor(0, 1); lcd.print("Lv:"); lcd.print(currentLevel); lcd.print(" "); break; case CORRECT_PAUSE: lcd.clear(); lcd.setCursor(0, 0); lcd.print("Correct! "); break; case GAME_OVER: lcd.clear(); lcd.setCursor(0, 0); lcd.print("Game Over! "); lcd.setCursor(0, 1); lcd.print("Scr:"); lcd.print(currentLevel - 1); lcd.print(" "); failBuzz(); break; case NEW_HIGH_SCORE: lcd.clear(); lcd.setCursor(0, 0); lcd.print(heatModeThisGame ? "HEAT BEST! " : "NEW BEST! "); lcd.setCursor(0, 1); lcd.print(heatModeThisGame ? highScoreHeat : highScoreNormal); lcd.print(" "); winFanfare(); break; } } void showIdleScreen() { lcd.clear(); lcd.setCursor(0, 0); lcd.print("Press button"); lcd.setCursor(0, 1); bool inHeatRange = !isnan(lastReadTemp) && (lastReadTemp >= HEAT_MODE_THRESHOLD_C); if (inHeatRange) { lcd.print("H:"); lcd.print(highScoreHeat); } else { lcd.print("N:"); lcd.print(highScoreNormal); } lcd.print(" "); } // ---------------- Sound effects ---------------- void failBuzz() { tone(BUZZER_PIN, 150, 600); } void winFanfare() { tone(BUZZER_PIN, 523, 150); delay(150); tone(BUZZER_PIN, 659, 150); delay(150); tone(BUZZER_PIN, 784, 300); delay(300); }