Month: November 2025

Thinking about the artwork “Remote Hugs”, I believe current physical computing devices are incapable of understanding and replicating human emotions due to their complexity. Emotions are constructed through a series of events that occur throughout one’s life, and we need to comprehend each event to truly understand and simulate one’s emotions. Since Remote Hug does not have the capability to analyze people comprehensively, I think it cannot replicate human warmth. Even the author mentioned that they were not able to understand the motivation behind it. Thus, I believe we need to integrate deep learning or machine learning mechanisms into such affective computing devices to better understand one’s emotional states.

In terms of the second reading, I disagree with the author in the sense that we should not completely let the audience interpret the meaning and purpose of an artwork on their own. I used to be a big fan of this idea, but that idea changed after I went to teamLab. When I visited teamLab, I experienced all the immersive artworks there but I was confused about what they were trying to convey and what kinds of experiences they wanted me to have. At the end of the day, I was completely lost and feeling dizzy heading back to campus. I think the essence of an artwork is to guide the audience through the experience, allowing them to connect it with their own personal thoughts and emotions. It goes back to the discussion we had about how we can incorporate randomness into artwork. As an artist, I think it is important to have a clear motivation and purpose behind the artwork and to guide the audience in how to interpret it.

Concept

So basically, I made this little setup where I can control two LEDs using a knob and a button. One fades in and out smoothly when you twist the knob, and the other just pops on and off when you hit the button. It’s honestly pretty straightforward, but it was actually kind of fun to put together.

Demo

How It Works

The Knob: There’s a potentiometer, when you turn it, one of the LEDs gets brighter or dimmer. Twist one way and the light fades down, twist the other way and it gets brighter.

The Button: The other LED is even simpler. Press the button, light’s on. Let go, light’s off. That’s it.

Code

int pushButton = 2;
int led1 = 4;
int potentiometer = A5;
int led2 = 3;
void setup()
{
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(pushButton, INPUT);
pinMode(potentiometer, INPUT);
}
void loop()
{
// digital sensor (switch) controlling ON/OFF state of LED
int buttonState = digitalRead(pushButton);
if (buttonState == HIGH){
digitalWrite(led1, HIGH);
}
else if (buttonState == LOW) {
digitalWrite(led1, LOW);
}
// analog sensor (potentiometer) controlling the brightness of LED
int potValue = analogRead(potentiometer);
int brightness = map(potValue, 0, 1023, 0, 255);
analogWrite(led2, brightness);
}

Concept

For this week’s assignment, I worked on building a Study Tracker that turns study and rest into clear, color-coded cues so I can keep my attention steady. The buttons each control one of the LED’s, making them flash when pressed then stop again signaling study and break depending on the button pressed. The LED flashing means the student is in a break and the blue LED flashing means the student is focused. While the the dial to set the brightness so the lights fit the time period of the studying, softer at night and stronger during the day. Over time the repeated pairing of blue with study and red with rest builds a simple habit, so the colors start to set the mood before a student begins studying.

Demonstration

IMG_7760

Code Snipped

//Map potentiometer to brightness
  int potValue = analogRead(potPin);
  int brightness = map(potValue, 0, 1023, 0, 255);

  //Button 1
  bool button1State = digitalRead(button1Pin);
  if (button1State == LOW && lastButton1State == HIGH) {
    led1Flashing = !led1Flashing; 
    if (!led1Flashing) {
      analogWrite(led1Pin, brightness); 
    }
    delay(200);
  }
  lastButton1State = button1State;

  //Button 2
  bool button2State = digitalRead(button2Pin);
  if (button2State == LOW && lastButton2State == HIGH) {
    led2Flashing = !led2Flashing;
    if (!led2Flashing) {
      analogWrite(led2Pin, brightness);
    }
    delay(200);
  }
  lastButton2State = button2State;

Brining together the different elements we learnt in class, I believe that this part of the code to me was exploring how there are countless ways to combine techniques and create something new. Which reminded me of this week’s reading which discussed the value of building up on existing works rather than worrying about creating something did not exist before. Creating something functional and different from the simple parts given to us is possible.

Complete Code

Github Link

Schematic

Reflection

During this assignment, exploring both digital and analog input, was interesting in discovering how they can interact together to add depth and dimension to the work. The difficult part to me was coming up with a way to creatively merge both of these elements while not having them crash with each other. In future work, I’d like to explore more sensors and switches and integrate them into my work, there were several ones we dicussed in class that I would like to explore.

Concept:

For this week’s assignment, I made the Plant Care Assistant. It helps users monitor their plant’s water needs through simple visual feedback. A green LED will light up when the sun exposure is high(simulate with flashlight from phone). A red LED will ligzht up when the sun exposure is low(simulate with moving away flashlight from phone). When users click the yellow button, if it flashes yellow, then the plant is in good state and if it does not flash at all, the plant needs to be taken care of.

Code:

int ledFlashOn = 11;   // led on pin 11 flashes if the plant has enough sunlight
int ledFlashOff = 12;  // led on pin 12  flash red if the plant doesn has enough sunlight
int sensorPin = A2; //sensor pin for the light sensor 

void setup() {
  Serial.begin(9600);
  pinMode(ledFlashOn, OUTPUT);
  pinMode(ledFlashOff, OUTPUT);
}

void loop() {
  int sensorValue = analogRead(sensorPin); //gettign the value of the pin 
  Serial.println(sensorValue); //printing t in the serial monitor

  if (sensorValue > 950) { //if sensor value is greater than 950 
    digitalWrite(ledFlashOn, HIGH); //light up green dont light up red
    digitalWrite(ledFlashOff, LOW);
  } else {
//light up red dont light up green   
    digitalWrite(ledFlashOff, HIGH);
  }

  delay(50); // small delay for stability
}

Concept

This project uses one digital sensor (a toggle switch) and one analog sensor (an LDR) to control two LEDs. The toggle switch turns a green LED fully on or off, and the LDR controls the brightness of a yellow LED. The darker it gets, the brighter the LED becomes.

Demo

Schematic

Code Snippet

void loop() {
  // Switch controls green LED
  int switchState = digitalRead(switchPin);
  if (switchState == LOW) {
    digitalWrite(greenLED, HIGH);
  } else {
    digitalWrite(greenLED, LOW);
  }

  // Analog part: light sensor controls yellow LED brightness
  int lightVal = analogRead(ldrPin);
  int brightness = map(lightVal, 0, 1023, 255, 0); // darker room = brighter LED
  Serial.println(brightness);
  analogWrite(yellowLED, brightness);
}

Reflection and Future Improvements

This project helped me clearly see the difference between analog and digital inputs: the LDR smoothly controls LED brightness while the switch simply turns the other LED on or off.  Moving forward, I’d like to try adding more outputs, like a buzzer or an RGB LED, to make the reactions more expressive.

Physical Computing’s Greatest Hits and Misses

Reading “Physical Computing’s Greatest Hits” made me realize that I don’t always have to invent something completely new. I learned that common projects are “hits” for a good reason. They are popular because they create a very clear and intuitive link between what a person does and what happens next. It showed me that these projects are powerful building blocks for learning, not just simple exercises to be done once and forgotten.

This article changed how I think about my own creative work. I used to worry a lot about being totally original, but now I see it’s more important to focus on the feeling or experience I’m creating. It’s okay to use a familiar idea, like a glove that senses movement, as long as I use it in a way that feels surprising or meaningful. It’s a relief to know that the human experience is more important than the technology itself.

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

The main lesson I learned from “Making Interactive Art” is that my job isn’t to tell the audience what to think or do. My first instinct is usually to explain everything so people “get it,” but this reading showed me that’s the wrong way. Instead, my role is to “set the stage” and to provide the space, the objects, and maybe a few hints. The real art isn’t just the thing I built. It’s the experience that people have when they explore it for themselves.

This approach means I have to “shut up and listen,” which requires a lot of trust. I have to trust that my design gives enough clues and trust that the audience will be creative. It helped me see that when people use my project in a way I didn’t expect, it’s not a failure, it’s a discovery. This makes the audience a partner in the art.

Most modern discoveries are build on foundational concepts that have been around for years. We are nothing without the knowledge of those who came before us. Which is why it is very insightful to dive into the previous works in the field of physical computing, going through the best and the not so best inventions and creations. Everyone is fixated on creating the next new thing that we forget the importance of building on and improving previous works and ideas. Through reading about these works, I was without a doubt inspired for future projects on how to integrate physical computing. It brought to my attention crucial elements that I would have otherwise overlooked such as the importance of balancing aesthetics and functionality. Projects such as the video mirrors had aesthetics as the central focus foregoing any structural interaction. While the lack of valuable interaction is a valid concern, it did get me thinking on the importance of interaction and if there is value that comes from aesthetics that makes overlooking interaction the correct move. This ties in with themes from the previous readings that discussed the balance between aesthetics and functionality, a concept which I believe were put to the test in these projects.

“Set the Stage, Then Shut Up and Listen” is a harsh message to the artists of interactive art, yet it is an important one as well. Creating interactive art is a collaborative effort, like a puzzle where the artist only has half the pieces and needs to guide the participants so they could place the remaining ones.  It is a reflection of the creator of the work as well as every person that choses to interact with it. A dynamic conversation where the artists becomes primarily a listener, following the guide of the consumers of their work. It is tempting to share the message behind a work, especially when you spent a long time developing it and integrating a message within it. Though, how can you conclude and solidify a message when the work has not been interacted with and spoken to from outside contributors. On the other hand, I do think that it is important to find a balance, where there is a foundational message that the work is being built on, one that can be altered and developed by outsiders. As without a strong foundation a project is at a risk of being void of a message to be build on by the participants. Once again, we are in a position where a balance is crucial to the building of a meaningful and engaging work.

Physical Computing’s Greatest Hits (and misses) 

Reading Tigoe’s article on “Physical Computing’s Greatest Hits (and Misses)” gave me a new appreciation for how simple ideas can be both educational and engaging in physical computing. I found it interesting that recurring themes, like theremin-like instruments, gloves, floor pads, and video mirrors, aren’t just repeated because they’re easy, but because they allow for creativity and experimentation. Even projects that seem simple, like LED displays or mechanical pixels, can produce surprising, beautiful, or playful results when combined with unique designs or gestures. I also liked how the article emphasized that physical computing focuses on human input and experience rather than just the machine’s output, which makes the interaction more meaningful and enjoyable.

I was especially inspired by projects that blend physical interaction with emotional or playful elements, such as remote hugs, interactive dolls, or meditation helpers. These projects show how technology can respond to people in subtle ways, creating experiences that feel alive or personal. I can see how many of these themes, like body-as-cursor or multitouch surfaces, could be adapted to new ideas, highlighting the importance of creativity over originality. Reading this made me think about how I might design my own physical computing projects, focusing on the human experience, interaction, and the joy of discovery rather than trying to invent something completely new from scratch.

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

This reading helped me understand that interactive art is fundamentally different from traditional art. It’s not about presenting a fixed statement; it’s about creating a space or instrument where the audience can explore and participate. I found it interesting that the artist’s role is to suggest actions and provide context without telling people what to think or do. The comparison to directing actors made this clear: just as a director provides props and intentions, interactive artists set up the environment and let participants discover meaning through their actions. I realized that this approach makes the audience an essential co-creator of the artwork.

I was inspired by the idea that interactive art is a conversation between the creator and the audience. It made me think about how designing for discovery and participation can lead to more meaningful and engaging experiences. I liked how the reading emphasized listening to the audience, observing their reactions, and letting the work evolve based on their interaction. This approach feels very open and collaborative, encouraging creativity both from the artist and the participants. It made me consider how I could apply this perspective to projects or experiences I create, focusing on engagement and exploration rather than fixed outcomes.

My Concept:

For this project, I wanted to control two LEDs using sensors in a creative way. One LED would respond to a potentiometer, changing its brightness based on how much I turned it. The other LED would respond to a pushbutton, turning on or off each time I pressed it. The idea was to combine analog input (potentiometer) and digital input (pushbutton) to control outputs in two different ways. I also wanted to make sure everything was wired properly on the breadboard with the Arduino so it all worked together. At first, I wanted to do a breathing light where it kind of switches on and off gradually like it’s a human breathing, but it took me hours to try and it still wasn’t working, so that was a big challenge for me, because I couldn’t figure it out. I had to try a couple of times and it wasn’t giving me what I wanted. So, I decided to stick on to the simple foundation of it, because i realized I needed more time to get comfortable with using the potentiometer and switch.

Video Demonstration: 

assignment_week9.mov

Hand-Drawn Schematic: 

Code I’m most proud of:

// Pin Definitions 
const int potPin = A0;       // Potentiometer middle pin connected to A0
const int buttonPin = 2;     // Pushbutton connected to digital pin 2
const int greenLedPin = 8;   // Green LED connected to digital pin 8 
const int blueLedPin = 9;    // Blue LED connected to digital pin 9 

// Variables 
int potValue = 0;           // Stores analog reading from potentiometer
int ledBrightness = 0;      // Stores mapped PWM value for blue LED
int buttonState = HIGH;     // Current reading of the button
int lastButtonState = HIGH; // Previous reading of the button
bool greenLedOn = false;    // Green LED toggle state

void setup() {
  pinMode(buttonPin, INPUT_PULLUP); // Enable internal pull-up resistor
  pinMode(greenLedPin, OUTPUT);
  pinMode(blueLedPin, OUTPUT);
  
  Serial.begin(9600); 
}

void loop() {
  //Read potentiometer and set blue LED brightness
  potValue = analogRead(potPin);                   // Read 0-1023
  ledBrightness = map(potValue, 0, 1023, 0, 255); // Map to PWM 0-255
  analogWrite(blueLedPin, ledBrightness);         // Set blue LED brightness

  // Read pushbutton and toggle green LED 
  buttonState = digitalRead(buttonPin);

  // Detect button press (LOW) that just changed from HIGH
  if (buttonState == LOW && lastButtonState == HIGH) {
    greenLedOn = !greenLedOn;                       // Toggle green LED state
    digitalWrite(greenLedPin, greenLedOn ? HIGH : LOW);
    delay(50);                                     // Debounce delay
  }

  lastButtonState = buttonState;

The code I’m most proud of is  basically the overall code where the green LED toggles ON/OFF with the pushbutton while the green LED changes brightness with the potentiometer. It was tricky at first because the button kept flickering, but I solved it with a debounce and I asked chatgpt to help me on what I had wrong and why this might have been happening. Here’s the code: 

I’m proud of this code because it solves the switch problem elegantly; the green LED reliably turns on and off without flickering, while the blue LED smoothly responds to the potentiometer. It made me feel like I had full control over both analog and digital inputs in the same circuit.

Reflection and Improvements:
This project taught me a lot about wiring and sensor behavior. One big challenge was the pushbutton;  at first, it would flicker, or the LED would turn on/off unexpectedly. Also, when I tried pressing the button with my finger, the breadboard wires kept moving because there were so many of them. Eventually, I realized using a pen to press the button made it much more stable and consistent.

For future improvements, I’d like to:

• Use more organized jumper wires to make the breadboard less messy
• Maybe add more sensors or another LED with creative behaviors
• Explore smoother debouncing techniques in software to make the switch even more responsive

Even with the challenges, seeing both LEDs working together exactly how I wanted was really satisfying. It showed me how analog and digital inputs can interact with outputs, and how careful wiring and coding logic are equally important.

Github Link: 

https://github.com/deemaalzoubi/Intro-to-IM/blob/c9dc75423cd71b8ea21d50a5756c4d5e7f420ba5/assignment_week9.ino