Category: F2024 – Mang

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.

Physical Computing’s Greatest Hits (and misses)

In Physical Computing’s Greatest Hits (and Misses), the author discusses recurring themes in physical computing projects, noting that while some ideas are popular for their simplicity and aesthetic appeal, others provide deeper interactive potential. These themes offer valuable learning opportunities and room for original interpretation, encouraging students not to shy away from them despite their repeated use. The author reviews various common projects, including musical instruments, interactive gloves, video mirrors, and mechanical pixels, each presenting unique interaction possibilities.

One example that stood out to me was the drum gloves. This project is intriguing because it uses a familiar gesture—tapping—to create music, leveraging a natural human rhythm. The gloves transform finger movements into drum sounds, adding a playful and structured interaction that feels intuitive. By applying sensors to each fingertip, this project highlights how everyday gestures can be amplified through physical computing, making it accessible and engaging. The concept demonstrates how physical computing can make technology feel natural, bridging the gap between digital and physical interaction.

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

In Making Interactive Art: Set the Stage, Then Shut Up and Listen, Tom Igoe argues that interactive art should let participants interpret and engage on their own terms, without over-explanation from the artist. By giving only minimal cues, artists create an environment for discovery, allowing users to shape their own experiences. I agree with Igoe; interactive media should be intuitive and self-explanatory, engaging participants in a personal way. This approach aligns with our midterm project presentations, where we were encouraged to figure out each other’s games independently before hearing the creator’s explanation, fostering genuine exploration and interaction.

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.

Concept 

For this week’s project I decided to create a smiley face out of LEDs and use different sensors & switches to control different color LEDs. Conceptually, this idea is fairly simple. When I read the assignment I almost immediately knew that I wanted to do a smiley face and just had to figure out how I would incorporate the different switches in an interesting way. When I looked online I was also pleased to see that there weren’t many renditions of my idea so I felt like I had to think for myself (at least to some extent). However, I did see the use of a LED screen (not included in our Arduino kits) that I would be interested in exploring in future projects.

Final Project & Schematic 

Design

Like I mentioned before, my design is pretty simple. I am using blue and yellow alternating LED lights to illuminate a smiley face. The brightness of the blue LED’s is controlled using the potentiometer and then the yellow LEDs are illuminated using the manual switch. I enjoyed this project a lot because it really tested my knowledge of what we’ve learned in class over the last two weeks. Although it is basically what we’ve done in class just on a slightly more complicated scale, I found that introducing more components made it much more difficult to manage the information and connect pieces accordingly.

One aspect I am proud of is the simplicity of the code. In order to get this to work I only needed to implement the potentiometer code from class and have the manual switch functioning just off of power. Although this seems like common sense (since the switch connects the current itself) I had to go through a trial and error to realize the code I was trying to implement (a merge between the code for switches and the potentiometer) was virtually pointless.

Future Recommendations

In the future I would really like to improve this project by simplifying it. I originally tried to connect everything using resistors but due to other issues in my circuit ended up restarting and only using wires. Although for the sake of this assignment I didn’t really mind, the amount of wires definitely takes away for the “art” itself. I’m sure there a multiple ways I can simplify my circuit or use other materials just to minimize the “under construction” appearance it currently has. Other than that, I am fairly satisfied with the outcome and am excited to apply these techniques to more complicate future tasks.

Okay, we should have read these earlier, I guess. Rather than discovering now things (well, there are a few in the physical computing list), I would say that reading these two passages was like reacquainting myself with some of my takeaways from the first half of our course.

‘Shut up’ is a rude phrase, especially when it’s called to the alleged ‘creator’ of a piece – I thought. Then it comes to the question again: “To what extent could we deem to be the creator, and to what extent should the intentionalistic pursuit of the creator be respected?” I have no clear answer to this. But if we hop out of the framework of intentionalism and think of ‘shut up’ as also a part of the ‘creation’ process—as if there is no static ‘art piece’ but only the rating process (borrowed from musicking if you’re curious), then the seeming sacrifice of intentionalism could serve something higher than itself. Philosophical enough, even merely regarding the pragmatic effect that ‘shut up’ could bring us, I believe the amusing moments that happened in our mid-term presentation could speak for themselves, signaling us creators to take another lens and subsequently improve the creation. That is, in a sense, also the creation process, isn’t it?

Anyway, as for the topics/types of physical computing projects listed, obviously, just within our class (or even only within my projects), there are already a lot of ‘overlapping’ ideas. If you ask me if in this particular case I would be bothered by the ‘ingenuity’, the answer – surprising or not – would be a clear NO. My interpretation of this problem would be similar to cover versions of music and the iteratively performed classical music – each and every version/performance contributes to the collective musicking process with its own uniqueness. Even if we are ‘just copying’, there is still nothing to be ashamed of: copying, or more professionally speaking, imitating, is still one of the best ways to learn.

Overview Video Link

The production goal for this week was to understand and play with the analog and digital components in the kit. Then with the input of the components, apply the readings to at least two LED bulbs. Just for fun, I decided to use 4 because I wanted them to glow in a random pattern with varying brightness. With the potentiometer, I decided to showcase how it can be linked to multiple LEDs to control their brightness.

Difficulty and Success of the Process

I felt the most difficult part of the process was the coding and software. Alongside getting use to the IDE, I think connecting the wires to the correct input ports and then referencing the port in the code was a bit confusing to me. Since some of the input ports on the Arduino do not have Pulse Width Modulation (PWM) that converts digital inputs into analog results, I initially was connecting leads to port 13 that didn’t have PWM functionality resulting in my LED blinking when I didn’t want them to and other fault design. With a quick Google search, it seemed like pins 3,5,6,9,10,11 have PWM functionality and changing my routing to those pins resolved most of my issues. As such, my recommendation for others starting out is to use those pins when working with analog measurements while using digital components.

On the other hand, I found great success in connecting multiple LEDs on my breadboard and then connecting the various parts in the IDE. I had a lot of fun organizing and visualizing the routing and see how each of the components would work together. I really loved how the random pattern turned out, but I think in the future I would like to find a way to connect the brightness control with the pattern. With the potentiometer, I ended up connecting each individual light with the meter, but not when the pattern was being displayed. I also wished I had more buttons to play around as well. However, I am still happy with the overall design and look forward to future projects.

Schematic (TinkerCAD)

IRL Photo

 

Idea

For this assignment, I came up with a simple idea of creating a personal space invasion detector. The circuit has two mode, turned on and off using digital input (switch), the space detection using analog input (photoresistor). If the hand comes to close the person, the yellow light will dim. I use the yellow LED because it normally symbolizes happiness, which means when it dims, the person becomes less happy because someone invaded his personal space.

Implementation

I drew a circuit of the detector, including 2 LEDs, 1 photoresistor, 1 resistor and 1 switch. The switch I use is the rectangular one with three connecting points. If points 1-2 are connected, turn on the red LED, if 2-3 are connected, turn on yellow LED (connected to photoresistor).

Video