Production: LED Lights Memory Game
Concept
The concept of my project was to create a memory-based LED game inspired by the small game we watched in class. In that example, a light would turn on and the first person to press the button on their side would win. I found that idea very engaging, so I wanted to build something similar but with a stronger focus on memory and sequence. While looking for ideas, I came across the concept of a “Simon Says” style memory game, which immediately reminded me of a toy I used to play with as a child, similar to a Pop It memory game with lights and patterns. This connection made the idea more personal and interesting to develop, so I decided to create a game where the Arduino generates a sequence of LED lights and the player must repeat it correctly using buttons.
Process
To build this project, I started by learning the basic components separately. I watched several tutorials by Paul McWhorter, which helped me understand more things on how LEDs and buttons can work, as well as how to structure Arduino code using functions, loops, and conditionals. I also explored the Arduino documentation to better understand how different functions work and how Arduino programming compares to tools like p5.js. The good thing is that both use similar logical structures, which made it easier for me to understand the code. I programmed the Arduino to generate a random sequence, display it using LEDs, and then check the user’s input through buttons. I also added a startup LED test to verify that the circuit was working correctly before the game begins.
// LED MEMORY GAME
// PIN SETUP
// LED pins
int redLED = 12;
int yellowLED = 9;
int greenLED = 6;
int blueLED = 3;
// Button pins
int redButton = 11;
int yellowButton = 8;
int greenButton = 5;
int blueButton = 2;
// GAME VARIABLES
int sequence[10]; // stores up to 10 steps
int level = 0; // current level
// ==============================
// SETUP
// ==============================
void setup() {
// Set LED pins as OUTPUT
pinMode(redLED, OUTPUT);
pinMode(yellowLED, OUTPUT);
pinMode(greenLED, OUTPUT);
pinMode(blueLED, OUTPUT);
// Set button pins as INPUT (with internal pull-up)
pinMode(redButton, INPUT_PULLUP);
pinMode(yellowButton, INPUT_PULLUP);
pinMode(greenButton, INPUT_PULLUP);
pinMode(blueButton, INPUT_PULLUP);
// Start random generator
randomSeed(analogRead(0));
// ==============================
// STARTUP LED TEST
// ==============================
// Turn on each LED one by one
digitalWrite(redLED, HIGH);
delay(300);
digitalWrite(redLED, LOW);
digitalWrite(yellowLED, HIGH);
delay(300);
digitalWrite(yellowLED, LOW);
digitalWrite(greenLED, HIGH);
delay(300);
digitalWrite(greenLED, LOW);
digitalWrite(blueLED, HIGH);
delay(300);
digitalWrite(blueLED, LOW);
delay(500); // small pause before game starts
}
// ==============================
// MAIN LOOP
// ==============================
void loop() {
addStep(); // add new random color
showSequence(); // show LED sequence
bool correct = checkPlayer(); // check user input
if (correct == false) {
gameOver(); // if wrong → game over
resetGame(); // restart
}
delay(1000);
}
// ==============================
// FUNCTIONS
// ==============================
// Add a new random step
void addStep() {
sequence[level] = random(0, 4);
level++;
}
// Show the sequence using LEDs
void showSequence() {
for (int i = 0; i < level; i++) {
turnOnLED(sequence[i]);
delay(500);
turnOffAll();
delay(250);
}
}
// Turn on the correct LED
void turnOnLED(int number) {
if (number == 0) digitalWrite(redLED, HIGH);
if (number == 1) digitalWrite(yellowLED, HIGH);
if (number == 2) digitalWrite(greenLED, HIGH);
if (number == 3) digitalWrite(blueLED, HIGH);
}
// Turn off all LEDs
void turnOffAll() {
digitalWrite(redLED, LOW);
digitalWrite(yellowLED, LOW);
digitalWrite(greenLED, LOW);
digitalWrite(blueLED, LOW);
}
// Check player input
bool checkPlayer() {
for (int i = 0; i < level; i++) {
int buttonPressed = waitForButton();
// Show feedback
turnOnLED(buttonPressed);
delay(300);
turnOffAll();
// Check correctness
if (buttonPressed != sequence[i]) {
return false;
}
}
return true;
}
// Wait for button press
int waitForButton() {
while (true) {
if (digitalRead(redButton) == LOW) {
delay(200); // debounce
return 0;
}
if (digitalRead(yellowButton) == LOW) {
delay(200);
return 1;
}
if (digitalRead(greenButton) == LOW) {
delay(200);
return 2;
}
if (digitalRead(blueButton) == LOW) {
delay(200);
return 3;
}
}
}
// Game over animation
void gameOver() {
for (int i = 0; i < 3; i++) {
digitalWrite(redLED, HIGH);
digitalWrite(yellowLED, HIGH);
digitalWrite(greenLED, HIGH);
digitalWrite(blueLED, HIGH);
delay(300);
turnOffAll();
delay(300);
}
}
// Reset game
void resetGame() {
level = 0;
}
Difficulties
One of the main difficulties I encountered was related to the physical design of the circuit, especially the buttons. It was challenging to make the buttons clearly visible and easy to press during gameplay. At times, the wires made the setup look cluttered and slightly uncomfortable to use. To improve this, I adjusted the layout of the breadboard and repositioned it to the left side instead of the right, which made the buttons more accessible. However, I still believe the design could be improved. A possible solution would be to use shorter wires, since the ones included in the kit are relatively long and make the circuit less organized.
Thing that I’m Proud Of
One aspect of the project that I am particularly proud of is the feedback system when the player loses. I programmed all the LEDs to blink simultaneously several times, creating a clear and satisfying visual indication that the game is over. This small detail enhances the user experience and makes the game feel more complete and interactive.
Reflection Overall 
Overall, I found this project very enjoyable and rewarding. It allowed me to combine creativity with technical skills and to better understand how hardware and software interact. I especially liked how I could take a simple idea and gradually build it into a functional game. If I were to improve this project in the future, I would like to add sound effects, such as tones that play when each LED lights up, to make the experience more immersive. Although I have not yet implemented this feature, it is something I would like to explore next. This project helped me gain confidence in working with Arduino and problem-solving in both coding and physical design.
PHOTO OF PHYSICAL CIRCUIT
PHOTO OF SCHEMATIC
Reading Reflections
Making Interactive Art
Reading this text me rethink what art even is, especially interactive art, because I feel like I’ve always thought of art as something where the artist is trying to say something very specific, and the audience is supposed to understand that meaning. But here it’s kind of the opposite. It’s saying that if you control too much, if you explain too much, you’re actually limiting the experience. And I find that really interesting but also a bit uncomfortable, because it means you’re giving up control over your own work. Like, you create something, but then people might completely misunderstand it, or interact with it in a way you didn’t expect, and that’s supposed to be part of it. I think what stood out to me the most is this idea that the artwork is not the final product, but more like the beginning of a conversation, and the audience kind of finishes it. At the same time, I feel a bit conflicted, because I wonder if that means the artist’s intention doesn’t matter as much anymore, or if it just becomes too vague. But I do like the idea that interaction is more real when it’s not forced, when people figure things out on their own. It makes the experience more personal instead of just following instructions. So I think the main thing I take from this is that good interactive art is not about telling people what to think, but about creating a space where they can think for themselves, even if that means losing some control over what your work becomes.
Physical Computing’s Greatest Hits (and misses)
This article made me realize something that I hadn’t really thought about before, which is how much creativity is not about doing something completely new, but about how you reinterpret things that already exist. At first, I kind of agreed with that instinct of “if it’s already been done, it’s not original,” but reading this made me see that that idea is actually very limiting. The author shows how the same types of projects keep coming back, like gloves or sensors or interactive spaces, but what changes is how people give meaning to them. And I think that’s the part that stood out to me the most, because it’s not really about the technology itself, it’s about the interaction and what it makes people feel or do. At the same time, I also feel a bit conflicted, because some of these projects sound very repetitive or even a bit shallow, like things that look cool but don’t really have depth. So it made me question where the line is between something that is genuinely creative and something that is just visually interesting. I think overall the article is kind of saying that originality doesn’t come from the idea itself, but from the intention behind it, but I’m not sure if I fully agree, because I still feel like at some point things can become too repetitive. But I do like the idea that you shouldn’t immediately discard something just because it’s been done before, because that mindset probably stops a lot of good ideas before they even start.
