Category: Spring 2024 – Aaron (Section 001)

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();
}

For my first Arduino-based assignment I wanted to incorporate the use of an ultrasonic sensor to generate an interaction for the user based on their presence alone. My initial idea was to have the output in the form of a message displayed on an LCD screen – I even wired up the circuit for this idea as shown below. However I was unable to figure out how to link information from the sensor to the LCD screen and decided to try a new approach.

In an attempt to simplify things for myself while maintaining the idea of detecting someone’s/something’s presence, I decided to create a ‘personal distance machine’ which tells users when something is too close for comfort. To do this I replaced the LCD screen with a buzzer and an RGB light which changes incrementally from green to yellow to red depending on the distance detected by the sensor. Below is an excerpt from the code as well as an example video.

void loop() {
  distance = getDistance();   //variable to store the distance measured by the sensor

  Serial.print(distance);     //print the distance that was measured
  Serial.println(" in");      //print units after the distance

  if (distance <= 20) {                       //if the object is close

    //make the RGB LED red
    analogWrite(redPin, 255);
    analogWrite(greenPin, 0);
    analogWrite(bluePin, 0);
     tone(buzzerPin, 272);  


  } else if (20 < distance && distance < 40) { //if the object is a medium distance

    //make the RGB LED yellow
    analogWrite(redPin, 255);
    analogWrite(greenPin, 50);
    analogWrite(bluePin, 0);

  } else {                                    //if the object is far away

    //make the RGB LED green
    analogWrite(redPin, 0);
        analogWrite(greenPin, 255);
    analogWrite(bluePin, 0);
        noTone(buzzerPin);   
  }

https://youtube.com/shorts/5y1aWPqcZVg?feature=share

For my first Arduino project, I was struggling to find ideas that didn’t involve my hands. I looked around my room, trying to utilize what I already have, and searched for objects that require the use of the body (not hands) to function. Which is when I saw my trash can! The idea was simple, create a circuit that closes when I press down on the trash can to open, and the circuit opens when I remove my foot. I used two foil pieces one stuck to the ground and one to the bottom of the trash can lever, allowing them to intersect and close the circuit when I press down with my foot. 

Additionally, the code was pretty straightforward, exactly what we’ve been doing in class:

const int ledPin = 2;
const int foilPin = 3;

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(foilPin, INPUT);
  Serial.begin(9600);
}
void loop() {
  int buttonState = digitalRead(foilPin);
  Serial.println(buttonState); 
  digitalWrite(ledPin, buttonState); 
}

Overall, the code functions by reading the state of the aluminum foil switch and uses that info to control the state of the LED (high/low). When the switch is closed, the LED turns on, and when the switch is open, the LED turns off.

However, I faced several issues during my project:

Error messages from IDE kep showing up, after multiple attempts to troubleshoot (going back and forth between Arduino and IDE) I decided to restart my laptop and Arduino board which ended up solving the issue.

My second issue was that the Led light stays on regardless of the foils touching or not, it’s like the circuit was complete or was not relying on the foils. However, when the foils do touch the led light gets brighter which meant there was an intervention from the foils but not exactly what I’m looking for. I tried to find ways to trouble shoot this but ended up giving up after going back and forth with the code and the board. 

Here’s a Demo:IMG_6092 2

Concept

For this assignment, my goal was to create a miniature car sensor system using Arduino. The system uses ultrasonic sensors to detect objects/vehicles and provide feedback to the user using RGB LED, similar to the sensors used in modern cars for reversing or parking assistance. Components used include: Arduino Board, Breadboard, Ultrasonic Sensors, RGB LED, 330Ω Resistors, and Jumper Wires.

Overview

if (distance <= 10) {
    //red
    analogWrite(redPin, 255);
    analogWrite(greenPin, 0);
    analogWrite(bluePin, 0);
  } else if (10 < distance && distance < 20) {
    //orange
    analogWrite(redPin, 255);
    analogWrite(greenPin, 50);
    analogWrite(bluePin, 0);
  } else {
    //green
    analogWrite(redPin, 0);
    analogWrite(greenPin, 255);
    analogWrite(bluePin, 0);
  }

• Distance Measurement: With some googling, I learned that ultrasonic sensors emit high-frequency sound waves and measure the time it takes for the waves to bounce back after hitting an object. Based on this time measurement, the system calculates the distance to the obstacle.
• Visual Feedback: The RGB LED is used to provide visual feedback to the user based on the distance readings from the sensors. The LED changes color to indicate the proximity.
• Consistency: the Arduino continuously monitors the distance readings from the sensors & updates the LED color accordingly. In reality or with the vision I had in mind, this real-time feedback would help the driver to move the vehicle carefully, especially in tight spaces.

IMPLEMENTATION

As the vehicle/object moves, the ultrasonic sensors detect obstacles in the path and passes on distance measurements to the Arduino. The Arduino then processes the distance readings and controls the RGB LED to provide real-time visual feedback to the driver. This is possible thanks to the loop that continuously retrieves distance measurements & adjusts the LED colors accordingly. I also came across echoTime which represents the duration for which the ultrasonic sensor receives an echo signal after emitting a sound wave, pretty cool!
– Red: Stop the vehicle immediately.
– Orange: Proceed with caution, slowing down if necessary.
– Green: Continue driving as the path is clear.

Conclusion

Tiny but mighty, it was quite enjoyable to create this miniature system. Although I may have accidentally followed the description of next week’s assignment and realized it a few minutes ago, I learned a lot. As a driver, I understand the importance sensors play in parallel parking and avoiding hitting a curb. Therefore, I wanted to contribute to improving this aspect in terms of accuracy. After encountering some obstacles, I resorted to Core Electronics on YouTube as a guide for this assignment. Overall, I had hoped to attach the sensors to the front or rear bumper of an actual vehicle and test the accuracy, but step by step, I’ll hopefully create something greater!