Category: Spring 2024 – Aaron (Section 001)

“Physical Computing’s Greatest Hits (and Misses)”

The review of recurrent project themes in educational settings captures the fine line between redundancy and innovation. Igoe’s encouragement for students to breathe new life into old ideas resonates with me, as it emphasizes the importance of creativity and personal expression in learning which is something that I feel strongly about. Personally, I find the discussion about the longevity and adaptability of simple projects like the Theremin and video mirrors particularly engaging. These projects, while simple, serve as a testament to the foundational skills being taught and the creativity they can unlock. The idea that a simple gesture, like moving your hand over a sensor, can create music or alter images is both magical and empowering. The section on video mirrors struck a chord with me; it’s described as the “screen-savers of physical interaction,” which is both amusing and apt. It underlines how some projects may lean more towards aesthetic value than interaction depth, but still hold significant educational value in terms of the skills they teach and their ability to engage viewers.

Moreover, Igoe’s mention of projects that have become almost iconic within the community, like the Drum Gloves and Mechanical Pixels, highlights an interesting aspect of physical computing: its blend of technology and tangible, interactive art. This intersection is where I see a lot of personal and academic growth potential, bridging the gap between technical skills and artistic expression.

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

This article also resonates with me because it champions the idea that art is not just an artist’s expression but a dynamic interaction. The artist’s role shifts from being a narrator to a facilitator who sets up the environment and then steps back to let the audience interact and derive their own meanings. The author persuasively argues against the traditional view of art as a static expression, pointing out that interactive art should be more like a conversation or a performance that evolves. The analogy of the artist as a director who does not strictly dictate but rather guides actors (or participants, in this case) allows for a genuine, emergent experience. This perspective is enlightening as it underlines the shift from passive consumption to active engagement. I appreciate Igoe’s emphasis on the importance of simplicity and clarity in setting up interactive environments. The directive to “arrange the space” thoughtfully and to “remove anything extraneous” serves as a crucial guideline for creating an immersive and intuitive experience. This approach ensures that each participant’s interaction is meaningful and personal, rather than overshadowed by the artist’s own interpretations or expectations.

Moreover, the concept of listening to how people interact with the artwork—and the notion that these interactions might change over time—adds a layer of complexity to the creation and exhibition of interactive art. It suggests that the artwork is not complete upon its initial display but continues to evolve and resonate differently as people engage with it.

In order to demonstrate both digital and analog input processing, my project uses an Arduino Uno to control two LEDs depending on input from an analog photo resistor and a digital pushbutton. The circuit consists of a pushbutton that activates the system when pressed and a photoresistor that controls the state of a red and a green LED by measuring the amount of ambient light. Pressing the button causes the system to come alive, activating a flag that maintains the LEDs’ responsiveness to light variations. The green LED shines in brighter lighting, while the red LED flashes in low light to signify darkness.

This is my code:

// Define pin numbers
const int buttonPin = 2;     // Digital pin connected to the button
const int redLEDPin = 3;     // Digital pin connected to the red LED
const int greenLEDPin = 4;   // Digital pin connected to the green LED
const int photoResistorPin = A0; // Analog pin connected to the photoresistor

bool ledsActive = false;  // State variable to keep track of LEDs' activity

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(redLEDPin, OUTPUT);
  pinMode(greenLEDPin, OUTPUT);
}

void loop() {
  int buttonState = digitalRead(buttonPin);
  int lightLevel;

  // Check if the button is pressed
  if (buttonState == HIGH) {
    ledsActive = true;  // Remember that LEDs should be active
  }

  // Control LEDs based on the 'ledsActive' state
  if (ledsActive) {
    // Read light level from the photoresistor
    lightLevel = analogRead(photoResistorPin);
    
    // Determine which LED to keep on based on light level
    if (lightLevel < 512) {  // Threshold for light level can be adjusted
      digitalWrite(redLEDPin, HIGH);  // Turn on red LED if dark
      digitalWrite(greenLEDPin, LOW); // Turn off green LED
    } else {
      digitalWrite(redLEDPin, LOW);   // Turn off red LED if bright
      digitalWrite(greenLEDPin, HIGH); // Turn on green LED
    }
  } else {
    // Turn off both LEDs if the LEDs should not be active
    digitalWrite(redLEDPin, LOW);
    digitalWrite(greenLEDPin, LOW);
  }
}

And this is the setup of my Arduino:

I really enjoyed playing around with the photoresistor in this project and seeing how variations in the surrounding light dynamically affected the LEDs’ behavior, providing a concrete example of how electronic components interact with their surroundings. In addition to adding another level of interest, this investigation into light sensitivity helped me gain a deeper comprehension of analog sensors. Nevertheless, I did struggle with a couple of things. At first, I had trouble wiring the circuit correctly and dealing with connections that were wrongly placed in incorrect places on the breadboard. Even though they were annoying, these errors taught me a great deal about circuit design and debugging and made me realize how important it is to pay close attention to detail when working with electronics.

Please view the video to visualize how my project works:

“Physical Computing Greatist Hits and (misses)” is a compilation of recurrent physical computing themes that are popular and integrated into many projects. Reading this article at this stage in the class was important for me as I contemplated the range of things one could do with a simple Arduino kit. I do indeed find myself quite compelled to ditch ideas that used common physical interaction principles because they were simply too common. Instead of thinking of the novel ways one could use an input to a sensor, I frequently found myself looking for the least used sensor to incorporate in my future projects. I realize now, after reading the article, that it is more important what one does with input from a human interaction, rather than focusing on the complexity of the circuitry or the parts used. It also allowed me to see the various ways in which one could combine different themes together to create original work (e.g. video mirrors and mechanical movements in Soyoung Park’s Waves of Leaves).

“Making Interactive Art: Set the Stage, Then Shut Up and Listen” establishes a necessary shift of perspective for those who are designing human-computer interactive pieces. As someone who grew up dabbling in artistic projects, from composing poetry in my journal to oil landscape paintings and abstract multi-media pieces to adorn the walls of my room, I reflect on the prescriptive nature of those early artworks. It centered me, the artist, in the meaning-making process of the art. My central focus in making them was that those who came into contact with them were able to easily discern what I wanted them to discern. Designing interactive art, however, involves the ability to make space for the audience to insert themselves into the piece. The trick lies in designing a piece that is effectively able to accommodate all the different reactions it garners. This involves being able to predict people’s possible responses, perhaps aided by some process of user testing, and planning accordingly. Providing users with precisely the minimum amount of guiding context that affords them a sense of agency that operates within the predefined parameters the piece was designed to accommodate is truly an art that is worth mastering.

I’ve always had this theory that if aliens ever visited Earth 👽, they’d mistake our art galleries for some silent, sacred worship spaces. I mean, where else will you find humans voluntarily hushed, tiptoeing about like they’re scared of disturbing the air itself?

Then I read the article by Tom Igoe, “Making Interactive Art: Set the Stage, Then Shut Up and Listen,” and it actually made me totally reconsider my previously formed opinion but from another point of view. Maybe our future cosmic friends would understand that in the quietude of an art space, there’s a loud, unspoken conversation between human and creation. And that’s precisely what Igoe is advocating for – an unscripted, raw dialogue where the artwork doesn’t just speak but listens too.

In “Making Interactive Art: Set the Stage, Then Shut Up and Listen,” Igoe takes a poke at would-be über-ambitious creators who helicopter-parent their creations. I can’t help smiling at his blunt advice not to interpret your own work.

It sounds very much as if one would tell a parent, “Yeah, you gave birth to it, but don’t you dare tell it what to be!” 😂

What an interesting notion, as I have to do the complete opposite more often than not in my professional life as a computer engineer: spoon-feeding users about what to do with my creation. I once preached in the IM class on exactly that, remember? “If an app needs a manual, you’ve done it wrong.” Yes. That point Tom made about the art being “a conversation,” not a monologue, is a beauty. You don’t dictate; you just help guide the process.

Now, moving on to “Physical Computing’s Greatest Hits (and misses),” it was really hard not to chuckle at the analogy Igoe is trying to make of evergreen themes of projects and how they could be recycled.

It’s like that old joke about there being only seven original plots  in all of literature 😂 (Yes, there are only seven types of stories in the world, according to some) . Sure, we’ve seen a hundred theremin-like instruments or video mirrors, but it’s the individual spin—that touch of personal madness—that makes them fresh and edgy. It’s like cooking; the same stuff can come up with many different flavors. And, as a computer engineer, I’ve seen too many cliché tech implementations. This idea is literally a breath of fresh air.

What really floats my boat, and tickles my pickles in this article is that Igoe gives a subtle nod toward the creative process.Even in the most clichéd themes, there’s a window for innovation. This is somewhat comforting, especially when one has to look at yet another “innovative” app idea that feels like déjà vu. This makes me think that maybe it’s not what you build but how you spin it.

In both articles, Igoe offers insightful perspectives on art and interactivity that echo many of my own beliefs. As creators, our job is not to impose but to propose. We set the stage, provide the tools, and in the most beautiful act of humility, we step back and let the symphony of interaction play. In that symphony is learning, growth—a perennial scope of innovation. Time to make more systems, in art and technology, that don’t just talk at us, but with us.

Because the best kind of conversation isn’t the one in which you’re the only one speaking.

I found both articles very interesting and it was fun reading both, maybe that was partly because they were written by the same person. In any case, starting with the “shut up, and listen” article; I have always found the interpretation of art to be a tricky subject. Mainly because I don’t believe that many of the interpretations that people see in the artwork were thought up by the artist him or herself. Often I get annoyed by some of the interpretations that people come up with since I feel it is so far from the original art but recently that has been less the case. The reason is, and also this is what I kept thinking about while reading the article, is that I have recently begun to think of art being able to stand on its own. What do I mean by that? Well, I mean that an artist isn’t really the creator of the artwork, but rather he is more a spectator. I say this because of one main reason (there are others but I can’t describe or explain it in detail and with clarity), an artist does not really come up with the idea of the artwork out of nowhere, he can say what “inspired” him but I believe inspiration are only things that resemble the idea not that the inspiration was the source of the idea. In thinking about this I searched to see if there were any quotes or artists that were quoted as saying something that fits/resembles my opinion.

“I saw the angel in the marble and carved until I set him free.” – Michelangelo 

“I never know what I’m going to put on the canvas. The canvas paints itself. I’m just the middleman.” – Peter Max

Of course not every artist or person is of the same opinion, but had it not been for the article I just read I would have never thought deeply about this.

As for the other article; I didn’t have thoughts or ideas that were as philosophical. As I was reading I realized that this article would be a great help for when we make the musical instruments using the Arduino’s after the Eid break. I also thought of how facial recognition could be used nowadays. Since the article was made in 2012 facial recognition was not nearly as advanced or reliable so the closest thing to that was the video tracking and the other things that were mentioned. Just something to think about.

My Project Idea:

I decided to build a project using an Arduino board that can detect when I wink. At first, I thought about making something that could sense how close my body was to a sensor. Later on in class, my teacher mentioned we shouldn’t use sensors for this project because that’s not what DigitalRead is about. So, I had to think of something else. That’s when I thought about how I often wink without even realizing it. I figured, why not turn that into my project? Surprisingly, setting up the breadboard, which I thought would be tough, turned out to be easier than I expected.

How It Works:

1. Circuit Setup: I attached two small pieces of aluminum foil in a way that they sit close to my eye, one above and one below. These foils are connected to the Arduino board. I also connected a green LED to the Arduino, which acts as the output signal.
2. Detecting the Wink: When I wink, the eyelid movement causes the two pieces of aluminum foil to touch. This touch closes the circuit, similar to pressing a button, but it’s my wink that makes it happen.
3. Interacting With the Project: To interact with my project, all I have to do is wink. The aluminum foil pieces make contact, the Arduino notices the change, and the green LED lights up in response.
4. Feedback: The lighting up of the green LED serves as immediate feedback that my wink was detected. It’s a simple and effective way to communicate the input action.
   Some challenges that I faced with this project are:

1.  Getting the aluminum foil just right so it detects winks without false triggers from other facial movements was tricky.
2. Keeping the foil safe and comfortable to wear around my eye needed thoughtful setup and possibly skin-friendly materials to avoid irritation which is why I opted to use a bandaid, which still seemed to irritated the area around my eyes.

Project Video:

IMG_5451 2

For this assignment I have created a switch that activates an LED light when two jumper wires come into contact with a conductive liquid. Initially utilizing saltwater due to its well-known conductive properties, the project later incorporates laban, showcasing the project’s versatility and the unexpected utility of common substances in electronics. The switch operates on the principle that when the liquid completes the circuit between the two wires, the LED is powered on, demonstrating a basic but effective application of electrical conductivity and circuit design.

Concept:

The concept revolves around the exploration of electrical conductivity in liquids and the application of this property in creating an unconventional switch. Conductivity in liquids is often associated with the presence of ions. Saltwater, being rich in ions, is a good conductor of electricity. On the other hand, laban, while less conventional, also contains various salts and minerals that can facilitate the flow of electricity, making it a surprising but effective choice for this experiment.

How It Works:

Circuit Setup: The project utilizes an Arduino board as the control unit, a simple LED light as the output indicator, and two jumper wires inserted into two separate GPIO (General-Purpose Input/Output) pins on the Arduino. One of these pins is set up as an input to detect the circuit’s completion, while the other serves to provide a low voltage signal. The LED is connected to another GPIO pin on the Arduino, configured as an output.

Conductive Medium: The circuit is initially open, meaning the electrical path is incomplete, and the LED remains off. The introduction of a conductive medium (saltwater or laban) bridges the gap between the two jumper wires, allowing current to flow through the liquid and complete the circuit.

Detection and Response: When the Arduino detects the completion of the circuit through its input pin, it triggers the LED to turn on. This response acts as a visual indication that the circuit has been completed through the conductive medium.

Experimentation and Learning: By experimenting with different liquids like saltwater and laban, users can learn about the properties of electrical conductivity in a hands-on manner.

Video:

IMG_5445

Image:

I spent hours trying to think of a concept until it eventually occurred to me. To be very honest, I’m happy with the result, but I wanted to challenge myself further and attempt to learn more about Arduino. My original plan was not to blow a charm into the jumper cable to achieve the light produced by the LED, but since my code was crashing and my Arduino board stopped working all of a sudden, I had to modify my plan. I had to make the most of my limited time to do my task.

Naturally, investing a significant amount of time to complete this “unusual switch” project enabled me to become comfortable with the Arduino board concept overall. While this wasn’t how I intended to become familiar with it, the experience was still an eventful rollercoaster. Moreover, I decided to incorporate a very memorable part of my childhood a charm of the Arc De Triomphe. France was a huge part of my childhood and still is, something that everyone finds shocking is that my first language surprisingly was French (I know crazy right?). Furthermore, I wanted to combine a partial part of my life into this project as well.

Something I’d like to improve on in the future is trying to figure out why the brightness of my LED was so dim and not that bright. Overall, I’m pleased with the outcome, and the fact that I get to include something somewhat special was pleasing.

Unusual switch

const int led0 = 11; // LED connected to digital pin 11
const int touchSensorPin = 3; // Touch sensor (white wire) connected to digital pin 3

void setup() {
  pinMode(led0, OUTPUT); //LED as output
  pinMode(touchSensorPin, INPUT_PULLUP);
}

void loop() {
  if (digitalRead(touchSensorPin) == LOW) {  // if touch sensor detects physical contact
    digitalWrite(led0, HIGH); // Turn on LED
  } else {
    digitalWrite(led0, LOW); // Turn off LED
  }
}

Before this assignment I spent a lot of time trying to brainstorm different ideas, I wasn’t really sure what to do until the last minute to be honest. Some of my ideas were if you say a specific word the switch triggers, or if you’re nodding off or maybe just a sound trigger, but none of those ideas seemed very original or interesting. Thankfully I ended up coming up with an idea I feel is far more unique.

When thinking about different limbs (other than my hands) and which I could move to cause the switch to turn on I eventually landed on my ear. Unlike most people I have the ability to slightly move my left ear. Not enough to be very noticeable but enough to have two contacts connect or disconnect.

The plan was to connect one wire to my glasses and one wire to the side of my head. I chose to do this because I noticed that when I do move my ear it also moves my glasses. Therefore, the switch would be turned on when I don’t move my ear as the glasses would be in its normal position, and the switch would be turned off once I move my ear.

Above is the finished product when it is not attached to me. The red wire on the bottom left is what I attach to my head with electrical tape and it is supposed to touch the copper contact that you can see on my glasses. You may also notice that on the breadboard there are two LEDs, one red, one blue. The red LED turns on when current is flowing between the contacts. Then the blue LED is connected to the Arduino. When the current is flowing a signal is sent to the Arduino, then the output is sent to the blue LED. I made it such that the blue LED flickers when current isn’t flowing, i.e. when I move my ear.

Making this was very tedious especially getting the wire on my head to stick and also because sometimes I had to take my glasses off while working on the project. Fortunately while writing this my glasses are on but I didn’t attach the red wire. Unfortunately, when I do attach the red wire it is slightly uncomfortable so I’ve decided to keep it disconnected until the last moment. There are also other problems with my design: The wires easily move around, I rely heavily on electrical tape to keep everything in place, and to make sure everything works I have to adjust my glasses as well since if they move then the switch no longer works, also the wires are messy. Since this is only a prototype problems are expected. Regardless I’m surprised at how well it works, for people who don’t realize I’m moving my ear it looks like I’m using my mind alone to control the light.

Thank you Aadhar the lab assistant for helping me with getting wires of the right length and finding electrical tape. And, thank you ChatGPT for writing the flicker code.

Code:

// PINS //
const int powerPin = 2;
const int outputPin = 3;
// ---------- //

// GLOBAL VAR //
int val = 0;
int outputVal = 0;
bool flicker = false;
// unsigned long time;
unsigned long previousMillis = 0;   // ChatGPT
const long interval = 200;
// ---------- //

void setup() {
  // note to self, returns either HIGH or LOW
  pinMode(powerPin, INPUT);
  pinMode(outputPin, OUTPUT);

  
  // Serial.begin(1000); // Begins serial communication with my computer

}

void loop() {
  // DIGITAL READ //
  val = digitalRead(powerPin);
  digitalWrite(outputPin, outputVal);
  // // ---------- //

  // time = millis();
  unsigned long currentMillis = millis(); // get the current time

  // Test
  // if(val == LOW) {
  //   outputVal = LOW;
  // } else {
  //   outputVal = HIGH;
  // }

// turn on later 
  if (currentMillis - previousMillis >= interval) {
      // save the last time you blinked the LED
      previousMillis = currentMillis;
      flicker = !flicker;
  }

  if(flicker && val == HIGH) {
    outputVal = HIGH;
  } else {
    outputVal = LOW;
  }

  // Serial.println();
}