Month: April 2026

Tigoe’s “Greatest Hits” taxonomy is useful precisely because it reframes recurring project themes not as signs of creative exhaustion, but as flexible starting points. The most interesting tension in the piece is between projects that offer structured interaction — drum gloves, floor pads, tilty controllers — and those that are essentially aesthetic spectacles you wave at, like video mirrors and mechanical pixels. Tigoe is honest about this distinction without being dismissive, and that balance feels right. The example that stuck with me most is the Digital Wheel Art project, designed for a patient with limited mobility — it reframes a “body-as-cursor” trope into something genuinely purposeful, which suggests that what makes a recurring theme worth revisiting is often the specificity of the context, not novelty for its own sake. The piece raises a question though: if these themes keep recurring, is that because they represent something deeply natural about how humans want to interact with physical systems, or just because they’re the easiest things to build with the available tools?
“Set the Stage, Then Shut Up and Listen” makes a compelling case that interactive art is fundamentally a conversation, and that over-explaining your work is a way of refusing to have that conversation. The director analogy is apt — you can set conditions for an authentic response, but you can’t prescribe the response itself. That said, Tigoe’s argument assumes a fairly confident, well-resourced designer. In practice, people often over-explain their work not out of arrogance but out of anxiety that the interaction won’t be legible at all — a real concern, especially for newer designers. There’s a tension between “shut up and let the audience interpret” and “design clearly enough that people know how to engage.” The “Greatest Hits” piece is actually a useful companion here: it shows that certain gestures — tapping, tilting, waving — are already culturally legible, which makes it easier to step back. The question both readings leave open is how much context is enough, and how you know when you’ve crossed from helpful framing into over-interpretation.

1. Repository

Repository

2. Overview

This project is an interactive color-matching game. A random RGB color is displayed on a target LED. The player uses a potentiometer to dial in their best guess across three channels — red, green, then blue — cycling between them with a button. A second RGB LED shows the guess in real time. When the player is satisfied, they press a lock button to submit their answer. The game scores the result based on how closely the guess matches the target across all three channels combined.

3. Concept

The idea came from thinking about how humans perceive color — we rarely see RGB values, we just see a color and react to it intuitively. The game puts that intuition to the test. By isolating each channel and forcing the player to set them one at a time, it makes visible a process that normally happens instantly in our brains. The constraint of the potentiometer (a single knob controlling one value at a time) creates a deliberate, almost meditative interaction. It’s also just a fun game to play, matching colors without needing to understand what’s happening electronically.

4. Process and Methods

• • The potentiometer is read every loop using analogRead, which returns a value from 0 to 1023. This is mapped to 0–255 using map() to match the range that analogWrite expects for PWM output.
  • A state machine (currentState) tracks which channel is active. Only the active channel updates when the pot is turned — the other two hold their last value. This lets the player build up the color incrementally without losing previous adjustments.
  • The Next button increments the state from Red to Green to Blue to Finished. If the player keeps pressing beyond Finished, the state wraps back to Red so they can refine any channel without restarting the round.
  • The Lock button only accepts input when currentState >= 3, preventing the player from accidentally locking in an incomplete guess.
  • randomSeed(analogRead(A5)) seeds the random number generator using electrical noise from an unconnected pin, ensuring a different target color every round.

5. Technical Details

• • Both buttons use INPUT_PULLUP mode — the pin is held HIGH internally and reads LOW when pressed. No external resistors are needed.

// Pin reads HIGH normally, LOW when pressed
pinMode(nextBtn, INPUT_PULLUP);
pinMode(lockBtn, INPUT_PULLUP);

• • The guess LED uses analogWrite (PWM) on pins 9, 10, 11 — this is the analog output requirement. The target LED uses the same approach on pins 5, 6, 7.

// analogWrite sends a PWM signal (0 = off, 255 = full brightness)
analogWrite(redG,   guessR);
analogWrite(greenG, guessG);
analogWrite(blueG,  guessB);

• • Scoring uses the sum of absolute differences across all three channels rather than a per-channel check. This gives a single number (0–765) representing total color distance, which maps naturally to a three-tier result.

// Total difference: sum of how far off each channel is (max possible = 765)
int diff = abs(targetR - guessR) + abs(targetG - guessG) + abs(targetB - guessB);

• • A simple delay(250) after each button press acts as debounce, preventing a single physical press from registering multiple times.

6. Reflection

This project was the most game-like thing I’ve built with the Arduino so far and it pushed me to think about user experience as much as electronics. The biggest design challenge was the state machine — figuring out how to let the player cycle back through channels to refine their guess without losing their previous values took a few iterations. I also underestimated how important the real-time feedback from the guess LED would be; watching the colour change as you turn the pot makes the whole interaction feel alive in a way that a number on a serial monitor never could. If I were to extend this, I would add a scoring history across multiple rounds and a visual indicator on the LED itself to show which channel is currently active (perhaps pulsing the active color) rather than relying entirely on the Serial Monitor for guidance.

7. Resources

• • https://pyserial.readthedocs.io/en/latest/
  • https://learn.sparkfun.com/tutorials

Demo Below:

Concept:

The idea of this is that, you “charge” up a light show by shining a really bright light on the photo resistor, once you charged it up for a good 10 seconds, a light show happens! A yellow RGB light slowly brightens up as the percentages reaches to a 100 while charging. I implemented a physical button that resets everything to stop the light show and so that you are able to charge it again.

Implementation:

Schematic:

The components used are RGB lights, a photo resistor, a 2×16 LCD and a potentiometer.

#include <LiquidCrystal.h>

// RS, E, D4, D5, D6, D7
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

const int ldrPin = A0;
const int btnPin = 7;     // Button
const int ledAnalog = 9;  // The fading LED
const int ledA = 13;      // Light show LED
const int ledB = 10;      // Light show LED
const int ledC = 8;       // Light show LED

int threshold = 600;
unsigned long startMs = 0;
bool charging = false;
bool done = false;

Here we initialize everything, since LCD has its own module and example code, I took the initialization and syntax from there, we assign pins, the threshold and set everything to false since the program just began.

// Reset logic
  if (digitalRead(btnPin) == LOW) {
    // Set variables to original values
    startMs = 0;
    charging = false;
    done = false;
    // Turn off everything
    digitalWrite(ledA, LOW);
    digitalWrite(ledB, LOW);
    digitalWrite(ledC, LOW);
    analogWrite(ledAnalog, 0);
    lcd.clear();
    lcd.print("System Reset");
    delay(500);
  }

This is the reset code for when the button is pressed, it just turns off everything, and sets charging and done false to enter the mode it originally started with and just reset everything to the origin.

if (!done) {
    // When light above threshold start counting
    if (light > threshold) {
      if (!charging) {
        startMs = millis();
        charging = true;
      } ...
  }
}

We have nested if statements here, to first check if the charging is done, if it isn’t we check if the light crosses the threshold, and if we aren’t already charging, we should start. If the light passes down the threshold, the charge goes to 0 and we restart.

  // Light show time
  lcd.setCursor(0, 0);
  lcd.print("FULLY CHARGED!  ");
  lcd.setCursor(0, 1);
  lcd.print("   100 PERCENT  ");
  
  // Blink Pattern
  digitalWrite(ledA, HIGH); delay(100);
  digitalWrite(ledB, HIGH); delay(100);
  digitalWrite(ledC, HIGH); delay(100);
  digitalWrite(ledA, LOW);  digitalWrite(ledB, LOW); digitalWrite(ledC, LOW);
  delay(100);
}

When it has charged for 10 seconds or more, we set done to true, which calls the else commands and starts the light show till stopped by the button or simply turned off.

Code here:
GitHub link

Reflection:

Some ways I thought of improving this is having a proper choreography of the lights that go along with some music, maybe manually do it or write up an algorithm that works for any song, either way I think that would improve this project. It was fun learning about the LCD however, and I am glad that I am able to use it now.

I really liked the second reading, because I am always curious about movies that leave things to the audience to interpret and also poetry; how everyone have their own meaning of the same couplet. The fear of not being able to convey what I am trying to convey is something I notice everyday everywhere. The author touched on the opposite where we ignite a thought and let other people drive anywhere. Thou this is a scary idea at the beginning, it uncover so many new possibilities which I might to have never thought about before. I wonder if I can in corporate in the Arduino assignments.  In the P5, it was easy to let the audience contemplate but with this I think there it harder but can be done. And if done properly, it can have a far greater impact as we can have all the sensory inputs here.

On the other hand, the first reading highlighted something which I feel during every assignment, even thou room for creativity is infinite, one often feels limited with when working with primitive shapes or two LEDs. I understand it possible to create a mural out of primitive shapes but that also requires mastery in it. My take away from that reading is a quote by Martin Scorsese that is “The most creative is the most personal”

https://github.com/da3755-ui/intro-to-im/blob/904200aaa8c70e0606c6851ffc5c46abe5d63b96/BirthdayConcept_IntroToIM_Week9.ino

 

The Concept

For this week’s assignment, I decided to incorporate the concept of birthday candles (lighting them up and blowing them out). My LEDs act as my candles, my button acts as a lighter, and the LDR/photocell senses my blowing (will explain).

I used a button (digital input) to be able to control my 3 LEDs. Once I hit the button, the LEDs turn on one after the other. The blowing concept works through my photocell. When you put your face closer to the photocell and the LEDs to blow, the light from the LEDs reflects on your face; this light reflection is further read by the photocell, and the reading increases. Once my photocell takes in that higher reading, the candles/LEDs turn off one after the other as well.

Process and Challenges

To do my led set-up, I followed a diagram I found online, but I altered some of it to how I wanted it to fit my set-up.

I first started by setting up my LED system before adding in my photocell, just to make sure the base part is working. I built the system successfully and moved on to add my photocell.

Adding in the photocell and getting its readings was the most challenging part of the process. I set up my photocell and connected it to a 10k resistor and an analog pin. However, the readings were not accurate at all. For example, covering the photocell would not decrease the reading. At that point, I decided that maybe because I’m testing it during the day, there is no dramatic shift in lighting for the photocell to read (that was wrong).

After a while had passed, I was thinking about my project, and I realized I had forgotten to attach a 5V pin to my photocell, and I forgot to attach my photocell to ground. That explained a lot of why the readings were inaccurate.

Once I plugged in the wires correctly, the readings were still inconsistent and inaccurate. Thats when I decided to fully take down the entire system and start with the photocell first.

I watched a YouTube video to ensure I have the right connectivity and rebuilt my voltage distributor and photocell system. The readings then became accurate. I added in my LED system that I removed and it worked.

I originally wanted each LED to light up after each singular clip so it would be:

• first button press = turn on first led
• second button press = keep first led on and turn on second led
• third button press = keep first and second leds on and turn on the third

but that would have required me to use specific array functions which were difficult for me to implement.

Code Highlight:

I’m happy with the way I let the led lights light up one after the other after hitting the button

if (state == LOW) {   // if the button is pressed, the leds/candles will light up one after the other
  digitalWrite(led1Pin, HIGH);
  delay(2000);
  digitalWrite(led2Pin, HIGH);
  delay(2000);
  digitalWrite(led3Pin, HIGH);
  delay(2000);
}

 

Circuit Schematic

Circuit look

References

Because my photocell readings would only keep decreasing no matter what, I used Gemini AI to explain to me whether the reading from my photocell should increase or decrease when the area gets brighter. It also told me to check my connectivity, because if my photocell’s resistor was connected to one of the wires, the readings would be flipped, but that was not the case for me.

Arduino Push Button with Multiple LEDs [Tutorial]