Author: Jania Jones

Concept

From the design to implementation phase I am rather satisfied with how close I was able to stay to my original concept. In the design phase I knew I wanted to create some type of map interaction with different countries and songs for users to dance too. When conceptualizing this project, my mind kept returning to the alphabet/poem rain installation we saw in the first half of the semester. I think it’s the best example we’ve seen of interactive art where there’s a message and a strong interactive component. Although, I was not able produce something of that quality, I am nevertheless pleased with way in which I combine meaning and interaction in my piece.

As a study away student being immersed in NYUAD’s vibrant culture has genuinely changed my perspective of the world. Growing up in New York City, and the US in general I’ve been taught a very specific definition of what diversity looks like and being a student here has completely redefined that for me. Thus, as the semester comes to a close, I thought this project would be a perfect way for me to share a glimpse of what I’ve come to appreciate so much.

Design

As I mentioned previously, throughout the design process I had a pretty clear idea of what I wanted to create.  There were other features that I considered in order to strengthen the interactivity such as body tracking or a point system but I settled on a simpler design to ensure maximum functionality. Nevertheless I took a lot of inspiration from the video game Just Dance, and tried to consider that level of interaction throughout the design and implementation process.

Implementation 

Once I began the ‘build’ process the difficult part was just in mainly getting started. Surprisingly enough, I also had a hard time figuring out what songs/countries would be represented. The hardware, although rather simple, tested a lot of skills in terms of soldering and using tools I’m not super familiar with so I’m glad I was able to use what we learned in class to my advantage. Furthermore, this is the first time I’m working with any kind of hardware components on top of software design so it took a bit of creativity to consider what materials I wanted to use to make my vision come alive.

Caption: I originally had a ton of extra wires because I thought I wanted to extend the Arduino behind my computer but after assessing the material available, I shorted them and added this box to tuck them away. – Phase 2

My prototype consisted of just using the map itself and a few switches to test both the hardware and software. Once that was good to go, my main concern became ‘cleaning up the look’ so that I had a clear, finished project to present. This was rather easy, I just needed to identify areas of concern, and figure out how I could further simplify them.

Prototype video from user testing – no sound

In terms of software implementation, once I decided how I wanted to exchange information between P5 and Arduino, I was able to make significant progress in my code. Basically, when a button on the map is pressed, a flag corresponding to that country in Arduino is sent to P5 which then sets a series of commands off to play it’s respective video. However, a major road block that I hit was the 5 MB upload limit to video files in P5. My solution to this problem is fairly simple, but the route I took to get there was very long and complicated (as is most debugging).  I eventually was able to implement an array based system to cycle through clips of each video so that they could all play as one.

Schematic

Arduino Code

int colombiaButton = 13; // Button connected to pin 13
int indiaButton = 12;
int koreaButton = 11;
int chinaButton = 10;
int italyButton = 9; //black button with whie & blue wire
int prButton = 7; //yellow button with green and blue wire 
int saButton = 5; //green button with white and yellow
int nigeriaButton = 2; //red button with orange and green 
int kazakhButton = 3; //blue button with green wires
int fpButton = 4; //black button yellow and white wire  

void setup() {
  // Start serial communication so we can send data
  Serial.begin(9600);

  // Configure the button pin as input with pullup
  pinMode(colombiaButton, INPUT_PULLUP);
  pinMode(indiaButton, INPUT_PULLUP);
  pinMode(koreaButton, INPUT_PULLUP);
  pinMode(chinaButton, INPUT_PULLUP);
  pinMode(italyButton, INPUT_PULLUP);
  pinMode(kazakhButton, INPUT_PULLUP);
  pinMode(prButton, INPUT_PULLUP);
  pinMode(saButton, INPUT_PULLUP);
  pinMode(nigeriaButton, INPUT_PULLUP);
  pinMode(fpButton, INPUT_PULLUP);
}

void loop() {
  // Check if button is pressed
  if (digitalRead(colombiaButton) == LOW) { // Button pressed (active low)
    Serial.println("colombia"); // Send "push"
  } else if (digitalRead(indiaButton) == LOW) { 
    Serial.println("india"); // Send "push"
  } else if (digitalRead(koreaButton) == LOW) { 
    Serial.println("korea"); // Send "push"
  } else if (digitalRead(chinaButton) == LOW) { 
    Serial.println("china"); // Send "push"
  } else if (digitalRead(italyButton) == LOW){
    Serial.println("italy");
  } else if (digitalRead(prButton) == LOW){
    Serial.println("pr");
  } else if (digitalRead(saButton) == LOW){
    Serial.println("sa");
  } else if (digitalRead(nigeriaButton) == LOW){
    Serial.println("nigeria");
  } else if (digitalRead(fpButton) == LOW){
    Serial.println("fp");
  } else if (digitalRead(kazakhButton) == LOW){
    Serial.println("kazakh");
  } else {
    Serial.println(0);
  }
  delay(150); // Debounce delay
}

P5 Code

https://editor.p5js.org/jajones/sketches/SaANLV2D5

Aspect’s I’m Proud Of

Overall, I am pretty proud of my final product. What I struggled with the most in the midterm was designing realistic plans for my project which left feeling overwhelmed throughout the implementation process. Throughout this process, I gave myself enough space to design new ideas while staying focused on what my original plan was which I think really helped the overall process.

A more concrete component I am proud of this the solution to the file size upload issue I faced earlier. I did a lot of reading on StackOverflow and random P5 forums to help me solve the issue and so even though it isn’t perfect I am really happy with how it turned out.

Future Improvement 

In terms of future improvement, I would love to incorporate more way to encourage people to physically react. Although in my user testing people were active and participating, I feel as though if I wasn’t standing there, watching, they wouldn’t necessarily feel as inclined to do so. To help alleviate this I did try to replicate a dance mirror effect when the videos play so users felt incentivized to dance, but I’m sure I could go even further to record them dancing and then have the program send it to them or add it to some dance database which they might enjoy being a part of.

Overall Reaction 
My user testing experience went about how I expected it to. The person who participated was already familiar with my concept so it was a bit challenging to get an authentic reaction but we still had a productive conversation about what steps I need to take to improve. Although he was aware of my concept, I did not prompt him with any steps on how to run the software. Therefore, I was quite pleased that he was able to navigate it fairly seamlessly but am considering altering a few of the prompts just so users have a better idea of what to expect when they choose a location.

Areas for Improvement 

One thing he highlighted in our discussion afterwards was the quality of my mappings. Because you are viewing the same thing on the screen (with brief instructions) and what you touch on the paper, it is clear that you should press a button to generate that location’s music. Right now my biggest concern in terms of improvements in finishing adding the switches to the map. This weekend I focused my time on finishing the software but now realize how that limited the user experience for testing. To help remedy this, I plan to conduct user testing again this Saturday to get a full critique of the design.

Another feature that we discussed would be beneficial in adding is a small screen where users can see themselves dancing to help promote full interaction with the piece. Given that my user already knew the intended goal of my design, he danced for the sake of full participation but I’m not sure it’s clear to users that I also want them to dance on their own. Thus, in terms of next steps, my immediate goals are: finishing the hardware, adding the video capture component, and creating another tab with specific instructions of how to use the program.

Testing Video

Final Concept 

My final concept for my IM final will be an interactive map representing the  diversity and culture of NYU students and our families through dance and music. I will have a framed, 2D paper map with buttons marked on different location around the world. When the user presses the button a song corresponding to that specific location will play. I plan to compile 10 songs with their selection being based on interviews from people I know at school. When a song is played, I’d also like to have a video of people dancing to the song as well. My hope is that the music and dance video will prompt users to partake in dancing to the music themselves as a type of cultural exchange but if I am being realistic, I’m not too sure that will happen. However, I will try to tweak the presentation of the dance video as much as possible so users feel invited to move their bodies in some way.

Concerns

I don’t think my ideas will be too difficult to implement, so in keeping it simple I hope to truly perfect each aspect of it. However, I do still have some concerns going into it. I have yet to make any final decisions on what the software side will look like,  I want it to be simple yet playful but am not exactly sure how I’d like to implement that aesthetic yet. Additionally, I originally designed a frame that stands up for users to press the buttons but after further consideration I realized they might not be able to properly push the buttons in because there is no support behind the map. My possible solutions for this are either using light sensors instead of buttons so they basically just have to hover their finger over the location, or making a 2D frame of sorts that just lays flat along the table. I think the map laying flat will be easier to implement and design so I will probably go with that as a solution but am still hesitant because I think it sacrifices a bit of the aesthetic of the overall design.

On the left is the standing up version and what the support would look like and on the right is the ‘tabletop’ design.

As I move further into the implementation stage I also want to consider the possibility of users being able to add their own songs but don’t want to get too far ahead of myself before the foundation is established.

Arduino Component 

For the most part the main thing the Arduino will be dealing with is receiving the information of what location the user selects. If time permits, I’d love to create some kind of LED visual to go along with the music but that is not my priority for now. Although I was originally leaning towards using the light sensors to detect the location a user selects, I am afraid of inconsistency in the data being read because their will be so much going on at the showcase so I think the buttons will be more reliable. With that being said, the Arduino program will signal P5 when a city is chosen and then P5 will handle the rest in terms of playing the song and whatnot. A small feature I am interested in implementing as well is using the LED board display that simply writes “Welcome to [country of song’s origin” to another component.

SchematicI did not include the LCD display in this schematic because I’m not sure how I’d balance those pins with what I need for the switches so I am temporarily pausing that idea. I will see if I can split half of the switched on analog and the other half on digital since LCD needs to be on digital pins.

P5 Component 

On the P5 side, I would really like to have an animation aspect of sorts that zooms in from a full map view to the specific city in order to play a song. I don’t think this will be too difficult to implement because I can just play a video, but I’m not exactly sure how I’d do it because I would need to create a different animation for each of the 10 cities which is a bit tedious. Here is a rough idea of what I mean by animation:

Once the animation plays a little information card about the song, it’s origins and the person who submitted it will play. Then, the user will be prompted to start the song/video via an on screen button and then can repeat and explore the map from there. I do not plan on playing the entire song for each video, I am thinking 20-30 seconds of the main chorus of the person who submitted it’s favorite part of the song.

P5 will be receiving the information about what button was selected from Arduino and will send a ‘current state’ flag to Arduino to prevent users from trying to select another location while a current one’s video is playing.

For my final projecting I am planning to expand on my midterm project to that it involves physical hands on components. Currently the project features two mini games and some helpful information regarding film photography in general. I plan to modify one of the pre-existing mini games (a mixing chemistry game) so that users have to hold a button in order to pour each chemical. I would also like to add 2-3 mini games. One of them would be assisting a customer calibrate the light meter in their camera (this would use a light sensor and potentiometer). Another idea is a further development of the dilm development station. This would feature the user loading their film in to a developing tank and would use dc motor to simulate the tanks spinning. Lastly, I am hoping to do some kind of lens assembly puzzle. I am the least sure about this idea because it would require 3D printing each piece of the lens and finding a way to simulate them locking together like they would on an actual camera. My biggest concern at the moment is being over ambitious in the conceptual phase and thus not having enough time to actually develop what I planned for. Please let me know if you have any suggestions!

This week’s reading, Design Meets Disability, explores the ways in which assistive technologies and art are being used together to represent disabilities. The author highlights how this type of design works to extend these tools beyond the problem they solve and instead focuses on the user and their experience with them. Whether that be through prioritizing aesthetics or representing these resources as art themselves, this drives a new type of design process, one in which functionality is not the only factor. This proposition, of sorts, is something we have explored countless times with a special mention to Don Norman’s The Design of Everyday Things. The idea that the user experience is just as important as the design and purpose are common theme of these two articles and I am particularly interested in how it is presented in this article.

Not only is this design methodology more effective but in this context, it evidently makes individuals’ lives more accessible and inclusive. Whether it be through re-designing hearing aids to better match the needs and preferences of users or representing diverse bodies with different disabilities in media, this approach not only makes their lives easier but they open up space for conversation on a larger scale about why this type of inclusion is important. We can apply these practices in class when designing and implementing our projects through user-focused design and testing. Although on the design side it is oftentimes difficult to recognize these shortcomings, through field testing and design/usability-centric improvements it is more than possible.

Below are the codes for each of our in class exercises including what was using in P5 and Arduino. After exercise 3’s code, you can find the video of the LED lighting up with the ball bouncing.

Exercise 1

P5 code

let distance = 0;

function setup() {
  createCanvas(640, 480);
  textSize(18);
}

function draw() {
  if (!serialActive) {
     //setting up the serial port information
    background(255);
    text("Press Space Bar to select Serial Port", 20, 30);
  } else {
    background(255);
    text("Connected", 20, 30);
    //reading the distance sent from arduino onto width of computer
    let mappedDistance = map(distance, 0, 50, 0, width); 
    //preventing ball from extending beyond the screen
    mappedDistance = constrain(mappedDistance, 0, width); 
    ellipse(mappedDistance, height / 2, 25, 25);
    //actually drawing the circle
  }
}

function keyPressed() {
  if (key == " ") {
    setUpSerial(); 
  }
}

function readSerial(data) {
  //reading the distance value given by arduino
  if (data != null) {
    distance = int(data); 
  }
}

Arduino Code

const int trigPin = 10;
const int echoPin = 9;
long timeTraveled; //variables for the distance monitor
int distance;

void setup() {
  Serial.begin(9600);
  pinMode(trigPin, OUTPUT); 
  pinMode(echoPin, INPUT); 
}

void loop() {
  // clear whatever the trig pin. has read
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  // 10 microsecond delay for each new reading
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  //read the values sent in through echo pin
  timeTraveled = pulseIn(echoPin, HIGH, 38000);
  // use this conversion to calculate in centimeters
  distance = timeTraveled * 0.034 / 2;
 /* if (distance > 500){
    distance = pulseIn(echoPin, HIGH);
  }*/
  //display in serial monitor
  Serial.println(distance);
  delay(50);
}

Exercise 2

P5 code

let brightnessValue = 0; 

function setup() {
  createCanvas(640, 480);
  textSize(18);
}

function draw() {
  background(250);
  //setting up the serial port information
  if (!serialActive) {
    text("Press Space Bar to select Serial Port", 20, 30);
  } else {
    text("Connected", 20, 30);
  //depending on where the mouse is from left to right, sending that value as a brifghtness value to arduino
    brightnessValue = int(map(mouseX, 0, width, 0, 255));
    text('Brightness: ' + str(brightnessValue), 20, 50);
    let sendToArduino = brightnessValue + "\n";
    //printing that value in serial monitor arduino
    writeSerial(sendToArduino);
  }
}

function keyPressed() {
  if (key == " ") {
    setUpSerial();
  }
}

function readSerial(data) {
  //just to avoid no readSerial error saving data
  if (data != null) {
    let receivedData = data
  }
}

Arduino code

int ledPin = 9; 
int brightness = 0; 

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

void loop() {
  if (Serial.available() > 0) {
    //making sure its not trying to run unless receiving from p5
    String brightnessString = Serial.readStringUntil('\n');
    //reading the converted value from the computer
    brightness = brightnessString.toInt(); //converting to an integer
    //illuminating the led to the newly converted brightness value
    analogWrite(ledPin, brightness);
    Serial.println(brightness); //adding to serial monitor
  }
}

Exercise 3

P5 code

let velocity;
let gravity;
let position;
let acceleration;
let wind;
let drag = 0.99;
let mass = 50;
let potValue = 512; //make it so that wind starts at 0 force
let running = true;

function setup() {
  createCanvas(640, 360);
  noFill();
  position = createVector(width / 2, 0);
  velocity = createVector(0, 0);
  acceleration = createVector(0, 0);
  gravity = createVector(0, 0.5 * mass);
  wind = createVector(0, 0);
}

function draw() {
  background(255);
  //created this flag variable to get the ball to drop again
  if (!running) {
    textSize(24);
    fill(0);
    text("Press 's' to run again", width / 2 - 100, height / 2);
    return;
  }
  //mapping the value of the potentiometer to which direction the ball falls 
  wind.x = map(potValue, 0, 1023, -2.5, 2.5);
  //mapping to speed -2.5 to 2.5 so the ball can gradually increase and decrease
  applyForce(wind);
  applyForce(gravity);
  velocity.add(acceleration);
  velocity.mult(drag);
  position.add(velocity);
  acceleration.mult(0);
  ellipse(position.x, position.y, mass, mass);
  if (position.y > height - mass / 2) {
    velocity.y *= -0.9;
    position.y = height - mass / 2;
  //standard s
    if (serialActive) {
      writeSerial("Ball bounced\n");
      //sending this to arduino each time ball hits ground
    }
  }
  if (position.x < -mass || position.x > width + mass) {
    //preventing the ball from being registered when it rolls off the screen
    running = false;
  }
}
function applyForce(force) {
  let f = p5.Vector.div(force, mass);
  acceleration.add(f);
}

function keyPressed() {
  if (key == ' ') {
    //opening setup pop up window
    setUpSerial();
  }

  if (key == 's') {
    //preparing a new ball to drop resetting the values 
    fill('white');
    position = createVector(width / 2, 0);
    velocity = createVector(0, 0);
    acceleration = createVector(0, 0);
    running = true;
  }
}
function readSerial(data) {
  //just to avoid no readSerial error saving data
  if (data != null) {
    potValue = int(data);
  }
}

Arduino code

const int pmPin = A0;  
const int ledPin = 9;   

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

void loop() {
  int potValue = analogRead(pmPin); //read potentiometer value
  Serial.println(potValue); //printing in serial monitor for p5
  if (Serial.available() > 0) { //make sure data is coming in to p5
    String event = Serial.readStringUntil('\n');
    event.trim(); //reading each newline of data
    if (event == "Ball bounced") { //sent from p5
      // turning the led on when bounce message is received
      digitalWrite(ledPin, HIGH);
      delay(100);  
      digitalWrite(ledPin, LOW);
    }
  }
  delay(50); 
}

When this code runs, the first ball is dropped from the original code and then you are prompted to open the serial connection I just cut that out of the video.

In the article A Brief Rant on the Future of Interaction Design, Bret Victor critiques the current state of interactive design by highlighting our reliance on “pictures under glass” aka electronic technology using screens. He argues that they over usage of them limits the way we interact with the digital world. Victor argues that by only using our fingers to complete so many different tasks, we lack the tactile experience. An ultimately cut ourselves short of the full potential of our hands, which are intended for so much more complex and creative things. Furthermore, he envisions a future where technology engages all of our senses and thus, feels more real, bridging the gap between our physical existence and digital experience. His perspective is interesting to me because it sheds light on how we as a society are not reaching our full potential, making us creatively lazy.  I also really enjoyed his argument because it made me think of the show Black mirror, which critiques society in a similar manner and provides dystopian snapshots of what we may be on track to become.

The second article is an additional piece providing reflection on what the audience thought and Victor’s responses to that. I particularly enjoyed this section because it posed a lot of interesting opinions and arguments that I, myself thought of and agreed with while reading both articles. All in all, I think this gave an unique look at how we must balance the present of technology in interactive media and design. It is a tool with endless capabilities but we cannot let the excitement of the unknown limit us from the potential of what we still can grow. I hope to apply these principals in my design process as I find ways to combine modern and innovative technology with traditional and reliable physical experiences.

Concept 

For this week’s assignment we spent a lot of time brainstorming ideas and developing different components of the instrument. Originally, we considered a light sensor activated lullaby machine (at night it plays a lullaby and an alarm in the morning) but weren’t sure if that actually constituted an instrument. Therefore, we decided to keep it more straightforward with an electric keyboard design that you can adjust the speed or “consistency” of the notes playing.

Materials

• Arduino Uno
• Jumper wires
• 7 button switches
• Speaker
• SPST Switch
• Potentiometer

Schematic

Design 

This project’s two main components are 7 buttons to play the notes and a potentiometer to control the speed of the notes playing. The green button to the left (closest to our potentiometer) represents middle C and then each button plays the consecutive note going up that scale. In our design, we also implemented a an SPST switch to control whether or not you could play anything on it, with the intention of mimicking an electric keyboard’s power button. A unique component to our design is the fact that we used both of our Arduino breadboards in order to better organize and manage the aesthetics of the design. Additionally, by still using one actual Arduino Uno we were able to avoid any complications with synching the information which was convenient in terms of time efficiency.

On the implementation side our biggest challenge was getting the volume to change with the adjustments of the potentiometer. After a bit of troubleshooting and heading back to the drawing board we decided to switch our original play and allow the potentiometer to control the speed of the notes. We intended to recycle as much code as we could from class and ultimately ended up use components from both Arduino’s tone() and button example codes that were reviewed in class. After switching between trying to change the pitch, speed, and volume of the notes with the potentiometer we decided on speed simply because we felt that the other adjustments weren’t noticeable enough for our intended purpose.

Code

#include "pitches.h"
 
// button pins
const int B_key = 4; 
const int A_key = 5;
const int G_key = 6; 
const int F_key = 7;
const int E_key = 8;
const int D_key = 9; 
const int C_key = 10; 
 
const int SWITCH_PIN = 12;  // switch pin
const int BUZZER_PIN = 2; // buzzer pin
const int POT_PIN = A0; // potentiometer pin 
 
// notes
int melody[] = {
  NOTE_B5, NOTE_A5, NOTE_G4, NOTE_F4, NOTE_E4, NOTE_D4, NOTE_C4
};
 
// Array for button pins
int buttonPins[] = { A_key, B_key, C_key, D_key, E_key, F_key, G_key };
 
void setup() { // initalization of the buttons, buzzer, and switch pins 
  for (int i = 0; i < 7; i++) {
    pinMode(buttonPins[i], INPUT_PULLUP); // sets button pins as inputs with internal pull-up resistors
  }
 
  pinMode(BUZZER_PIN, OUTPUT); // sets the buzzer pin as an output
  pinMode(SWITCH_PIN, INPUT_PULLUP);  // sets switch as inputs with internatinoal pull-up resistors
}
 
void loop() {
  int switchState = digitalRead(SWITCH_PIN);    // reads the state of the switch
  int potValue = analogRead(POT_PIN);   // reads the potentiometer value (0-1023)
 
  int speedDelay = map(potValue, 0, 1023, 50, 500);  // maps potentiometer value to speed delay range (50-500 ms)
 
  // if the switch is HIGH the button functionality is enabled
  if (switchState == HIGH) {
    // continously checks each button state
    for (int i = 0; i < 7; i++) {
      int buttonState = digitalRead(buttonPins[i]);
        
      // if the button is pressed,  play the corresponding note
      if (buttonState == LOW) {
        tone(BUZZER_PIN, melody[i], 200); // play note for 200ms
        delay(speedDelay); // speed delay based on the position/ value of the potentiometer 
      }
    }
  }
  delay(50);
}

Final Project 

Conclusion and Reflection

All in all, we are both rather pleased with the outcome of this weeks assignment. With it being our first assignment working with another person, it was an interesting opportunity to compare techniques in regards to simpler things like breadboard organization or schematic design preferences. We were able to use both of our strengths in different ways and support each other in areas that we were weaker. In terms of future developments we had a few smaller ideas such as adding LEDs to correspond with the keys, or allowing the user to control the pitch of the notes. Looking at the bigger picture, we even discussed what it would look like to allow the user to choose what kind of electric keyboard sounds they wanted to play (going beyond the use of the speakers we have). Although our project is rather simple, we were truly tested when it came to debugging our code but really appreciated the experience of going at it together.

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.

Physical Computing’s Greatest Hits (and misses)

Tigoe’s Physical Computing’s explores common trends on themes found in physical computing along with their pros and cons. Ranging from implementing toys as touch sensors to using our voice to complete a task, the author emphasizes the versatility we have when it comes to designing our projects. This is particularly interesting because it reminds us how endless our creativity can go as we take mundane, everyday tools and make them into something so much greater. I find this to be particularly applicable in our case because as we make the transition from software based development to hardware, a new creativity block can be formed. In other words, working with physical materials takes an entirely new level of creativity and out of the box thinking as we turn our ideas into reality. The formal introduction of these themes or common trends not only gives us an idea for how we can implement these kind of tools, but also a starting platform of ideas for us to further develop.

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

In this article the author starts off by establishing the common, ineffective scenario in which an artist has to walk their audience through every stage of the their creation in order for them to follow what is happening. He highlights this as one of the most important issues to be addressed because of how it heavily hinders the experience of interactive media and art. Tigoe also states that similar to traditional art, viewers deserve the chance to interpret the art on their own and strike up conversations in regards to what it means to them. I find this advice to be extremely helpful because it reminds me of the piece we read early in the semester that said interactive media should think, listen, and speak on its own. In combining these two pieces we can clearly see what makes a strong interactive piece of art and going forward I will use these standards to assess my own work for creativity, originality, and usefulness.