Final Project Idea – Emotion Vendor

Name: Peter Wang

Instructor: Marcela Godoy

Partner: Yutong Zeng

INTM-SHU  101 002

22 April 2018

Thoughts on final project

What is interaction:

“Interaction” is not a strange word for me. “Click”, “move”, and “scroll” for mouse; “press” for key board, these are examples of inputs. When the inputs are sent, then the computer would react by “displaying” corresponding change on the screen—this is an example of outputs. Although what I said might sound intuitive to most of the people in my generation and the concept of “interaction” won’t even run through their mind when they were performing the action, but moving one’s mouse and watching the cursor moves are truly the essence of interaction—input and output.

Examples I gave are ones of digital interaction, but “interaction” is not limited to the digital world. When one exert pressure on  a mouse, one will hear a “click” sound. This is also an example of interaction, not a digital one but physical interaction. The same rule applies: input and output. Similarly, interaction also takes place on an emotional level. However, different from physical and digital interaction, which are usually between a human and an object, emotional interaction happens between two persons: when one express one’s feeling, another person might sympathize, criticize, etc.; also, one can hide one’s emotion, and one’s counterpart will in turn take corresponding action. One’s feeling will affect another’s, and this change in emotion will pass along to yet another person and to yet another to yet another… This baton-passing of emotion is what our project is all about.

 

Emotion Vendor

Our project is called Emotion Vendor, which I would like to call EmoVen. It would work pretty much like a specific type of vending machine called gachapon whose basic concept is that one would not know which specific product will he/she get among a variety of products. Usually, gachapon would sell toys in capsules. For EmoVen, it sells capsules with notes inside and one don’t pay to get one. Instead, one has to leave a note in an empty capsule and put it into the pool of capsule in order to receive a capsule with note written by another person. One can then carry the note, together with the emotion embedded in it, walk away, and move on with one’s life.

 

The working mechanism would be rather easy:

  • How to check if one writes a note or not: when one put a capsule back, the capsule will roll along a slanted platform and to the pool. On the way back there will be a distance sensor installed so that arduino can tell if something has pass through.
  • How to distribute capsule: the pool of capsule has an outlet that is blocked by gate controlled by a servo motor. After the arduino detects that something has passed through the distance sensor, it will change the position of the servo so that it will allow a nearest capsule to fall out.
  • Interaction between arduino and processing: processing will show animated instruction step by step to help its user to use the machine. Also, it will record how many people have used it in a day and might record what is written on each note captured by arduino and export them so that we can have a database of people’s emotion.

 

Final words:

Technology has been evolving rapidly these days, so does human-object interaction. This is definitely a good news and is something to be cheered for. All inventions are created for the benefit of us humans. However, there is a tendency that technology is distracting us from focusing on others. This is why we would like to focus on human interaction in this project.

Interaction Lab Recitation: Object oriented programming (Sean)

In class we discussed the objectives for using objected oriented programming and how it eases the process of creating functional multiples of a specific object by suing classes. It is a more efficient way of increasing the functionality of your code since it is easier to multiply the functions and/or object and thus enrich your program. It was interesting how the professor created the analogy of Pokemon, and how Pokemon are a group of creatures while every creature is different. Which is the same in a sense with programming because you can create multiples of a functional something (example in class: rotating phone), however they can have their own individual traits.

With using class in processing we were told to create something of our own choosing. I wrote a code for multiple bouncing balls.

This is useful for my project because it helps me to better understand the use of classes in processing. I have not yet come to a point in the process where I know for certain that I will need this function, however having a better understanding of a more difficult function of processing definitely benefits me in my use of processing and writing code that one can interact with.

Assignment 5: Tilt Remote Sensor Makes a Sound

In this group project, Angelina, Sarah, Arizona, and I made a tilt remote sensor with the Arduino that can play a sound corresponding to tone 640 when you pressed the remote and tilted your wrist. We attached both the Arduino and the remote to separate wristbands. The Arduino wristband was quite long, spanning with 3 wristbands because it included a condensed breadboard and a portable battery.

 

This is the code for the Arduino. From what I know, you could get a regular remote without the tilt sensor and press volume – and volume + to get different sounds. But, for the conventions of our tilt sensor wristband, we can only play one sound, which came from the volume – button.

In our breadboard, besides wires, we used a buzzer, a sensor, and although in the photo it shows the LED light and resistor, we later realized we did not need it and replaced it with wires. This was because we didn’t need any component of our Arduino to light up, it only needed to receive the tilt sensor from the remote and make the sound. The communication was an audio response to the sensor, and not a visual one.

 

We learned how to correspond the red wires to power and positive and the black wire to ground and negative. This differentiation helped us in the long run in knowing how the breadboard and Arduino worked. The sensor also had a red wire for power, a black wire for ground, and a yellow wire for the Infrared receiver. The buzzer was connected to digital pin 10, and the sensor was connected to digital pin 8. I realize that we didn’t need to connect anything to digital pin 11 after all, because we removed the LED light, but we still just added wires where the resistor and the LED light would be so that it would close and continue the circuit.

For a future project, we should use our time to make more sound with the Arduino, and also make it more compact. We tried transferring it to the lilypad this time, but somewhere along the lines, it didn’t seem to comply, so we reverted back to the Arduino. In the end, I think this was a successful group project, and I got much enjoyment out of working with my group.

Recitation 10 – Divided Workshop

Instructor: Marcela Godoy

Workshop: Oriented Object Programming

In the workshop, Lius firstly introduced this topic with simple examples, like Pokemon and phone, about the variables, functions, objects and classes. Then use two example sketches of rotate phone to illustrate how exactly OOP works in Processing. Then in the practice time, with the previous Pokemon as inspiration, I wrote two simple classes, one of which is the Pokemon and the other Poke Ball. I wanted to use keyboard to control the Poke Ball to catch the Pokemon. I googled three pictures and below is how it works.

I chose this workshop because in our final project, I would be responsible for the logic code part in Processing. And OOP is one of the key algorithms which will help build our Ping-Pong Game’s logic before being projected on a box.

 

float x = 10;
float y = 10;

PImage Pikachu_;
PImage pokeBallOpen;

Pokemon Pikachu;
PokeBall Ball;

void setup(){
  size(500, 500, P2D);
  background(255);
  
  pokeBallOpen = loadImage("pokeBallOpen.jpg");
  Pikachu_ = loadImage("Pikachu.jpeg");
  
  Pikachu = new Pokemon(250, 250, Pikachu_);
  Ball = new PokeBall(pokeBallOpen, 250, 250);
}

void draw(){
  
  if (keyPressed){
      if (keyCode == UP){
        y = y - 2;
      }else if (keyCode == DOWN){
        y = y + 2;
      }else if (keyCode == LEFT){
        x = x - 2;
      }else if (keyCode == RIGHT){
        x = x + 2;
      }
    }
    
  Pikachu.display();
  Pikachu.pokeBallCatch();
  
  Ball.display();
  Ball.BallCatch();
}



class PokeBall{
  PImage photoImage;
  float pokemonX, pokemonY;
  
  PokeBall(PImage photoImage_, float pokemonX_, float pokemonY_){
    photoImage = photoImage_;
    pokemonX = pokemonX_;
    pokemonY = pokemonY_;
  }
  
  void display(){
    image(photoImage, x, y, 100, 100);
  }
  
  void BallCatch(){
    if (dist(x, y, pokemonX, pokemonY) <= 50){
      photoImage = loadImage("pokeBallClose.png");
    }
  }
}




class Pokemon {
  PImage photoImage;
  int pokemonX;
  int pokemonY;
  
  Pokemon(int pokemonX_, int pokemonY_, PImage photoImage_){
    photoImage = photoImage_;
    pokemonX = pokemonX_;
    pokemonY = pokemonY_;
  }
  
  void display(){
    image(photoImage, pokemonX, pokemonY, 150, 100);
  }
  void pokeBallCatch(){
    if (dist(x, y, pokemonX, pokemonY) <= 50){
      
      photoImage = loadImage("white.png");
      
      textSize(25);
      fill(0);
      text("You have catched this Pokemon!", 50, 50);
    }
 
  }
}

Recitation 10, Apr 20, Sean(2018)

In this recitation I choose the workshop of Object Oriented Programming. In this workshop I mainly learnt about the concept of objects, how to create a class and how to use it to do variable things.

OOP makes it easier to create things of the same kind. These things, which we call objects, have similar features and can do similar actions. OOP is the process of creating the template that all projects fit in, and the features make each of them different. For example, if I create a class “Square”, then I can use it to create hundreds of different squares easily, and display all of them use a single function. The code I wrote in class is shown below.

As you can see, it makes the process of “mass production” easier. As my final project will be mainly based on Processing, it helps me a lot. The different roles I will be creating can be based on one Class, and I can adjust the parameters to let them have different features.

 

void setup(){
  size(500,500);
  background(0);
  frameRate(20);
}



class Square{
  color c;
  float x;
  float y;
  float rotation;
  
  Square(float px, float py, float rot){
    x = px;
    y = py;
    rotation = rot;
    c = color(214,random(170,255),random(170));
  }
  
  void rotate(){
    rotation++;
  }
  
  void move(){
    y += 10;
  }
  void display(){
    noStroke();
    fill(c);
    rect(x,y,20,20);
  }
}

Week 11- Greene-Lu,Syed

Rachel Greene’s piece throughly describes the history of a new art form called “net  art”. While this art form is new as of the last 25 years or so, clearly it has gone through many stages. I must admit I often get a little lost in this passage because of the amount of description and to be honest, a lack of understanding certain terminology. Perhaps a visual representation of the information would allow for us viewers to better understand such art. Anyways, I gathered a few good points and quotes from this piece. The main two being that “net art” was/is a platform for activism and the interactivity of the art form not only is what the art form is about, but separates it from other forms of art. I want to highlight the portion where she talks about the cyber-rape within the chat room because I think that is the most thought-provoking part of the essay presented. Whether you agree or do not agree that this instance was rape, it shows that this is a kind of art that can emotionally impact someone unlike anything else.

 

Recitation 9, Apr 21, Sean(2018)

In this recitation, Luna and I made a rabbit using the basic shapes offered by Tinkercad. It is saved as a STL file and we turned it into a physical model by 3D-printing.

850

However, limited by the gravity and its structure, we are required to use some supporting parts when printing, and thus it looks like this.

I choose 3D printing because it can make things that are tridimensional more easily than other ways, given that we created a model not so suitable for laser cutting.

During my midterm projects and Stupid Pet Trick, I mainly used paper printing and handcrafts. However, the digital fabrication makes it possible for me to create more complicated physical parts more easily.

According to the reading, the invention of digital fabrication makes it possible to turn data into things and turn things into data. This ability triggers revolution in many industries, and most importantly, it shifted the way people thinks and acts in society. Therefore, when I am designing and creating my own project, I am also influenced by this revolution. The design is made up of separated parts that are changeable, and every thing can be fixed easily if I am not satisfied with it. The file is always accurate and is easy to duplicate — I can create as many counterparts as I want. There is still a long way to go, but through my work I feel the infinite possibility of this technology — that’s why it can trigger a revolution.

In the future I believe creating things will be even easier. For example, there will be more materials that we can chose, so we can design more things. Also, the process will be faster and the accuracy will also be improved. On the other hand the designing process will surely get improved — but it will certainly still be based on mathematics calculation, because that’s where the accuracy and the beauty of those curves come from.

Recitation Week 10 Documentation – Ally Porter (Rudi)

For this week I chose to do the soldering workshop, just in case I would need to know how to solder for my final project.

The first part of the soldering workshop, we learned about the different tools and basic do’s and don’ts of soldering. Then we soldered a wire onto a piece of paper with conductive tape on it.

Then, we soldered two wires together with the help of the helping hands:

Finally, we made a circuit by soldering two wires to an LED and touching them to a battery:

Lab: 3D Printing (Sean)

My partner was Monica. Firstly, we wanted to make a necklace shaped like a flower. but we couldn’t find a teardrop-shaped model in Tinkercad, so we had to come up with something else. After some experiments, Mona was born.

This is a rabbit wearing a princess dress. We combined our names so she was called Mona.

When we went to print her, the fellow told us it would take an hour. So we plan to video the process half an hour later. However, when we came back, it was already done. We both feel sorry that we were not there to witness the process.

We used supporter but we weren’t able to tear it off. We didn’t dare to use too much strength in fear of killing it. So, it looks like this:

 

Conclusion: in this recitation, I practiced how to do 3D Printing. Although we wanted to do complicated design at first, we found it hard to model it in Tinkercad. As a result, we gave up our original design and used the model Tinkercad provided to make something new. We stated with the simple things, a ball, a diamond. Then, we made a rabbit out of it. I enjoyed making pretty toys out of simple things through our creativity.

Interaction Lab || Joseph Hensersky || Recitation 10 – Serial Communication

I thought this recitation was very useful from a technological perspective. Serial Communication is the way in which we get two devices to pass information between each other. The micro controllers that we use do this through UART’s (Universal Asynchronous Receiver Transmiter) which is the RX and TX pins on the Arduino.

The recitation was focused on sending multiple values from the Arduino to Processing and then from Processing to the Arduino. The part I found interesting is that the most import part is figuring out how to signal to the other device that the section of data you are sending is finished. This allows us to send data in “chunks” that are recognized by the other system. Without this the machines would forever be reading data with no idea of what it implies.

The protocol demonstrated for sending data from Arduino to Processing was simple. Send each value separated by a comma and end it with a newline character. Processing is conveniently able to read data up to a specified character (via Serial.readStringUntil( int )) which allows us to use any character of our choosing for the end of “chunk” signal. Using the newline character is rather easy because it guarantees no overlap with data and we can just use Serial.println() in Arduino. Additionally, sending data in this format is made easy by Processing’s split() function which allows us to pass in a string and a character from which it makes an array of strings which are separated by the character we provided.

Sending data from Processing to Arduino is slightly different. What was demonstrated during the recitation was first concatenating all of the data that need be sent into a long string first, separating the smaller pieces of data with commas and ending it all with a special signal character (in our case it was ‘n’) and then just sending it from the port. The tricky part about this is that the Arduino is unable to pick full pieces of data like that from Serial.read() but is instead only able to pick up one byte at a time (aka one character at a time). This provides a little bit of trouble when trying to read numbers from processing because you end up getting the most significant digit first and the smallest one last. Luckily with some simple code and the use of switch…case statements it isn’t that hard to figure it out. We used certain temporary variables to store the values we were reading and upon encountering a comma or end of data signal we would reset those variables to zero. Very clever and easy to use.

 

This workshop is going to be very useful for our final project because of our need to communicate a decent amount of different types of data from the Arduino to Processing and vice versa. With some simple protocols that we can create and the tricks I learned from this workshop we should be able to effectively create an efficient means of communication. Additionally we will be using XBee’s in our final project to allow for wireless communication. While in reality this changes little in terms of Processing and Arduino code, it is still interesting to add those additional layers on top of the Serial communication we will be doing.