Category: F2023 – Mang

Physical Computing’s Greatest Hits (and misses)

Tigoe delves into a range of ‘physical computing’ projects in his article, “Physical Computing’s Greatest Hits (and misses).” I found this piece to be particularly beneficial, treating it as a brainstorming session for ideas on my final project. Exploring the diverse examples of projects was not only interesting but also provided inspiration for potential directions in my own work. One particularly noteworthy aspect of Tigoe’s perspective is his emphasis on the intrinsic beauty of recurring themes in physical computing. Rather than viewing the repetition of certain ideas as a deterrent, Tigoe encourages a nuanced perspective. He suggests that newcomers should recognize the vast potential for injecting individuality and creativity into these themes. What resonates with me is Tigoe’s assertion that repetition need not be perceived as a limiting factor. Instead, he reframes it as an open invitation to innovate — an opportunity to build upon existing concepts, introduce new elements and refine established ones. This perspective fosters a dynamic and progressive approach to physical computing projects, emphasizing the continuous evolution and enrichment of the field through creative contributions.

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

In “Making Interactive Art: Set the Stage, Then Shut Up and Listen” interactive art, is described as, is nothing short of orchestrating a living conversation. It’s not just a canvas where an artist dumps their thoughts; it’s a dynamic exchange where both creator and audience actively contribute. What struck me the most in this article is the call to resist the temptation to over explain. It’s an invitation for artists to step back after crafting the initial experience and allowing people the space to unravel its layers on their own. I used to think that you had to know how to interpret a piece of art to fully enjoy it. But over time, I’ve come to realize that not knowing is sometimes better than knowing. There’s no one right way to perceive an experience, and by trying to dictate it to the audience, you limit their perspective. This approach to interactive art feels really freeing. It’s all about breaking away from a fixed narrative and embracing the unpredictable beauty of individual interpretations. It’s not about telling people what the art means; it’s about co-creating an experience that’s as diverse and dynamic as the people engaging with it.

For this week’s assignment, I drew inspiration from traffic lights. I aimed to replicate their functionality using a potentiometer for analog input and a button for digital input. The potentiometer serves to control the transition of the LED lights, mimicking the sequence of a traffic light as it turns from red to yellow and then to green. Additionally, pressing the button initiates a special state where all three lights blink simultaneously. 

Video Demonstration

link to the video: https://drive.google.com/file/d/1gREpijAMYFY12Yk4Ann_fiJzZrkjL-z1/view?usp=sharing

Code

The code uses the concepts of analog reading, digital input, LED control, and mapping to create a dynamic and interactive traffic light simulation.

const int analogSensorPin = A0;
const int digitalSensorPin = 2;
const int redLEDPin = 6;
const int yellowLEDPin = 9;
const int greenLEDPin = 11;

//variables to store sensor readings
int analogSensorValue;
int digitalSensorState;
int trafficLightState = 0; // 0: red, 1: yellow, 2: green

void setup() {
  pinMode(analogSensorPin, INPUT);
  pinMode(digitalSensorPin, INPUT);
  pinMode(redLEDPin, OUTPUT);
  pinMode(yellowLEDPin, OUTPUT);
  pinMode(greenLEDPin, OUTPUT);
}

void loop() {
  analogSensorValue = analogRead(analogSensorPin);

  digitalSensorState = digitalRead(digitalSensorPin);

  //toggle traffic light state on button press
  if (digitalSensorState == HIGH) {
    // Blink all lights together
    digitalWrite(redLEDPin, HIGH);
    digitalWrite(yellowLEDPin, HIGH);
    digitalWrite(greenLEDPin, HIGH);
    delay(500); // Blink duration
    digitalWrite(redLEDPin, LOW);
    digitalWrite(yellowLEDPin, LOW);
    digitalWrite(greenLEDPin, LOW);
    delay(200); // Debouncing
  } else {
    //map potentiometer value to traffic light state
    trafficLightState = map(analogSensorValue, 0, 1023, 0, 2);

    //control traffic light LEDs based on state
    if (trafficLightState == 0) {
      //red light
      digitalWrite(redLEDPin, HIGH);
      digitalWrite(yellowLEDPin, LOW);
      digitalWrite(greenLEDPin, LOW);
    } else if (trafficLightState == 1) {
      //yellow light
      digitalWrite(redLEDPin, LOW);
      digitalWrite(yellowLEDPin, HIGH);
      digitalWrite(greenLEDPin, LOW);
    } else if (trafficLightState == 2) {
      // green light
      digitalWrite(redLEDPin, LOW);
      digitalWrite(yellowLEDPin, LOW);
      digitalWrite(greenLEDPin, HIGH);
    }
  }
  delay(50);
}

I enjoyed working on this assignment since there were numerous ways to modify the LEDs’ behavior. The only challenging aspect was recording the video, as the potentiometer is a bit tough to turn, and it ends up rotating the entire breadboard with it :/

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

The author points out that people often mix up the real idea behind interactive media and art. Art usually constitutes people expressing their own feelings and emotions whereas interactive media installations usually urge the viewer to come up with their own interpretation, part of the installation is the viewer coming up with a creative interpretation based on their own observations. In my opinion, this concept can be applied to all sorts of art to create a more interesting and captivating experience for the viewers as they unconsciously start relating the art piece to what they want to see. I took a class last year that discussed the idea of close-viewing paintings with zero context. We were not allowed to know who the artist was, when the painting was drawn, in which country it was drawn, the title, nothing. Our final project was to go to the Louvre and each choose a painting and close-view it for an hour and take notes of what we believed was the story behind the painting and the message the painter wanted to send through the painting, before actually reading the description of the painting. During the presentations, I remember that everyone had come up with these amazing and extreme interpretations of their piece that actually had no correlation at all to the description written by the painter. I was surprised by how different everyone’s interpretation can be depending on what their background is, what they currently have on their mind, what their hobbies and interests are, etc. I believe that giving your viewer the space to come up with their own interpretation makes the art experience more enjoyable and relatable to them.

Physical Computing’s Greatest Hits (and misses):

This author lists and describes the most recurring themes in physical computing as of 2008. I have to be honest most of these themes I have seen before, but nevertheless some of them were new to me. I realize that sometimes the best projects stem from the simplest of ideas that incorporate user engagement. I agree that physical computing may seem limited but it is a very broad area and even using creativity to enhance an already existing idea would take it to another level, turning it into an impressive project. I wonder how the rapid evolution of artificial intelligence and machine learning models since this article has affected physical computing projects and installations and how it has enhanced the accessibility of the projects. The article leaves me wondering what new ideas of human interaction could be employed using artificial intelligence and what other possibilities lie ahead in a future of ever evolving technology.

Physical Computing’s Greatest Hits (and misses)

What made this reading very interesting for me is that It’s all about those recurring themes in physical computing classes, and I must say, I have a soft spot for them. There’s something truly special about the way they offer a playground for creativity and innovation.

What really tickles my fancy is how Tigoe encourages us not to view these recurring themes as stale or unoriginal. Instead, he invites us to look at them as blank canvases ready for our artistic interpretation. It’s like he’s saying, “Hey, don’t shy away from these themes – they’re your chance to shine!”

Now, when we talk about themes like “Theremin-like instruments” and “Gloves,” I can’t help but get excited. I mean, who wouldn’t love the idea of creating music simply by waving their hands around? It’s not just cool; it’s a testament to the magic of human-computer interaction. And those dance pads inspired by Dance Dance Revolution? They’re pure nostalgia and joy wrapped up in a project. It’s like turning your favorite pastime into an interactive art form.

But it’s not all about play; there’s an element of challenge too. Tigoe talks about how we can add meaning to these themes by creating a physical form and context that turns simple gestures into something meaningful. That’s where the artistry comes in. It’s about infusing technology with a touch of human emotion.

And let’s not forget “LED Fetishism.” I mean, who can resist the allure of those blinking LEDs? It’s like a canvas waiting to be painted with light. The possibilities are endless, and it’s a guilty pleasure for tech enthusiasts like me. You can turn a simple LED into a work of art if you let your creativity run wild.

In the grand scheme of things, this article is a reminder that technology can be a tool for self-expression and creativity. It’s a canvas, and these recurring themes are like a familiar backdrop that sets the stage for our innovation. So, what’s not to like about that? It’s an invitation to turn everyday actions into interactive adventures, and I’m all in for that kind of excitement!

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

When I read this piece, it’s like a little reminder that sometimes, as artists, we tend to over-explain our creations. We put our hearts and souls into our work, and it’s only natural to want to guide others in understanding it. However, this article argues that in interactive art, there’s a beauty in leaving room for interpretation.

You see, interactive art isn’t just about creating a statement; it’s about sparking a conversation. It’s about building a stage where the audience becomes the actors. The artist sets the scene, provides the props, but then steps back and lets the audience take the spotlight.

It’s a bit like a director working with actors. You can’t tell an actor exactly how to feel or what to do to convey a particular emotion authentically. You can guide them, suggest intentions, but the true interpretation and expression come from within them. The same goes for interactive art. You design the environment, you set the stage, but you don’t need to hand-hold the audience through every step.

Instead, you offer them the basic context, suggest sequences through placement, and then let them explore. It’s like a silent invitation, a conversation between the art and the viewer. What you’ve created becomes a canvas for their emotions and thoughts.

And it’s not a one-way street. As the audience interacts with your work, they become part of this ongoing dialogue. Their reactions, their understanding, their misunderstandings – it’s all part of the artistic conversation. Some may be moved emotionally, while others might not immediately grasp the message. Some may even inspire and teach others about the work.

It’s a dynamic process, much like a performance. The audience becomes an integral part of your creation, shaping it with their responses. In a way, the art isn’t truly complete until the audience has added their unique layer to it.

Concept

For this week’s assignment, I drew inspiration from Mood Lamps. Mood Lighting helps create a calming and soothing atmosphere and can invoke different moods depending on the colors you set it at. I’ve tried to create a very basic version of this.

Process

My idea was to use an RGB Led, a digital switch for digital input and a potentiometer for analog input for this. However, certain values of potentiometer readings did not work and hence I added separate green and yellow LEDs that would light up instead. There is a circular ring of moods around the potentiometer. You can move the arrow towards the mood you’d like to set it up at. The potentiometer values are mapped to rgb values that are then displayed on the RGB Led. If the digital switch is pressed, alot of colors get displayed automatically. In this case the mapping is between time and the rgb values

I had some trouble figuring out the working of the digital switch but with some references and trial and errors, I eventually figured it out to work somewhat like desired.

code:

void setup() {
  pinMode(RGB_RED_PIN, OUTPUT);
  pinMode(RGB_BLUE_PIN, OUTPUT);
  pinMode(RGB_GREEN_PIN, OUTPUT);
  pinMode(GREEN_LED_PIN, OUTPUT);
  pinMode(YELLOW_LED_PIN, OUTPUT);
  pinMode(SWITCH_PIN, INPUT);  

  Serial.begin(9600);  
}

void loop() {
  int switchState = digitalRead(SWITCH_PIN);
    Serial.print("Switch State: ");
Serial.println(switchState);

  if (switchState == HIGH) {

     int currentTime = millis();
  int period = 3; 
  int rgbValue = map(currentTime % period, 0, period, 0, 1535);

  // convert the RGB value to individual color components
  int red, green, blue;

  if (rgbValue < 256) {
    red = 255;
    blue = rgbValue;
    green = 0;
  } else if (rgbValue < 512) {
    red = 511 - rgbValue;
    blue = 255;
    green = 0;
  } else if (rgbValue < 768) {
    red = 0;
    blue = 255;
    green = rgbValue - 512;
  } else if (rgbValue < 1024) {
    red = 0;
    blue = 1023 - rgbValue;
    green = 255;
  } else if (rgbValue < 1280) {
    red = rgbValue - 1024;
    blue = 0;
    green = 255;
  } else {
    red = 255;
    blue = 0;
    green = 1535 - rgbValue;
  }

  // setting RGB LED colors
  analogWrite(RGB_RED_PIN, red);
  analogWrite(RGB_BLUE_PIN, blue);
  analogWrite(RGB_GREEN_PIN, green);

  

    // separate green LED
    digitalWrite(GREEN_LED_PIN, HIGH);

    //separate yellow LED
    digitalWrite(YELLOW_LED_PIN, LOW);
  } else {
  int potentiometerValue = analogRead(POTENTIOMETER_PIN);
  int rgbValue = map(potentiometerValue, 0, 1023, 0, 1535);

  // potentiometer value to the serial monitor
  Serial.print("Potentiometer Value: ");
  Serial.println(potentiometerValue);

  int red;
  int blue;
  int green;
  
  if (rgbValue < 256) {
    red = 255;
    blue = rgbValue;
    green = 0;
  }
  else if (rgbValue < 512) {
    red = 511 - rgbValue;
    blue = 255;
    green = 0;
  }
  else if (rgbValue < 768) {
    red = 0;
    blue = 255;
    green = rgbValue - 512;
  }
  else if (rgbValue < 1024) {
    red = 0;
    blue = 1023 - rgbValue;
    green = 255;
  }
  else if (rgbValue < 1280) {
    red = rgbValue - 1024;
    blue = 0;
    green = 255;
  }
  else {
    red = 255;
    blue = 0;
    green = 1535 - rgbValue;
  }
  
  analogWrite(RGB_RED_PIN, red);
  analogWrite(RGB_BLUE_PIN, blue);
  analogWrite(RGB_GREEN_PIN, green);

  // separate green and yellow LEDs based on potentiometer value
  if (potentiometerValue >= 340 && potentiometerValue <= 510) {
    digitalWrite(GREEN_LED_PIN, HIGH);  // Turn on green LED
    digitalWrite(YELLOW_LED_PIN, LOW);  // Turn off yellow LED
  } else if (potentiometerValue >= 165 && potentiometerValue <= 342) {
    digitalWrite(GREEN_LED_PIN, LOW);   // Turn off green LED
    digitalWrite(YELLOW_LED_PIN, HIGH);  // Turn on yellow LED
  } else {
    digitalWrite(GREEN_LED_PIN, LOW);   // Turn off green LED
    digitalWrite(YELLOW_LED_PIN, LOW);  // Turn off yellow LED
  }
  
  delay(100);  
  }

  // delay to avoid flooding the serial monitor with data
  delay(100);
}

Reflections

I really enjoyed this and was able to explore different sensors as I tried out the ultrasonic resistor, potentiometer and photoresistor before deciding which one to go forward with. I did have some issues while coding but managed to make something similar to what I had expected. For future improvements, I could maybe use something transparent/translucent to cover the leds and make the light intensify more like in usual lamps.

References

rgb led

For this week’s assignment, my goal was to get more comfortable with the different components of Arduino and making circuits. I decided to use a potentiometer for analog input and a button for the digital. With potentiometer, I aimed to control the dim level of a red LED, and with the button I wanted to control the yellow LED. Here is the result:

Here is my code:

#define LED_PIN_1 8
#define BUTTON_PIN 7

#define LED_PIN_2 11
#define POTENTIOMETER_PIN A1

void setup() {
  pinMode(LED_PIN_1, OUTPUT);
  pinMode(BUTTON_PIN, INPUT);

  pinMode(LED_PIN_2, OUTPUT);
}
void loop() {

  int potentiometerValue = analogRead(POTENTIOMETER_PIN);
  int brightness = potentiometerValue / 4;
  analogWrite(LED_PIN_2, brightness);

  if (digitalRead(BUTTON_PIN) == HIGH) {
    digitalWrite(LED_PIN_1, HIGH);
  }
  else {
    digitalWrite(LED_PIN_1, LOW);
  }
}

It was a simple setup but completing this assignment made me feel more comfortable with Arduino. Also, a big shoutout to the IM Lab assistants and their Saturday vibes💅🏻.

My project this week is fairly simple, and my goal was to just get more comfortable using the components with the Arduino (in preparation for following weeks!). I used an RGB LED controlled by a potentiometer, and a regular LED controlled by a momentary switch to do a little light show.

The RGB LED shines red, green, and blue continuously, but the speed is controlled by the voltage at the potentiometer. The mapping is done as such:

delayTime = map(analogRead(potentiometerPin), 0, 1023, 1, 10);

“Physical Computing’s Greatest Hits (and misses)” was a fun and inspiring read about physical computing and some examples of projects that were done throughout the years. Although this is my first time using hardware to create interactive projects, I have had a lot of enjoyment so far, and reading about these projects motivates me to learn more about Arduino and hopefully come up with my own takes on them. By far the projects that most caught my attention were the theremin-like instruments, the dolls and pets, and the remote hugs. 

First, when it comes to hardware, I believe that instruments are one of the most effective and fun tools to exercise creativity. For instance, the drum glove turns a mundane activity into something that people could actually use to learn drumming and spend their free time with. Not only is it entertaining, but it is also convenient, and I believe that people of all ages would find joy in such a technology. The dolls and pets one is also interesting, and it is something that I see many kids or even adults enjoying depending on the context of the product, such as a physical version of Tamagotchi which could captivate both Millennials and Gen Z. Finally, the remote hugs intrigued me. I do not think such a tool would be convenient as a commercialized product, but I do think it opens doors to a set of captivating technologies that could be used in virtual reality games or even in long-distance relationships.

Meanwhile, “Making Interactive Art: Set the Stage, Then Shut Up and Listen” made me reflect on the purpose of interactive art and how it should be conducted to the public. I strongly agree with the author when it comes to how people should approach interactive art. To me, it is intuitive that too much information can ruin an interactive experience. If the author is micromanaging the user and explaining every single detail based on his perspective, then there is no mystery in the project, no room for interpretation, and no way of knowing how people truly approach your work, leaving a diminished experience and a lack of observations.

In his exploration of interactive art “Making Interactive Art: Set the Stage, Then Shut Up and Listen”, Tigoe suggests that meaningful interactive experiences emerge from a delicate combination of guidance and freedom of the participant. He offers an analogy of a director working with actors to illustrate the importance of subtly suggesting intentions without imposing rigid interpretations. Such comparison sparks a reflection about the setting and design of interactive artworks, which drives a question as to how much guidance is sufficient to provide a context without overshadowing individual interpretation? What is the role of physical space and how can an artist set up a design that encourages curiosity and discovery without the need of dictating the narrative? Furthermore, does the setup of the artwork influence the participant’s emotional connection as well as one’s interpretation of the artwork?

This nicely ties in with the “Physical Computing’s Greatest Hits (and misses)” reading. The part about Theremin-like instruments caught my attention, where the author mentions the importance of gestures being meaningful when a participant interacts with the artwork (gesture of moving your hand over a sensor vs a glove where one taps his fingers to make a rhythm). It makes complete sense that less guidance is required when a setup matches with some kind of pre-existing mental model. It highlights the interconnected nature of physical computing and interactive art, emphasizing the importance of aligning design choices with participants’ intuitive understanding for a more seamless and engaging interactive experience.

Physical Computing’s Greatest Hits

In this article what I really like is the floor pads. I think it’s one of the interactive art that’s most used in real-life scenarios and I really enjoy it. It’s set up in most of the arcades in China and I find it fun. I also like the concept of video mirrors. I once read that people tend to think of humanoid shapes as human figures even if they might be very different. Video mirrors are like the reverse of this concept, changing images of people into humanoid shapes. Therefore when people see these humanoid shapes as themselves, more value is added through the composition or the material of these humanoid shapes.

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

I can really relate to this. In my high school, we have literature classes where we are supposed to learn to appreciate, analyze, and interpret literature pieces. At first, when we interpreted it by ourselves we had many different ideas and conclusions. However, when the teacher told us how she analyzed and interpreted it, our own thoughts about the work disappeared and only one interpretation remained. But the thing with art I believe is that it should not have only one “correct answer”. It should be allowed to be openly interpreted by the public, and interpreting your own work kills that possibility. Even if there really is something you want to show to the viewers, it should not be shown through killing the other possibilities of interpretation. I think it is okay to lead viewers to think in a certain way, but it’s completely different than telling the viewers what they should think.