Month: November 2024

Both of this week’s readings explore the common creative challenges and themes in Design and Interactive Media.

Physical Computing’s Greatest Hits (and Misses)

The reading was nostalgic for me as it recounted several projects which I used to do in my school days for exploring the world of electronics. However, these projects are the starting point for many electronic-based fields and have withstood the test of time like Interactive Gloves, LED based projects, Video Mirrors, and so on. The author emphasizes on the fact that these projects are building blocks for other interactive projects and many famous digital works of art are variations of these seemingly simple projects. However, despite their simplicity, by changing one factor or adding another component, the entire project becomes something new. Thus, these ideas might not seem “original”, but can be interpreted in an entirely different manner it takes inspiration from.

What strikes me most in this reading is the challenge of achieving a balance between visual appeal and meaningful interaction. For example, video mirrors are essentially screens that mimic the viewer’s movements and they are captivating to look at, but limited in what they offer interactively. The author raises an important point here: while these types of projects are beautiful, they don’t necessarily provide much depth in interaction. I agree with him because I have experienced the same with my Midterm Project- it was beautiful, but offered limited interaction. I was wound up in the making the project work that I did not think of the project from a user’s perspective.

Another theme that emerges is the idea of adaptability. The author encourages creators to see these “tried – and – true” themes not as stale, but as playgrounds for innovation. This idea of keeping traditional themes fresh is something that really resonates with me. How do we, as creators, continue to reinvent these classics in a way that speaks to new audiences? That is a question which I believe everyone would answer in their own way. For me, I use some basic physics principles with electronics to bring my own twist into my projects.

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

This reading really brings a fresh perspective on an artist’s role. The author challenges creators to move away from interpreting their work or instructing audiences on what to think. Instead, he sees interactive art as a conversation that begins with the artist but is completed by his audience. This concept reminds me of theater, where the director sets the scene but leaves it to the actors to interpret their roles (to allow some freedom in exploring that character). In this case, it’s the audience that gets to step into the role of interpreter, finding their own meaning in the art.

One of the most intriguing aspects of this reading is the emphasis on “letting go of control.” For many artists, this can be challenging because we are often taught that art is an act of personal expression, a statement that’s “ours.” But interactive art, according to the author, flips that on its head – it’s no longer just our statement; it’s a shared experience. The author argues that our job is to give subtle hints, to design a space that encourages discovery, and then to get out of the way. This idea resonates with me because it’s about trusting the audience to bring their own insights and emotions to the work. This encourages me to use subtle hints rather than hard-coded instructions to engage the audience with my work.

 

Concept:

GripSense  is designed to empower recovery and build strength through simple, intuitive grip exercises. Inspired by the resilience required in rehabilitation, it is designed with individuals in mind who are recovering from hand injuries, surgeries, or conditions like arthritis that can limit hand mobility and grip strength. The idea is to create a device that not only helps measure improvement over time but also motivates users to engage in strength exercises by giving real-time feedback and adapting to different levels of force.

Work Procedure:

A squishy ball, embedded with Force Sensor, connected to 5V and Analog Pin A0 on the Arduino through a 1kΩ resistor to ground. This creates a voltage divider, enabling the Arduino to detect varying pressure levels. For feedback, two LEDs are connected: a Light Touch LED on Pin 8 with a 310Ω resistor for gentle squeezes, and a Strong Force LED on Pin 10 with a 310Ω resistorfor firmer grips. Each LED lights up based on the detected force level, providing immediate, intuitive feedback on grip strength.

The Arduino reads these values and provides real-time feedback through LEDs:

• Light Touch LED (Blue): Lights up for a gentle squeeze ensuring the sensor is working.
• Strong Force LED (Yellow): Lights up for a firmer, stronger grip.

Code:

const int forceSensorPin = A0;  // Pin connected to the force sensor
const int lightTouchLED = 8;    // Pin for the first LED (light touch)
const int strongForceLED = 10;  // Pin for the second LED (strong force)

int forceValue = 0;             // Variable to store the sensor reading
int lightTouchThreshold = 60;   // Threshold for light touch
int strongForceThreshold = 300; // Threshold for strong force

void setup() {
  Serial.begin(9600);               // Initialize serial communication at 9600 bps
  pinMode(lightTouchLED, OUTPUT);   // Set LED pins as outputs
  pinMode(strongForceLED, OUTPUT);
}

void loop() {
  // Read the analog value from the force sensor
  forceValue = analogRead(forceSensorPin);

  // Print the value to the Serial Monitor
  Serial.print("Force Sensor Value: ");
  Serial.println(forceValue);

  // Check for strong force first to ensure it takes priority over light touch
  if (forceValue >= strongForceThreshold) {
    digitalWrite(lightTouchLED, LOW);    // Turn off the first LED
    digitalWrite(strongForceLED, HIGH);  // Turn on the second LED
  }
  // Check for light touch
  else if (forceValue >= lightTouchThreshold && forceValue < strongForceThreshold) {
    digitalWrite(lightTouchLED, HIGH);   // Turn on the first LED
    digitalWrite(strongForceLED, LOW);   // Ensure the second LED is off
  }
  // No touch detected
  else {
    digitalWrite(lightTouchLED, LOW);    // Turn off both LEDs
    digitalWrite(strongForceLED, LOW);
  }

  delay(100);  // Small delay for stability
}

Schematic Diagram:

 

 

 

 

 

 

 

Media:

 

 

Reflection and Future Improvements:

In the future, I plan to enhance GripSense with several key upgrades:

1. Secure Sensor Integration: I’ll embed the force sensor inside the squish ball or design a custom 3D-printed casing to hold both the ball and sensor. This will make the setup more professional, durable, and comfortable for users.
2. Add OLED Display for Instant Feedback: I want to incorporate an OLED screen that will show live grip strength data, allowing users to see their strength level and progress instantly with each squeeze.
3. Implement Multi-Level LED Indicators: To make feedback more visual, I’ll add a series of LEDs that light up at different levels of grip strength. For example, green will represent light grip, yellow for medium, and red for strong, giving users an intuitive, color-coded response.
4. Data Logging for Progress Tracking: I aim to add an SD card module to log grip strength data over time, stored in a CSV format. This feature will enable users to track their improvement and analyze their progress with tangible data.
5. Enable Bluetooth or Wi-Fi Connectivity: I plan to incorporate wireless connectivity so that users can view their grip data on a smartphone app. This will allow them to track progress visually with graphs, set goals, and receive real-time feedback, making the recovery journey more engaging and motivating.

These upgrades will help make GripSense a comprehensive, interactive tool that supports and inspires users through their rehabilitation process.

Second Reading:

The idea that interactive art should leave room for the audience to interpret, experience, and even shape it is powerful—and surprisingly challenging. As artists, we’re often conditioned to pour ourselves into our work as a complete expression of what we want to say. But interactive art pushes us to let go of that control, to see ourselves less as “sole authors” and more as facilitators of an experience that isn’t ours alone.

One thing that really resonates with me is Tigoe’s assertion that our role, especially in interactive art, is not to dictate meaning or guide the viewer’s every move, but to create a space where people can explore. I think this goes against the grain of traditional art, where the artist’s interpretation and intent are often front and center. For me, that’s what’s exciting about interactive art: it’s unpredictable. You’re creating an experience without fully knowing where it will go, and you have to be okay with that ambiguity. There’s something freeing about stepping back and letting the audience complete the work in their way, with their own reactions, ideas, and personal connections.

In my own projects, I’ve noticed that the most memorable moments come not from following my own scripts but from watching how others interpret and transform what I’ve made. I remember one piece where I built a simple interactive environment with lights and motion sensors to respond to presence and movement. I’d imagined that people would move slowly through the space, savoring the changing light patterns. Instead, they ran, laughed, and turned it into an almost game-like experience. It wasn’t what I envisioned, but it was better in many ways—more alive, more spontaneous. This unpredictability is what Tigoe captures when he says to “listen” to the reactions and responses. Observing others engage with your work like this gives you insights you couldn’t have planned for, and it makes the artwork feel truly collaborative.

Video Link to final project: https://youtu.be/lS588oI_GPU

Concept

For this assignment, my concept was to simulate a day and night state using 2 LEDs and a photosensor. The digital sensor would be the switch, while the photosensor would be the analog sensor. One light should turn on while the other is off during each state. I was also inspired by this week’s readings, which discussed the idea of not being afraid to draw inspiration from what other artists have created. The articles by Tigoe helped me gather inspiration from various sources on the internet, such as our GitHub page. From there, I was able to develop this day and night simulation prototype.

Design and Execution

The following schematic represents the foundation on which I built this day and night simulator:

After drawing the schematic, I carefully assembled the entire circuit to represent the desired effect. The following code is the loop which allowed the entire idea come to life:

void loop() {
  int lightLevel = analogRead(photoPin); // Read photosensor value
  bool isDay = lightLevel > lightThreshold; // Determine if it's daytime
  Serial.println(lightLevel); // Print light level for debugging

  // Read switch positions
  bool switch1 = !digitalRead(switchPin1); // True if position 1 is active
  bool switch2 = !digitalRead(switchPin2); // True if position 2 is active

  if (switch1) {
    // Position 1: Both LEDs off
    digitalWrite(dayLed, LOW);
    analogWrite(nightLed, 0);
  } else if (switch2) {
    // Position 2: Daytime/Nighttime mode based on light sensor
    if (isDay) {
      // Daytime behavior
      digitalWrite(dayLed, HIGH); // Daytime LED on
      analogWrite(nightLed, 0);   // Nighttime LED off
    } else {
      // Nighttime behavior
      digitalWrite(dayLed, LOW);       // Daytime LED off
      analogWrite(nightLed, lightLevel / 4); // Nighttime LED brightness based on light level
    }
  }

  delay(100); // Small delay to smooth transitions
}

Finally, the project works, and here is a link that demonstrates the final outcome: https://youtu.be/lS588oI_GPU

Final Thoughts and Reflection:

This project allowed me to utilize previous knowledge and to learn and apply new concepts. I believe a great way to improve this project would be to have multiple lights that would react differently for day and night states. The challenge behind this would be wire management, and I believe there is a solution to this problem that I’m still yet to encounter. I am, however, curious about how this could manifest. This exercise is pivotal to my knowledge basket, as it will all contribute to my final project. That’s all for now!

Reflection on “Physical Computing’s Greatest Hits and Misses”

This reading covers both the successes and failures in the field of physical computing. It shows that the best projects are designed to be simple and easy for people to use, while projects that try to be overly complex or focus too much on technology alone often fail. The reading highlights that successful projects blend new technology with a strong focus on what users actually need and find helpful. Reading this, I realized how important it is to keep users in mind when designing, focusing on how they will interact with the system rather than just on the technology itself. When I work on my own projects, this idea of user-centered design can help me make choices that make my designs feel more useful and intuitive. This reflection reminds me to aim for a balance between innovation and usability, focusing on what will make the design easy and enjoyable to use.

 

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

This reading talks about how artists can create interactive art by giving the audience space to explore and interpret the work on their own. Instead of controlling every aspect of the experience, the artist should set up a framework and then let the audience interact with it however they want. This approach lets people bring their own ideas and feelings into the art, creating a more personal connection. I find this approach inspiring because it gives people the freedom to experience the art in their own way, rather than the artist guiding them to a specific idea or feeling. In my own work, I usually try to direct how users should interact, but this reading has me thinking about how allowing more freedom can create a deeper, more meaningful experience. By stepping back and letting users take control, I can create projects that are more engaging and leave room for different interpretations.

Concept

This week, I created a simple switch to control the lights of LEDs both digitally and in an analog way. For the digital control, I used basic switches, and for the analog control, I used a potentiometer. The potentiometer detects and measures the voltage based on how much the knob or slider is turned.

Schematic Diagram

 

Code

// Pin definitions for the RGB LED
const int redPin = 6;
const int greenPin = 5;
const int bluePin = 3;

// Analog input pins for potentiometers
const int redControl = A1;
const int greenControl = A2;
const int blueControl = A3;

void setup() {
  // Set RGB LED pins as outputs
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);

  // Initialize serial communication for debugging
  Serial.begin(9600);
}

void loop() {
  // Read values from potentiometers (0-1023 range)
  int redValue = analogRead(redControl);
  int greenValue = analogRead(greenControl);
  int blueValue = analogRead(blueControl);

  // Map potentiometer values to PWM range (0-255)
  int redBrightness = map(redValue, 0, 1023, 0, 255);
  int greenBrightness = map(greenValue, 0, 1023, 0, 255);
  int blueBrightness = map(blueValue, 0, 1023, 0, 255);

  // Set the brightness of each color channel
  analogWrite(redPin, redBrightness);
  analogWrite(greenPin, greenBrightness);
  analogWrite(bluePin, blueBrightness);

  // Print the brightness values to the Serial Monitor
  Serial.print("Red:   ");
  Serial.print(redBrightness);
  Serial.print("\tGreen:   ");
  Serial.print(greenBrightness);
  Serial.print("\tBlue:   ");
  Serial.println(blueBrightness);
  
  // Short delay to make output more readable
  delay(100);
}

Video Demonstration of my design can be seen below:

Reflection for future works

I am proud of the progress I made in designing and implementing the analog and digital switch controls for the LEDs. This simple project has greatly enhanced my understanding of how these systems work. I look forward to taking on more challenging tasks, particularly those that involve further manipulation of analog signals.

Dynamic Light Play: Interactive LED Control with Potentiometer and Button

Concept

The aim of this project was to use a combination of analog and digital inputs to control two LEDs (one red, one blue) in a creative and functional way. The potentiometer serves as an analog input, allowing us to control the brightness of the red LED, while a button acts as a digital input to control the blue LED. This setup meets the assignment requirement to use at least one analog sensor and one digital sensor, with one LED controlled in an analog fashion and the other in a digital fashion.

Materials Used

• Arduino Uno board
• Breadboard
• Red LED and Blue LED
• Potentiometer (analog sensor)
• Button (digital sensor)
• Resistors:
  • 10kΩ for the button’s pull-up resistor
  • 330Ω for each LED
• Jumper Wires

Arduino Code

 

const int potPin = A0;       
const int buttonPin = 2;    
const int redLEDPin = 9;     
const int blueLEDPin = 8;    

void setup() {
  pinMode(buttonPin, INPUT_PULLUP); 
  pinMode(redLEDPin, OUTPUT);       
  pinMode(blueLEDPin, OUTPUT);      
}

void loop() {
  
  int potValue = analogRead(potPin);

  
  int redLEDIntensity = map(potValue, 0, 1023, 0, 255);

 
  analogWrite(redLEDPin, redLEDIntensity);

  
  int buttonState = digitalRead(buttonPin);

  
  if (buttonState == LOW) {
    digitalWrite(blueLEDPin, HIGH);  
  } else {
    digitalWrite(blueLEDPin, LOW);   
  }

  
  delay(10);
}

Implementation

Video Demonstration

IMG_3370

Reflections

This project was a practical way to understand the difference between analog and digital inputs and outputs. The potentiometer provided smooth, gradual control over the brightness of the red LED, giving me hands-on experience with analog input. The button provided simple on/off control for the blue LED, demonstrating digital input.

Challenges:

• Button Debouncing: Without the slight delay, the button would sometimes register multiple presses in a quick succession due to “bouncing.” Adding a delay(10); solved this issue.

Future Improvements:

• Adding more LEDs or sensors to expand the circuit’s functionality.
• Using more advanced analog sensors, such as a temperature or light sensor, to explore other applications.