Sequence Master

reflex game where players repeat flashing LED sequences to score points and beat high scores.

Dec 17, 2025

•

509 views

•

0 respects

•

GPL3+

Games

Lights

Kids

Devices & Components

40 colored male-male jumper wires

5mm Blue LED

Monochrome 1.3" 128x64 OLED graphic display

Mini breadboard - White

Push Button de 4 pines

Red LEDs 5mm

5mm Yellow LED

5mm Green LED

Grove - Buzzer - Piezo

Software & Tools

Thinkercad Circuits

Arduino IDE

Project description

Code

SequenceMaster.ino

Source Code

1#include <EEPROM.h>
2#include <Wire.h>
3#include <Adafruit_GFX.h>
4#include <Adafruit_SSD1306.h>
5#include "pitches.h"
6
7#define SCREEN_WIDTH 128
8#define SCREEN_HEIGHT 64
9#define SCREEN_I2C_ADDR 0x3C
10
11#define NUM_BUTTONS 4
12#define BUZZER 12
13#define MAX_GAME_LENGTH 10
14
15const uint8_t gameLEDs[NUM_BUTTONS] = { 2, 3, 4, 5 };
16const uint8_t gameButtons[NUM_BUTTONS] = { 8, 9, 10, 11 };
17const uint8_t gameStart = 7;
18
19const int gameTones[NUM_BUTTONS] = {
20  NOTE_G3, NOTE_C4, NOTE_E4, NOTE_G5
21};
22
23Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
24
25uint8_t gameSequence[MAX_GAME_LENGTH];
26uint8_t currentLevel = 1;
27uint16_t currentScore = 0;
28uint16_t highScore = 0;
29
30const uint16_t EEPROM_MAGIC = 0xABCD;
31const int ADDR_MAGIC = 0;
32const int ADDR_HIGHSCORE = 2;
33
34char textBuffer[24];
35
36uint8_t bounceIndex = 0;
37int8_t bounceDir = 1;
38uint32_t previousMillis = 0;
39const uint16_t bounceInterval = 100;
40
41bool startScreenShown = false;
42
43void drawText(const char* text, uint8_t size, int16_t x, int16_t y, bool clear) {
44  if (clear) display.clearDisplay();
45  display.setTextSize(size);
46  display.setTextColor(SSD1306_WHITE);
47  display.setCursor(x, y);
48  display.print(text);
49}
50
51void drawCentered(const char* text, uint8_t size) {
52  int16_t x1, y1;
53  uint16_t w, h;
54  display.setTextSize(size);
55  display.getTextBounds(text, 0, 0, &x1, &y1, &w, &h);
56  int16_t x = (SCREEN_WIDTH - w) / 2;
57  int16_t y = (SCREEN_HEIGHT - h) / 2;
58  drawText(text, size, x, y, true);
59  display.display();
60}
61
62void drawStartScreen(uint16_t highScoreValue) {
63  display.clearDisplay();
64
65  const char* title = "START";
66  display.setTextSize(2);
67  display.setTextColor(SSD1306_WHITE);
68
69  int16_t x1, y1;
70  uint16_t w, h;
71  display.getTextBounds(title, 0, 0, &x1, &y1, &w, &h);
72  int16_t xTitle = (SCREEN_WIDTH - w) / 2;
73  int16_t yTitle = 15;
74  display.setCursor(xTitle, yTitle);
75  display.print(title);
76
77  char scoreBuffer[20];
78  snprintf(scoreBuffer, sizeof(scoreBuffer), "High Score: %d", highScoreValue);
79  display.setTextSize(1);
80  display.getTextBounds(scoreBuffer, 0, 0, &x1, &y1, &w, &h);
81  int16_t xScore = (SCREEN_WIDTH - w) / 2;
82  int16_t yScore = yTitle + 25;
83  display.setCursor(xScore, yScore);
84  display.print(scoreBuffer);
85
86  display.display();
87}
88
89void bounce() {
90  if (millis() - previousMillis >= bounceInterval) {
91    previousMillis = millis();
92    for (uint8_t i = 0; i < NUM_BUTTONS; i++) digitalWrite(gameLEDs[i], LOW);
93    digitalWrite(gameLEDs[bounceIndex], HIGH);
94    bounceIndex += bounceDir;
95    if (bounceIndex == 0 || bounceIndex == NUM_BUTTONS - 1) bounceDir = -bounceDir;
96  }
97}
98
99void loadHighScore() {
100  uint16_t magic = 0;
101  EEPROM.get(ADDR_MAGIC, magic);
102
103  if (magic != EEPROM_MAGIC) {
104    highScore = 0;  // first time running
105    EEPROM.put(ADDR_MAGIC, EEPROM_MAGIC);
106    EEPROM.put(ADDR_HIGHSCORE, highScore);
107  } else {
108    EEPROM.get(ADDR_HIGHSCORE, highScore);
109  }
110}
111
112void saveHighScore() {
113  highScore = currentScore;
114  EEPROM.put(ADDR_HIGHSCORE, highScore);
115}
116
117void resetGame() {
118  currentLevel = 1;
119  currentScore = 0;
120  for (uint8_t i = 0; i < NUM_BUTTONS; i++) digitalWrite(gameLEDs[i], LOW);
121}
122
123void extendSequence() {
124  for (int i = 0; i < currentLevel; i++) {
125    gameSequence[i] = random(0, NUM_BUTTONS);
126  }
127}
128
129void lightLedAndPlay(uint8_t idx) {
130  digitalWrite(gameLEDs[idx], HIGH);
131  tone(BUZZER, gameTones[idx]);
132  delay(300);
133  digitalWrite(gameLEDs[idx], LOW);
134  noTone(BUZZER);
135}
136
137void playSequence(uint16_t pauseTime) {
138  for (uint8_t i = 0; i < currentLevel; i++) {
139    lightLedAndPlay(gameSequence[i]);
140    delay(pauseTime);
141  }
142}
143
144int8_t readButtons(uint32_t timeout) {
145  uint32_t start = millis();
146  while (millis() - start < timeout) {
147    for (uint8_t i = 0; i < NUM_BUTTONS; i++) {
148      if (digitalRead(gameButtons[i]) == LOW) {
149        delay(40);
150        return i;
151      }
152    }
153  }
154  return -1;
155}
156
157bool checkUserSequence() {
158  const uint32_t maxTimePerButton = 5000;  // 5 seconds
159  for (uint8_t i = 0; i < currentLevel; i++) {
160    uint32_t startTime = millis();
161    int8_t btn = -1;
162
163    while (millis() - startTime < maxTimePerButton) {
164      for (uint8_t j = 0; j < NUM_BUTTONS; j++) {
165        if (digitalRead(gameButtons[j]) == LOW) {
166          delay(40);  // debounce
167          btn = j;
168          break;
169        }
170      }
171      if (btn >= 0) break;
172    }
173
174    if (btn < 0) return false;
175
176    lightLedAndPlay(btn);
177
178    if (btn != gameSequence[i]) return false;
179
180    uint32_t timeTaken = millis() - startTime;
181    uint16_t points = map(maxTimePerButton - timeTaken, 0, maxTimePerButton, 1, 10);
182    currentScore += points;
183
184    if (currentScore > highScore) {
185      saveHighScore();
186    }
187  }
188
189  return true;
190}
191
192void displayReadyCountDown() {
193  char countDownBuffer[10];
194  for (uint8_t count = 3; count > 0; count--) {
195    tone(BUZZER, NOTE_C4);
196    
197    for(uint8_t i = 0; i < NUM_BUTTONS; i++) digitalWrite(gameLEDs[i], HIGH);
198    snprintf(countDownBuffer, sizeof(countDownBuffer), "READY %d", count);
199    drawCentered(countDownBuffer, 2);
200    for(uint8_t i = 0; i < NUM_BUTTONS; i++) digitalWrite(gameLEDs[i], LOW);
201    
202    noTone(BUZZER);
203    delay(500);
204  }
205  snprintf(countDownBuffer, sizeof(countDownBuffer), "Let's Go");
206  drawCentered(countDownBuffer, 2);
207  delay(300);
208}
209
210void displayGameData() {
211  display.clearDisplay();
212  snprintf(textBuffer, sizeof(textBuffer), "      Level: %d", currentLevel);
213  drawText(textBuffer, 1, 10, 10, false);
214  snprintf(textBuffer, sizeof(textBuffer), "      Score: %d", currentScore);
215  drawText(textBuffer, 1, 10, 20, false);
216  snprintf(textBuffer, sizeof(textBuffer), " High Score: %d", highScore);
217  drawText(textBuffer, 1, 10, 30, false);
218  display.display();
219}
220
221void gameOver() {
222  drawCentered("GAME OVER", 2);
223  tone(BUZZER, NOTE_DS5);
224  delay(200);
225  tone(BUZZER, NOTE_D5);
226  delay(200);
227  tone(BUZZER, NOTE_CS5);
228  delay(200);
229  noTone(BUZZER);
230}
231
232void levelUpSound() {
233  drawCentered("CLEAR!", 2);
234  tone(BUZZER, NOTE_E4);
235  delay(120);
236  tone(BUZZER, NOTE_G4);
237  delay(120);
238  tone(BUZZER, NOTE_E5);
239  delay(120);
240  noTone(BUZZER);
241}
242
243void melodyCelebration() {
244  const int melody[] = { NOTE_C5, NOTE_E5, NOTE_G5, NOTE_C6 };
245  const int duration = 150;
246
247  for (int round = 0; round < 5; round++) {
248    for (uint8_t i = 0; i < NUM_BUTTONS; i++) {
249      digitalWrite(gameLEDs[i], HIGH);
250      tone(BUZZER, melody[i % 4]);
251      delay(duration);
252      digitalWrite(gameLEDs[i], LOW);
253      noTone(BUZZER);
254    }
255  }
256}
257
258void displayCelebration() {
259  int textWidth = 6 * 2 * 8;  // approx: 6 pixels per char * 8 chars * textSize 2
260  int x = (SCREEN_WIDTH - textWidth);
261  int y = 20;
262  int dir = -1;
263
264  for (int i = 0; i < 100; i++) {  // adjust number of iterations
265    display.clearDisplay();
266    display.setCursor(x, y);
267    display.setTextSize(2);
268    display.setTextColor(SSD1306_WHITE);
269    display.print("YOU WIN!");
270    display.display();
271
272    for (uint8_t j = 0; j < NUM_BUTTONS; j++)
273      digitalWrite(gameLEDs[j], (millis() / 100 + j) % 2);
274
275    x += dir;
276
277    if (x <= -textWidth || x >= (SCREEN_WIDTH - textWidth)) dir = -dir;
278
279    delay(30);
280  }
281
282  for (uint8_t j = 0; j < NUM_BUTTONS; j++) digitalWrite(gameLEDs[j], LOW);
283}
284
285void gameCelebration() {
286  melodyCelebration();
287  displayCelebration();
288}
289
290void setup() {
291  for (uint8_t i = 0; i < NUM_BUTTONS; i++) {
292    pinMode(gameLEDs[i], OUTPUT);
293    pinMode(gameButtons[i], INPUT_PULLUP);
294  }
295  pinMode(gameStart, INPUT_PULLUP);
296  pinMode(BUZZER, OUTPUT);
297
298  display.begin(SSD1306_SWITCHCAPVCC, SCREEN_I2C_ADDR);
299  display.clearDisplay();
300  display.display();
301
302  loadHighScore();
303  randomSeed(analogRead(0));
304}
305
306void loop() {
307  if (!startScreenShown) {
308    drawStartScreen(highScore);
309    startScreenShown = true;
310  }
311
312  bounce();
313
314  if (digitalRead(gameStart) == LOW) {
315    delay(100);
316    while (digitalRead(gameStart) == LOW)
317      ;
318    resetGame();
319    startScreenShown = false;
320
321    while (currentLevel <= MAX_GAME_LENGTH) {
322      snprintf(textBuffer, sizeof(textBuffer), "LEVEL %d", currentLevel);
323      drawCentered(textBuffer, 2);
324      delay(800);
325
326      extendSequence();
327
328      displayReadyCountDown();
329
330      displayGameData();
331      playSequence(100);
332
333      if (!checkUserSequence()) {
334        gameOver();
335        delay(1000);
336        break;
337      }
338
339      currentLevel++;
340      if (currentLevel <= MAX_GAME_LENGTH) {
341        levelUpSound();
342        delay(500);
343      }
344
345      if (currentLevel > MAX_GAME_LENGTH) {
346        gameCelebration();
347      }
348    }
349  }
350}

#include <EEPROM.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include "pitches.h"

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define SCREEN_I2C_ADDR 0x3C

#define NUM_BUTTONS 4
#define BUZZER 12
#define MAX_GAME_LENGTH 10

const uint8_t gameLEDs[NUM_BUTTONS] = { 2, 3, 4, 5 };
const uint8_t gameButtons[NUM_BUTTONS] = { 8, 9, 10, 11 };
const uint8_t gameStart = 7;

const int gameTones[NUM_BUTTONS] = {
  NOTE_G3, NOTE_C4, NOTE_E4, NOTE_G5
};

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

uint8_t gameSequence[MAX_GAME_LENGTH];
uint8_t currentLevel = 1;
uint16_t currentScore = 0;
uint16_t highScore = 0;

const uint16_t EEPROM_MAGIC = 0xABCD;
const int ADDR_MAGIC = 0;
const int ADDR_HIGHSCORE = 2;

char textBuffer[24];

uint8_t bounceIndex = 0;
int8_t bounceDir = 1;
uint32_t previousMillis = 0;
const uint16_t bounceInterval = 100;

bool startScreenShown = false;

void drawText(const char* text, uint8_t size, int16_t x, int16_t y, bool clear) {
  if (clear) display.clearDisplay();
  display.setTextSize(size);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(x, y);
  display.print(text);
}

void drawCentered(const char* text, uint8_t size) {
  int16_t x1, y1;
  uint16_t w, h;
  display.setTextSize(size);
  display.getTextBounds(text, 0, 0, &x1, &y1, &w, &h);
  int16_t x = (SCREEN_WIDTH - w) / 2;
  int16_t y = (SCREEN_HEIGHT - h) / 2;
  drawText(text, size, x, y, true);
  display.display();
}

void drawStartScreen(uint16_t highScoreValue) {
  display.clearDisplay();

  const char* title = "START";
  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);

  int16_t x1, y1;
  uint16_t w, h;
  display.getTextBounds(title, 0, 0, &x1, &y1, &w, &h);
  int16_t xTitle = (SCREEN_WIDTH - w) / 2;
  int16_t yTitle = 15;
  display.setCursor(xTitle, yTitle);
  display.print(title);

  char scoreBuffer[20];
  snprintf(scoreBuffer, sizeof(scoreBuffer), "High Score: %d", highScoreValue);
  display.setTextSize(1);
  display.getTextBounds(scoreBuffer, 0, 0, &x1, &y1, &w, &h);
  int16_t xScore = (SCREEN_WIDTH - w) / 2;
  int16_t yScore = yTitle + 25;
  display.setCursor(xScore, yScore);
  display.print(scoreBuffer);

  display.display();
}

void bounce() {
  if (millis() - previousMillis >= bounceInterval) {
    previousMillis = millis();
    for (uint8_t i = 0; i < NUM_BUTTONS; i++) digitalWrite(gameLEDs[i], LOW);
    digitalWrite(gameLEDs[bounceIndex], HIGH);
    bounceIndex += bounceDir;
    if (bounceIndex == 0 || bounceIndex == NUM_BUTTONS - 1) bounceDir = -bounceDir;
  }
}

void loadHighScore() {
  uint16_t magic = 0;
  EEPROM.get(ADDR_MAGIC, magic);

  if (magic != EEPROM_MAGIC) {
    highScore = 0;  // first time running
    EEPROM.put(ADDR_MAGIC, EEPROM_MAGIC);
    EEPROM.put(ADDR_HIGHSCORE, highScore);
  } else {
    EEPROM.get(ADDR_HIGHSCORE, highScore);
  }
}

void saveHighScore() {
  highScore = currentScore;
  EEPROM.put(ADDR_HIGHSCORE, highScore);
}

void resetGame() {
  currentLevel = 1;
  currentScore = 0;
  for (uint8_t i = 0; i < NUM_BUTTONS; i++) digitalWrite(gameLEDs[i], LOW);
}

void extendSequence() {
  for (int i = 0; i < currentLevel; i++) {
    gameSequence[i] = random(0, NUM_BUTTONS);
  }
}

void lightLedAndPlay(uint8_t idx) {
  digitalWrite(gameLEDs[idx], HIGH);
  tone(BUZZER, gameTones[idx]);
  delay(300);
  digitalWrite(gameLEDs[idx], LOW);
  noTone(BUZZER);
}

void playSequence(uint16_t pauseTime) {
  for (uint8_t i = 0; i < currentLevel; i++) {
    lightLedAndPlay(gameSequence[i]);
    delay(pauseTime);
  }
}

int8_t readButtons(uint32_t timeout) {
  uint32_t start = millis();
  while (millis() - start < timeout) {
    for (uint8_t i = 0; i < NUM_BUTTONS; i++) {
      if (digitalRead(gameButtons[i]) == LOW) {
        delay(40);
        return i;
      }
    }
  }
  return -1;
}

bool checkUserSequence() {
  const uint32_t maxTimePerButton = 5000;  // 5 seconds
  for (uint8_t i = 0; i < currentLevel; i++) {
    uint32_t startTime = millis();
    int8_t btn = -1;

    while (millis() - startTime < maxTimePerButton) {
      for (uint8_t j = 0; j < NUM_BUTTONS; j++) {
        if (digitalRead(gameButtons[j]) == LOW) {
          delay(40);  // debounce
          btn = j;
          break;
        }
      }
      if (btn >= 0) break;
    }

    if (btn < 0) return false;

    lightLedAndPlay(btn);

    if (btn != gameSequence[i]) return false;

    uint32_t timeTaken = millis() - startTime;
    uint16_t points = map(maxTimePerButton - timeTaken, 0, maxTimePerButton, 1, 10);
    currentScore += points;

    if (currentScore > highScore) {
      saveHighScore();
    }
  }

  return true;
}

void displayReadyCountDown() {
  char countDownBuffer[10];
  for (uint8_t count = 3; count > 0; count--) {
    tone(BUZZER, NOTE_C4);
    
    for(uint8_t i = 0; i < NUM_BUTTONS; i++) digitalWrite(gameLEDs[i], HIGH);
    snprintf(countDownBuffer, sizeof(countDownBuffer), "READY %d", count);
    drawCentered(countDownBuffer, 2);
    for(uint8_t i = 0; i < NUM_BUTTONS; i++) digitalWrite(gameLEDs[i], LOW);
    
    noTone(BUZZER);
    delay(500);
  }
  snprintf(countDownBuffer, sizeof(countDownBuffer), "Let's Go");
  drawCentered(countDownBuffer, 2);
  delay(300);
}

void displayGameData() {
  display.clearDisplay();
  snprintf(textBuffer, sizeof(textBuffer), "      Level: %d", currentLevel);
  drawText(textBuffer, 1, 10, 10, false);
  snprintf(textBuffer, sizeof(textBuffer), "      Score: %d", currentScore);
  drawText(textBuffer, 1, 10, 20, false);
  snprintf(textBuffer, sizeof(textBuffer), " High Score: %d", highScore);
  drawText(textBuffer, 1, 10, 30, false);
  display.display();
}

void gameOver() {
  drawCentered("GAME OVER", 2);
  tone(BUZZER, NOTE_DS5);
  delay(200);
  tone(BUZZER, NOTE_D5);
  delay(200);
  tone(BUZZER, NOTE_CS5);
  delay(200);
  noTone(BUZZER);
}

void levelUpSound() {
  drawCentered("CLEAR!", 2);
  tone(BUZZER, NOTE_E4);
  delay(120);
  tone(BUZZER, NOTE_G4);
  delay(120);
  tone(BUZZER, NOTE_E5);
  delay(120);
  noTone(BUZZER);
}

void melodyCelebration() {
  const int melody[] = { NOTE_C5, NOTE_E5, NOTE_G5, NOTE_C6 };
  const int duration = 150;

  for (int round = 0; round < 5; round++) {
    for (uint8_t i = 0; i < NUM_BUTTONS; i++) {
      digitalWrite(gameLEDs[i], HIGH);
      tone(BUZZER, melody[i % 4]);
      delay(duration);
      digitalWrite(gameLEDs[i], LOW);
      noTone(BUZZER);
    }
  }
}

void displayCelebration() {
  int textWidth = 6 * 2 * 8;  // approx: 6 pixels per char * 8 chars * textSize 2
  int x = (SCREEN_WIDTH - textWidth);
  int y = 20;
  int dir = -1;

  for (int i = 0; i < 100; i++) {  // adjust number of iterations
    display.clearDisplay();
    display.setCursor(x, y);
    display.setTextSize(2);
    display.setTextColor(SSD1306_WHITE);
    display.print("YOU WIN!");
    display.display();

    for (uint8_t j = 0; j < NUM_BUTTONS; j++)
      digitalWrite(gameLEDs[j], (millis() / 100 + j) % 2);

    x += dir;

    if (x <= -textWidth || x >= (SCREEN_WIDTH - textWidth)) dir = -dir;

    delay(30);
  }

  for (uint8_t j = 0; j < NUM_BUTTONS; j++) digitalWrite(gameLEDs[j], LOW);
}

void gameCelebration() {
  melodyCelebration();
  displayCelebration();
}

void setup() {
  for (uint8_t i = 0; i < NUM_BUTTONS; i++) {
    pinMode(gameLEDs[i], OUTPUT);
    pinMode(gameButtons[i], INPUT_PULLUP);
  }
  pinMode(gameStart, INPUT_PULLUP);
  pinMode(BUZZER, OUTPUT);

  display.begin(SSD1306_SWITCHCAPVCC, SCREEN_I2C_ADDR);
  display.clearDisplay();
  display.display();

  loadHighScore();
  randomSeed(analogRead(0));
}

void loop() {
  if (!startScreenShown) {
    drawStartScreen(highScore);
    startScreenShown = true;
  }

  bounce();

  if (digitalRead(gameStart) == LOW) {
    delay(100);
    while (digitalRead(gameStart) == LOW)
      ;
    resetGame();
    startScreenShown = false;

    while (currentLevel <= MAX_GAME_LENGTH) {
      snprintf(textBuffer, sizeof(textBuffer), "LEVEL %d", currentLevel);
      drawCentered(textBuffer, 2);
      delay(800);

      extendSequence();

      displayReadyCountDown();

      displayGameData();
      playSequence(100);

      if (!checkUserSequence()) {
        gameOver();
        delay(1000);
        break;
      }

      currentLevel++;
      if (currentLevel <= MAX_GAME_LENGTH) {
        levelUpSound();
        delay(500);
      }

      if (currentLevel > MAX_GAME_LENGTH) {
        gameCelebration();
      }
    }
  }
}

Downloadable files

Circuit

Circuit view using ThinkerCAD

sequence_master_circuit_vw.png

Documentation

Play a Melody using the tone() function

To make the pitches.h file

https://docs.arduino.cc/built-in-examples/digital/toneMelody/

Comments

Only logged in users can leave comments

dodi01

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content