Month: April 2024

In this post, you will find each individual reading reflection assigned for week 10. These reflections will be mostly based on my experiences, so actual discussion on the contents of the writing will be somewhat limited since I feel that it would be redundant to summarize what is there.

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

Generally, I associate the term Interactive Art with video games. According to the article, we are not supposed to readily give interpretation of our own works due to possibly adding bias and making boring the interactive experience for others. For example, in mysterious abstract video games, I have seen authors avoid giving full explanations to seemingly inconclusive questions in order to keep conversations, theories, and engagement alive. In a confusing title such as OFF (Mortis Ghost, 2008) the world that it presented is full of mysterious elements. At first sight is difficult to give an explanation to, nevertheless it invites the player to give its own reasoning to this interactive art.

As for other interactive art mediums, I often found myself walking on the corridors of the Arts Center building to see some interesting digital arts, such as a screen that portrays me in symbols. There are many other examples, but what they have in common is that they apply the concept of “show, don’t tell” that I really love about video games, since it leaves the spectator/player alone with the interactive art. In other words, it is a personalized experience: I will find an interactive digitalized portrait of myself super thought-provoking, while a friend could just find it funny. Different experiences, but there is not a fixated idea due to not having the author directly explain it to us as to why the existence of the created interactive art.

Physical Computing’s Greatest Hits (and misses)

During my time as a child, I have seen a correlation between success and devices that challenge pre-established formulas. For example, in today’s world (today as at the time I am writing this) computer mouses are generally used due to facilitating the computer experience, it facilitated it so much that the entire computer GUI landscape adapted to it. It acts as a “third hand” that gets materialized into the digital world, where if you want to “grab a file”, you just have to hold the mouse with one of your fingers in order to simulate the action of grabbing. It was a great hit, but what about other technologies that try to revolutionize or seek general fun?

I would like to imagine a James Bond like hand watch as a replacement for the watches we have now, such as the Apple Watch. One finds (small) pleasure in using the watch to quickly watch the time and timely arrange the next activities to do, as well as it also looks and feels nice to have due to the possible elegance it possesses. But what about making it a very curious device, such as the one that James Bond has? Imagine this: you have a clock that looks impressive, thus it is pleasurable to wear, but also has a laser, camera, and magnetism included on it. Yes, one can easily argue that this idea is already done to death in many series and movies as an inspiration, but still, one can find other workarounds to this theoretical watch; a remix act. So, instead of creating an actual James Bond like that shoots lasers, what about throwing confetti in miniature? One could find pleasure in annoying friends and family with the functionality.

In conclusion, I found this article curious as I noticed some patterns in successful products, such as the indirectly mentioned Dance Dance Revolution Dance Pads in the writing. The world of physically interactive art has its market, because it is pleasurable and fun to experiment with items one might never be seen before.

Introduction

For this week, I tried to imagine something complex to do, but due to creative bankruptcy, I could not imagine any interesting mechanisms for this Arduino. Although, I still wanted to experiment with what we have learned in class so far.

When we were experimenting with the photoresistor, I was curious to see what kind of patterns I could make with the use of the device, LEDs, and the mapping function. Thus, I came with the idea of doing a volume meter inspired light detector.

Figure #1: Arduino made in person.

Materials

• • 7 330-ohm resistors.
  • 2 green LED lights.
  • 1 yellow LED light.
  • 1 red LED light.
  • 1 blue LED light.
  • A breadboard.
  • 8 red jumper wires (due to being low in red jumper wires, three are yellow).
  • 7 black jumper wires (again, due to being low, 2 are white).
  • 2 blue jumper wires.
  • An Arduino board with, 5V, GND, analog and digital output and input.
  • A slideswitch.

Implementation & Usage

Once all the materials are set up like in the schematic and the Arduino is powered, the user can do either of the following according if the slideswitch is ON or OFF:

1. If the slideswitch is ON, a blue LED will indicate this state. In this mode, if a light source is redirected to the photoresistor, the LEDs will turn on, like a volume meter, depending on the strength of the source.

2. If the slideswitch is OFF, the blue LED light will be off, indicating this state. In this mode, a non-interactable sequence where each LED light will be displayed, where they will be turning ON and OFF in a 0.5 second basis.

Both modes can be interrupted at any time.

Schematics

Figure #2: Schematic #1 made in Tinkercad.

Figure #3: Schematic #2 made in Tinkercad.

Code

For the coding, I used the blocks GUI from Tinkercad, and then transform it into code to change it according to my necessities, as well as add some comments to it to further explain some functionalities.

//We will only use two variables for this Arduino set up:
//Brightness is to receive the analog values from the photoresistor, to use to turn ON the LEDs.
//Switchstate will alternate between states depending on the analog valaue received.

int brightness = 0;
int switchstate = 0;

void setup()
{

  // Preparing the Arduino and variables initialization.
  pinMode(A0, INPUT);
  pinMode(A1, INPUT);
  Serial.begin(9600);
  pinMode(3, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(12, OUTPUT);

  brightness = 0;
  switchstate = 0;
}

void loop()
{
  switchstate = analogRead(A0);

  // According to the amount of light received by the photoresistor, it will turn on the LEDs. For example,
  //if the light source is too strong, all LEDs will turn on, if it is too low, either 1 or 2 will be ON.

  if (switchstate > 1013) {
    digitalWrite(12, HIGH); // Blue LED indicates light mode.
    brightness = analogRead(A1); //Receive values from the photoresistor.
    Serial.println(brightness); //and print it to serial.
    if (brightness > 100) {
      analogWrite(3, map(brightness, 0, 1023, 0, 300)); //First green LED will be turn on and its intensity will depend on the intensity of the light source. Also, we map the values received since if it is too high, then it will basically loop; mapping makes sure that it always states in a range.
      if (brightness > 200) {
        analogWrite(5, map(brightness, 0, 1023, 0, 300)); //Second green LED will be turn on and its intensity will depend on the intensity of the light source. The rest is the same.
        if (brightness > 300) {
          analogWrite(6, map(brightness, 0, 1023, 0, 300));
          if (brightness > 400) {
            analogWrite(9, map(brightness, 0, 1023, 0, 300));
          } else {
            digitalWrite(9, LOW);
          }
        } else {
          digitalWrite(6, LOW);
        }
      } else {
        digitalWrite(5, LOW);
      }
    } else {
      digitalWrite(3, LOW); //If it fails to meet the requirement, the it will turn OFF without exceptions. It is the same for the rest of LEDs.
    }


  } else {
    // Each LED gets turn on and off in order.
    digitalWrite(12, LOW); // Blue LED gets shut down.
    digitalWrite(3, HIGH);
    delay(500); // Wait for 500 millisecond(s)
    digitalWrite(3, LOW);
    digitalWrite(5, HIGH);
    delay(500); 
    digitalWrite(5, LOW);
    digitalWrite(6, HIGH);
    delay(500); 
    digitalWrite(6, LOW);
    digitalWrite(9, HIGH);
    delay(500); 
    digitalWrite(9, LOW);
    Serial.println(switchstate);
  }
}

Showcase

In this video, I show how the Arduino looks and operates. Please keep in mind that the color of some jumper wires had to be mixed up (at least strategically) due to material constrains, in order to still convey the positive and negative connections.

Challenges

The biggest challenge in this Arduino was, actually, making the photoresistor to work. The reason of this difficulty was that I had forgotten how to set up the photoresistor properly, even though we were taught how to do so in class. Although, with a YouTube video and quick review of the slides, I was able to pick up again what I needed to do and not question myself why I was getting a consistent analog value of 1024 from my photoresistor.

Reflection

I am feeling that I am going a bit bankrupt creatively. I do admit that this Arduino took me time to develop, but the many ideas I had in my mind are still not able to come into fruition. Likewise, I personally feel that this is like the previous scenario in the first half of this semester, where I was mostly experimenting with the provided tools in order to have a greater idea of what is possible to do. It is likely it will happen in this case, but still, I wish I could come with more ideas to develop more curious devices.

Nevertheless, I did learn something new from this Arduino, like how to effectively map some values and how to set up properly a device (ignoring the selection of colors of the jumper-wires of course) to capture values from two points: the photoresistor and the slideswitch.

Thanks for reading this and have a happy day.

I although I find that the subject of “Making Interactive Art: Set the Stage, Then Shut Up and Listen” is well meaning, it think that to an extent, it misses the reason why some artists interpret their own interactive works.

Coming from a mainly computer science background, its hard for me to see my programs being misused in a way that I did not intend. To me, this feels like failure, which in a way it is, as I have failed to design a program which accurately and correctly executes what it is supposed to. This is why I emphasize with artist who offer interpretation notes beside their work, as they too are hoping that it will be used or viewed in the “right” way, the way that they intended, as a way to prevent their “failure”.

However, the big difference here is that what they are doing is art, and not computer science. In computer science, the focus is often on precision, functionality, and predictability. A program that doesn’t work as intended is considered flawed and needs debugging or refinement.

Art, on the other hand, often thrives on ambiguity, interpretation, and the emotional response it elicits from its audience. Interactive art, especially, invites the audience to engage with it, to become part of the artwork’s evolution and meaning. This inherently means that the artist relinquishes some control over the final outcome.

When an artist provides interpretation notes or guidelines alongside their interactive art, it can be seen as a way to guide the audience’s experience or to share their perspective. However, it’s essential to remember that art is subjective. Each viewer brings their own background, experiences, and emotions to their interpretation of the artwork. This diversity of interpretation can enrich the artwork’s meaning and create a more profound connection between the viewer and the art.

Rather than viewing unintended interactions or interpretations as failures, artists can see them as opportunities for growth, learning, and further exploration of their art’s potential. It can lead to unexpected outcomes that even the artist hadn’t considered, expanding the artwork’s scope and impact.

For this assignment, I wanted to make something a bit funny. Thus, I decided to make a light switch powered by light. My idea was simple, point an LED at an LDR, record its readings, and light up another LED at the brightness the LDR recorded.

Unfortunately, after building by circuit, I ran into an issue with the Arduino, where it would not read anything from the IN pins and would not allow me to print anything to the terminal either.

Not to be discouraged, I decided to build the entire circuit in analog.

Had I been able to use the analog IN pins, my code would have looked like this.

// Define the LDR pin
const int ldrPin = A0;
// Define the digital LED pin
const int digitalLedPin = 13;

// Variable to store the LDR value
int ldrValue = 0;

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

void loop() {
  // Read the analog value from LDR
  ldrValue = analogRead(ldrPin);
  
  // Print the LDR value to Serial Monitor
  Serial.print("LDR Value: ");
  Serial.println(ldrValue);

  // Set the brightness of the digital LED based on the LDR value
  analogWrite(digitalLedPin, map(ldrValue, 0, 1023, 0, 255));

  // Add a delay to avoid flooding the Serial Monitor with data
  delay(500);
}

Additionally, I noticed that the who design does not work very in lit environments, so I wanted to add a function which would calculate the average light in a room, and set the output LED to 0, so that a change in lighting from the other LED would be more noticeable. This, however, is impossible to do with my understanding of analog circuits.

For this week’s assignment, I used potentiometer as an analogue sensor, and a tactile button as a digital sensor (switch) and two LEDs. For the LED that is controlled by the tactile button, I made it so that it blinks twice and the potentiometer for brightness control.

Code:

int led = 11;
void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  Serial.begin(9600);
  pinMode(led, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(A2, INPUT);
}

// the loop function runs over and over again forever
void loop() {
  int button1State = digitalRead(A2);
  int sensorValue = analogRead(A1);
  
  Serial.println(sensorValue);

  analogWrite(led, sensorValue/4);
  delay(30);

  if (button1State == HIGH) {
    digitalWrite(8, HIGH);
    delay(1000);
    digitalWrite(8, LOW);
    delay(1000);
    digitalWrite(8, HIGH);
    delay(1000);
    digitalWrite(8, LOW);
    delay(1000);

  } else if (button1State == LOW){
    digitalWrite(8, LOW);
  }

}

Video:

This idea of not over-explaining your interactive artworks really struck a chord with me. I’ve definitely been guilty of that in the past – spelling out too many specifics about what different elements “mean” and how people are “supposed” to interact with them. But as the author points out, doing that pretty much defeats the whole purpose. You’re just dictating how the audience should think and experience the piece, instead of leaving room for them to explore and interpret it themselves.

I can vividly remember one interactive installation I saw that fell into this trap. It looked really cool – these conductive surfaces that would trigger light patterns when you touched them. But then the description plaque gave you this long, explicit walkthrough of the precise sequence you “should” follow when engaging with it. It ended up feeling really prescriptive and took away from the sense of curiosity and spontaneous discovery that initially drew me to the work.

The author’s point about interactive art being the “start of a conversation” between the artist and viewer resonated so much. Rather than a static, finished product, it’s meant to be this open-ended exchange where the audience’s live participation and personal perspectives complete the experience. Kind of like a director setting up a premise and suggestions for the actors, but then letting them organically find their own emotional truths within that framework.

Moving forward, I really want to embrace that spirit of intentional ambiguity in my own interactive work. Instead of strictly defining roles and meanings, I should focus on crafting intriguing environments, suggestive arrangements of elements, and potential pathways to explore – but then step back and allow diverse interpretations to emerge organically through self-directed engagement. Creating prompts for personal dialogue rather than dictating conclusions. It’s a shift in mindset, but one I think will lead to much richer, more interactive experiences.