Week 10 Reading Reflection

Reflection on “Physical Computing’s Greatest Hits (and misses)”

In “Physical Computing’s Greatest Hits (and misses),” the complex interplay between user interaction and physical computing physics is masterfully broken down. The article examines the ways in which different initiatives seek to build a connection between digital response and human engagement. The investigation of technologies that aid in meditation strikes me as particularly noteworthy. Being a tech and mindfulness fan, I find it fascinating and a little frightening that an essentially qualitative experience can be quantified. Are these devices making the spiritual journey better, or are they just turning it into a set of numbers? This query calls for a more thorough examination of technology’s place in settings that are often designated for pure human experience.

“Digital Wheel Art,” another noteworthy initiative that was highlighted, demonstrates how technology may democratize the creation of art, particularly for people with restricted mobility. It serves as a sobering reminder that technological accessibility is a bridge to equality and self-expression rather than merely a feature. This, together with the creative Sign Language gloves, strengthens my conviction that technology, when used carefully, can serve as a potent force for inclusion rather than just serving a practical purpose.

These illustrations highlight a more general insight that was brought to light by the reading: interactive installations are more than just impressive technical feats; they also reveal human stories and arouse feelings. Therefore, interactive art’s value lies not only in its technological prowess but also in its capacity to speak to our common humanity and elicit a wide range of emotions.

Reflection on “Making Interactive Art: Set the Stage, Then Shut Up and Listen”

With regard to the function of the artist in the age of interactive media, “Making Interactive Art: Set the Stage, Then Shut Up and Listen” presents an interesting perspective. According to the reading, interactive art ought to be a conversation rather than a monologue—a platform for engagement rather than only observation. This speaks to me, especially when it comes to the fear that an artist may have that their creations would be misinterpreted or inappropriately used. The act of giving up control and letting the audience add their own interpretations to the work is evidence of the transformational potential of art.

The spectrum of engagement that creators struggle with is highlighted by the tension between interaction and set narrative, such as that seen in video games or visual novels. These media contest the idea that interactive equals natural, unscripted experiences, proposing instead that the audience’s interpretation and the artist’s intention are complementary elements of a nuanced dialogue.

Thinking about this makes me wonder about the fine line that all artists have to walk. In order to create an environment where art and audience can collaboratively generate meaning, curation involves more than just designing the experience. It also involves managing the lack of direction. It’s a subtle, yet audacious, gesture of faith in the audience’s ability to connect with the work of art, giving each encounter a distinct personality. My comprehension of interactive art has grown as a result of this study, and I now have a greater respect for the bravery and vulnerability that these works of art require.

Week 10 Assignment – light sensor

This projects concept is related to automatic lights, where a sensor detects the amount of light in its surroundings and according to it, it switches lights on and off. So for this assignment, I decided to implement this technique:

This is the code that I used to implement this method:

int photoSensorPin = A0;
int buttonPin = 2;
int ledPin1 = 9;
int ledPin2 = 10;
void setup() {
  pinMode(photoSensorPin, INPUT);
  pinMode(buttonPin, INPUT);
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
void loop() {
  int sensorValue = analogRead(photoSensorPin);
  int buttonState = digitalRead(buttonPin);
  if (buttonState == HIGH) {
    digitalWrite(ledPin1, LOW);
    digitalWrite(ledPin2, HIGH);
  } else if (sensorValue < 512) {
    digitalWrite(ledPin1, HIGH);
    digitalWrite(ledPin2, LOW);
  } else {
    digitalWrite(ledPin1, LOW);
    digitalWrite(ledPin2, LOW);


Reading Response 7

The article “Physical Computing’s Greatest Hits (and misses)” offers an exploration of various classes of physical computing projects and the dynamics between implementation and engagement. The concept of “Meditation Helpers” caught my attention as someone interested in cognitive psychology and mindfulness. While these devices aim to guide users into a meditative state by measuring physiological indicators like heart rate and breath rate or stress through measuring sweat gland activity, I wonder about their effectiveness. Can technology truly facilitate mindfulness, or does it risk reducing meditation to a quantifiable metric? The reading prompted me to consider the role of technology in spiritual practices and whether it enhances or detracts from the essence of meditation. Another example that I found to be very innovative was Younghyun Chung’s “Digital Wheel Art”. I have always raised the question of accessibility in interactive installations. However, his project demonstrates that by utilizing technology to track and interpret bodily movements, individuals who may have limited mobility or dexterity can also engage in interactive experiences with greater ease and independence. Thus, physical computing can be leveraged to create inclusive and accessible solutions for individuals with disabilities. Another example of this is Sign Language gloves, which attempt to convert the motions of sign language into written or spoken words, which can help people who are deaf or hard of hearing to communicate easier with a hearing person.

Furthermore, the article prompted me to reconsider the essence of interactive art and its intrinsic connection to human emotions and experiences. The idea that interactive art should evoke feelings and thoughts rather than merely showcase technological prowess struck a chord with me. It reminded me that the true essence of art lies in its ability to stir emotions and provoke introspection, fostering a collaborative relationship between the artist and the audience. Overall, the article sparked a renewed curiosity in exploring the delicate balance between technical innovation and human connection in interactive art.


The article “Making Interactive Art” resonated with me deeply, particularly its emphasis on allowing the audience to interpret and engage with the work independently. It reminded me of my own experiences with interactive art installations, where the most impactful moments occurred when I was given the freedom to explore and interact without being told what to think or do. Like I mentioned earlier, art is truly interactive when there is open conversation between the artist and the viewer. In simple terms: show, don’t tell.

I appreciated the comparison the author drew between designing interactive art and directing actors in a performance. It highlighted the importance of providing the audience with tools and cues to guide their interaction while allowing room for individual interpretation and discovery. However, I found myself questioning whether there might be instances where some level of guidance or interpretation could enhance the audience’s experience without detracting from their autonomy. For example, some modern artworks look like random nonsense to me before I’m told the hidden meaning. 

Week 10 – Interactive/traditional switches

Project Concept:

Drawing inspiration from everyday objects and interactions, this assignment presents a simple light switch and dimmer found in most houses around the world. I’m reimagining these familiar components in a playful and interactive way using Arduino and LEDs. The dynamics consists of a modern twist on traditional controls, where pressing a button toggles the red LED while turning a knob adjusts the brightness of the green LED.


  • Arduino Uno board
  • Jumper wires
  • Green LED
  • Red LED
  • Two 330 ohm resistors
  • One 10k ohm resistor
  • Push button
  • Potentiometer


The circuit reflects the simplicity and functionality of a traditional light switch and dimmer. The push button acts as the on/off switch for the red LED, providing tactile feedback similar to pressing a light switch. Meanwhile, the potentiometer emulates the rotary dial of a dimmer, allowing users to adjust the brightness of the green LED by turning the knob.



const int SENSOR_PIN = A0; // Analog input pin for sensor controlling red LED brightness
const int CONTROL_PIN = 2; // Digital input pin for control button to switch LED colors
const int RED_LED = 5;  // Digital output pin for LED (red)
const int GREEN_LED = 6;  // Digital output pin for LED (green)

int redBrightness = 0; // Red LED brightness controlled by sensor
bool buttonPressed = false; // Button state
int colorIndex = 0; // Index of current color

void setup() {
  pinMode(RED_LED, OUTPUT);

void loop() {
  // Read sensor value to control brightness of red LED
  redBrightness = analogRead(SENSOR_PIN) / 4; // Divide by 4 to map 0-1023 to 0-255
  // Set the brightness of the red LED
  analogWrite(RED_LED, redBrightness);
  // Check control button state
  if (digitalRead(CONTROL_PIN) == LOW) {
    if (!buttonPressed) {
      // Toggle color index
      colorIndex = (colorIndex + 1) % 2;
      buttonPressed = true;
      // Turn on green LED when button is pressed
      digitalWrite(GREEN_LED, HIGH);
  } else {
    buttonPressed = false;
    // Turn off green LED when button is released
    digitalWrite(GREEN_LED, LOW);


Video Demonstration:

Reflection and Improvements:

Finally, I’m satisfied with the project outcome, as it bridges the gap between simplicity and innovation, reimagining everyday objects in a playful and interactive manner while showcasing the creative potential of Arduino-based projects. Some improvements are as follow:

  • Experiment with different button and knob designs to enhance user experience and aesthetic appeal.
  • Integrate additional sensors, such as light sensors or temperature sensors, to create more dynamic lighting effects and automation capabilities.

production assignment week 10

This project allows us to control the brightness of two LEDs – one red and one green – using a potentiometer and a push button.

Here’s what you’ll see in the video:
An Arduino Uno board.
A potentiometer, acting as a dimmer switch.
A push button for an instant override.
Two LEDs, red and green, responding to our commands.


How does it work?
Let’s dive into the details:
The Potentiometer: As you turn the knob, it sends varying voltage values to the Arduino. The code interprets these values and maps them to control the brightness of the LEDs. Turning one way brightens the green LED while dimming the red, and vice versa.
The Push Button: This acts as an override switch. No matter what the potentiometer setting is, pressing the button instantly turns the red LED on to full brightness.

Technical Insights:
The project utilizes the Arduino’s analog input capabilities to read the potentiometer values and its PWM (Pulse Width Modulation) functionality to control the LED brightness.
The push button is connected to a digital input pin, allowing the Arduino to detect button presses and trigger the override function.

Week 10 | Beyond Ideas

I started picking up my first console when I was around four years old. It was Nintendo’s Gameboy Advance console. To this day, I still remember my first time inserting the cartridges, booting up the machine, and blasting hours and hours into Pokémon FireRed. The feeling of being immersed into an alternate world despite it being on a screen a few inches wide, and with few buttons to press, still blows my mind.


Gameboy Advance. Nintendo.

Even if it’s just 8 buttons, the console opened a rift to a new reality

Igoe clarifies that interactivity should be a gateway to endless possibilities rather than a fixated destination. Similarly, the console’s interactiveness only goes as far as the buttons and screen, yet game developers utilize those mechanics to propel the user one step closer to experiencing the Kanto Region (Pokémon FireRed’s world).

Video games, to me, are a new type of art–a premature one that is. Unlike paintings, books, or movies, it is a medium of art that takes shape by the user, rather than the author. Plus, because of how young they are, there is still room for the medium to grow.

I was thinking about how physical computing machines mentioned in Igoe’s post are not commercialized. Because these are new ideas, they still require rigorous testing and adjustments to fit our society. Yet, video game console challenges this idea. Floor dances, gloves, VR headsets, all these new devices are the pillars of future technologies. Hence, is it not better for us to embrace it as soon as possible?

Week 10 Reading Response: Tom Igoe

Making Interactive Art: Set the Stage, Then Shut Up and Listen

This was a pretty interesting look into interactive media as a participatory media. Often artists tend to be afraid of their art being assigned a wrong meaning, and artistic clarifications usually keep popping up well after a work is created (JK Rowling is a particularly glaring example). It stems from a fear that our own beliefs, our own creation, will be inevitably challenged by the audience. This is even more true for something that involves even more two-way communication, like an interactive art showcase. Even in our own documentation, it is tempting to include an exact user guide of how to “use” our art. And while user guides are helpful for products, they might not have the same effect in art.

That is not to say however, that all interactive art has to be fully participatory and unscripted. This again goes back to the debate we had when discussing Chris Crawford’s The Art of Interactive Design. Once again, the question pops up of whether interactive is participatory, or whether it has to be organic. For example, a lot of games are deeply scripted, and while it may be argued that playing the game is an organic experience of its own, it doesn’t change the fact that in a lot of games, you will be seeing most, if not all, the events that are meant to happen. Visual novels are another example. By most definitions of interactivity, they are not interactive, being no better than picture books. Yet, they do feel interactive in their own way.

At the end of the day, it is up to the artist and what compromise they make between interactivity and meaning.

Physical Computing’s Greatest Hits (and misses)

This was a nice look at different classes of physical computing projects and the benefits and challenges of each. Usually, there seems to be a common theme where there is a compromise between implementation and engagement. Relatively simpler projects like the theremin, floor pad, video mirrors, and Scooby Doo paintings may be easier to implement and more common, but they also lose engagement quickly. On the other hand, more complex mechanical pixels, body/hand cursors, multi-touch interfaces and fields of grass may be more engaging but often run into implementation or maintenance issues that take away some of the charm. In a way, my main takeaway from the article was that rather than your physical computing mechanism, what is more important is the story and how the mechanisms tie in to the story being told.

Week 10: Analog/Digital (Parking Sensor)


For this project, I wished to use the ultrasonic sensor in some form, especially as it used to be my favorite sensor back when I experimented around with LEGO Mindstorms. I remembered that conceptually, a parking sensor was, in its simplest form, a combination of a digital input (Reverse Gear On/Off) and an analog input (ultrasonic/electromagnetic sensor). So, I decided to emulate that for this project.

  • 1 Arduino Uno R3 SMD
  • 1 HC-SR04 4-pin Ultrasonic Distance Sensor
  • Slideswitch
  • Arduino Piezo Buzzer
  • 10 kΩ Resistor
  • 330 Ω Resistor
  • Red LED
  • 1 Green LED
  • Jumper Wires (3 red, 5 black, 2 blue, 2 yellow, 2 white, 1 green [in lieu of black, as per convention])
Circuit Schematic and Simulation

The first step was to prepare a circuit schematic on TinkerCAD. Basically, the digital input took the form of a slideswitch feeding into a digital input pin (pin 12) through a 10 kΩ pull-down resistor. Analog Input (which I later discovered was actually a digital input) came from the Echo pin of the Ultrasonic sensor (pin 8), while the ultrasonic pulses were triggered from pin 9. Pin 7 and PWM Pin 5 controlled the digital-controlled Green LED and the analog-controlled Red LED respectively, while the buzzer output was from PWM pin 5.

Figure 1: Component Simulation View

Figure 2: Schematic View

TinkerCAD also has a handy simulation functionality, that even allows to upload the Arduino code and test how the circuit would work under simulator conditions. This definitely helped in fixing bugs before even testing with the actual circuit, and also helped to individually simulate each component before assembling together.

Usage and Implementation

So, the “parking sensor” is first switched on with a slideswitch, which simulates the gear being changed. The green LED turns on, indicating that the sensor is now switched on.

The analog part works by taking the reflection times reported by the ultrasonic sensor, which is converted to distance using the speed of sound. The distance is mapped to the brightness of the red LED and the frequency of repetition of beeps from the buzzer.

The circuit was assembled almost identically to the above schematic. As I had run out of black jumper wires, I substituted using a green jumper wire, as per convention. No other connections made use of green jumper wires. Other than the convention of red for live / black for neutral, I had additional conventions of my own: blue for inputs, white for digital outputs, and yellow for analog outputs.

Figure 3: Front View

Figure 4: Top View

Figure 5: Arduino Pins Connection

int distance = 0;
int duration = 0;
int brightness = 0;
int minDistance = 5;
int maxDistance = 30;

int digitalIn = 12;
int trigger = 9;
int echo = 8;
int green = 7;
int red = 5;
int buzzer = 3;

// Ultrasonic Function
long readUltrasonicDistance(int triggerPin, int echoPin)
  pinMode(triggerPin, OUTPUT);  // Clear the trigger
  digitalWrite(triggerPin, LOW);
  // Sets the trigger pin to HIGH state for 10 microseconds
  digitalWrite(triggerPin, HIGH);
  digitalWrite(triggerPin, LOW);
  pinMode(echoPin, INPUT);
  // Reads the echo pin, and returns the sound wave travel distance in centimeters
  return 0.01723 * pulseIn(echoPin, HIGH);

void setup()
  pinMode(digitalIn, INPUT);
  pinMode(green, OUTPUT);
  pinMode(red, OUTPUT);
  pinMode(buzzer, OUTPUT);

void loop()
  if (digitalRead(digitalIn) == HIGH) {
    digitalWrite(green, HIGH);
    distance = readUltrasonicDistance(trigger, echo);
    if (distance < maxDistance && distance != 0) {
      duration = map(distance, 0, maxDistance, 5, 60);
      brightness = map(distance, 0, maxDistance, 220, 0);
      analogWrite(red, brightness);
      tone(buzzer, 523); // play tone C5 = 523 Hz for 100 ms
      if (distance > minDistance){
        delay(duration); // Wait for (duration) millisecond(s)
    } else {
      analogWrite(red, 0);
    delay(10); // Wait for 10 millisecond(s)
  } else {
    digitalWrite(green, LOW);
    analogWrite(red, 0);

The code is not too different from the examples we did in class, other than the function for the Ultrasonic Sensor. For that, I followed this helpful tutorial on the Arduino Project Hub.



I enjoyed working on this project, although figuring out the Ultrasonic Sensor and debugging it did take a while. I was actually impressed by how sensitive the sensor turned out to be, and how it managed to sense even objects passing perpendicular to its field of view (as demonstrated towards end of demo). Thus, other than being a parking sensor, it does actually work as a rudimentary safety sensor, being able to detect pedestrians as well.

I originally wished to include another LED (a yellow one that would fade with distance and a red that would trigger at a threshold minimum distance), but I ran out of black jumper wires and viable space on the breadboard, so I cut it down to two. Also, not shown in the showcase itself is an issue that the circuit has with powering off. Possibly due to the built-in delays, it takes a while between the switch turning to off position and the LEDs themselves actually turning off.

Also, I realized only later that Ultrasonic Sensors technically are digital inputs, but since they transduce an analog measurement into a digital input, I felt that it worked for the scope of this project.

Week 10: Pulse Beat

For this assignment, I wanted to recreate the human pulse / heartbeat. The blinking of the LEDs represents the ‘lub-dub’ sound of our heartbeat and the sound of the piezo buzzer represents our heart rate or pulse. When the button is pressed, the LEDs blink in a pattern synchronized with the buzzer. The potentiometer enables users to adjust the speed of the blinking pattern and the pitch of a piezo buzzer. So turning up the potentiometer symbolizes increasing the heart rate.


Schematic Diagram:

Arduino Code:

const int buttonPin = A2;          
const int potentiometerPin = A0;   
const int buzzerPin = 12;          
const int ledPin1 = 7;   //red         
const int ledPin2 = 8;   //green         

int buttonState = LOW; //digital input
int potValue = 0;  //analog input
int blinkSpeed = 500; //LED blink speed

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(buzzerPin, OUTPUT);
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);

void loop() {
  // Read the value of the potentiometer and map it to blink speed range (100-1000 ms)
  potValue = analogRead(potentiometerPin);
  blinkSpeed = map(potValue, 0, 1023, 100, 1000);

  buttonState = digitalRead(buttonPin);
  if (buttonState == HIGH) {  //button pressed
    // Play a tone with frequency based on blink speed
    int buzzerFrequency = map(blinkSpeed, 100, 1000, 500, 1500);
    tone(buzzerPin, buzzerFrequency);
    delay(50);  // Buzz for 100 milliseconds
    noTone(buzzerPin);  // Turn off the buzzer
  } else { //button released
    digitalWrite(ledPin1, LOW);
    digitalWrite(ledPin2, LOW);

void blinkPattern() {
  digitalWrite(ledPin1, HIGH);
  digitalWrite(ledPin1, LOW);
  digitalWrite(ledPin2, HIGH);
  digitalWrite(ledPin2, LOW);

Overall, I am happy with the outcome. I was relieved to see it finally work because I was trying everything (debugging, restarting circuit, etc.) for 4 hours before I realized my 5V wasn’t connected in properly.

I further want to create more audio-visual displays using LEDs and the piezo buzzer.

Assignment #10 – Reading Response – Less Rules More Art

In a sense, all art is interactive. The typical definition given to «interactive» is one that we have discussed in previous readings. As Chris Crawford had mentioned in «The Art of Interactive Design», he believes that interactive art is interactive when and only when both entities listen, think, and speak. Similarly, this is what the author of Making Interactive Art: Set the Stage, Then Shut Up and Listen» points to. The key here is to create a conversation, a dialogue between the artist and the viewer. When the artist over-interprets their own work, they force the viewer to listen and think in a certain way, without letting them speak.
In philosophy of art, what makes art different from other, technical, disciplines is that the process is part of the art. There are no pre-imposed rules to create art – the artist just creates as they go. This is where the place of the spectator is important. When there are no rules imposed, it means that the final result is never determined in advance. In that case, the whole process of creating an artwork becomes the artwork. The result becomes influenced by the interaction with the audience. And, even if there isn’t a visual shift after the audience’s reaction, it is the act of listening to your audience and letting them think and speak for themselves that conceptually alters the course of the artwork.