Recitation9 Serial Communication(Leon)

Project one:

I forgot to change the numeber of the values at first, besides that, it goes pretty well.

Project Two:

I used the different postions of mouse to control the tone of the buzzer.

//First one
import processing.serial.*;

String myString = null;
Serial myPort;


int NUM_OF_VALUES = 2;   /** YOU MUST CHANGE THIS ACCORDING TO YOUR PROJECT **/
int[] sensorValues;      /** this array stores values from Arduino **/


void setup() {
  size(800, 800);
  background(0);
  setupSerial();
}


void draw() {
  updateSerial();
  printArray(sensorValues);
  println(sensorValues[0]);
  println(sensorValues[1]);

  // use the values like this!
  // sensorValues[0] 
  fill(255);
ellipse(sensorValues[0],sensorValues[1],20,20);
  // add your code

  //
}



void setupSerial() {
  printArray(Serial.list());
  myPort = new Serial(this, Serial.list()[0], 9600);
  // WARNING!
  // You will definitely get an error here.
  // Change the PORT_INDEX to 0 and try running it again.
  // And then, check the list of the ports,
  // find the port "/dev/cu.usbmodem----" or "/dev/tty.usbmodem----" 
  // and replace PORT_INDEX above with the index number of the port.

  myPort.clear();
  // Throw out the first reading,
  // in case we started reading in the middle of a string from the sender.
  myString = myPort.readStringUntil( 10 );  // 10 = 'n'  Linefeed in ASCII
  myString = null;

  sensorValues = new int[NUM_OF_VALUES];
}



void updateSerial() {
  while (myPort.available() > 0) {
    myString = myPort.readStringUntil( 10 ); // 10 = 'n'  Linefeed in ASCII
    if (myString != null) {
      String[] serialInArray = split(trim(myString), ",");
      if (serialInArray.length == NUM_OF_VALUES) {
        for (int i=0; i<serialInArray.length; i++) {
          sensorValues[i] = int(serialInArray[i]);
        }
      }
    }
  }
}

//Second one
import processing.serial.*;

int NUM_OF_VALUES = 2;

Serial myPort;
String myString;

// This is the array of values you might want to send to Arduino.
int values[] = new int[NUM_OF_VALUES];

void setup() {
  size(500, 500);
  background(0);

  printArray(Serial.list());
  myPort = new Serial(this, Serial.list()[0], 9600);
  // check the list of the ports,
  // find the port "/dev/cu.usbmodem----" or "/dev/tty.usbmodem----" 
  // and replace PORT_INDEX above with the index of the port

  myPort.clear();
  // Throw out the first reading,
  // in case we started reading in the middle of a string from the sender.
  myString = myPort.readStringUntil( 10 );  // 10 = 'n'  Linefeed in ASCII
  myString = null;
}


void draw() {
  background(0);

  // changes the values
  for (int i=0; i<values.length; i++) {
    values[i] = mouseX;
    values[1]=mouseY;
  }


  echoSerialData(200);
}

void sendSerialData() {
  String data = "";
  for (int i=0; i<values.length; i++) {
    data += values[i];
    //if i is less than the index number of the last element in the values array
    if (i < values.length-1) {
      data += ","; // add splitter character "," between each values element
    } 
    //if it is the last element in the values array
    else {
      data += "n"; // add the end of data character "n"
    }
  }
  //write to Arduino
  myPort.write(data);
}


void echoSerialData(int frequency) {
  //write character 'e' at the given frequency
  //to request Arduino to send back the values array
  if (frameCount % frequency == 0) myPort.write('e');

  String incomingBytes = "";
  while (myPort.available() > 0) {
    //add on all the characters received from the Arduino to the incomingBytes string
    incomingBytes += char(myPort.read());
  }
  //print what Arduino sent back to Processing
  print( incomingBytes );
}



Final Project: Part 2 (Proposal Essay) – Leon’s Class

Project Title

CPR trainer

Project statement of Purpose

The project, CPR trainer, will make a device that enables anyone from the age of 10 and above to practice giving CPR, by enabling them to get the right rhythm and pressure during the process.

Project Plan

We will first start off with researching the main problems arising from the use of CPR. Then from that, we will go through user testings to adjust to the comfort of the user and the purpose of ht project. The first prototype that we are planning to make is a basic body with a pressure sensor which could sense both the pressure and the tempo and this would be displayed using processing, through means such as 2 meters that represent how strong and fast the user is.

Context and Significance

One of the most common cause of death among adults is from a Heart Attack, especially through Cardiac Arrest. Cardiac arrest is the state where the heart stops beating and when the heart stops beating there is no oxygen flow throughout the body and in most cases, brain death will occur in less than 10 minutes. To prevent this an AED (Automated External Defribillators) are used. But statistics show that 70%-80% of cardiac arrest occur either in public areas or at home, AEDs are not in always in reach or may require time so instead what must be done is CPR(Cardiopulmonary Resuscitation). However, in many cases, unless they have been to basic life-saving classes, people do not know the correct way of giving CPR. From further research, we found that the most difficult part is getting the right tempo and pressure. Thus, our project will focus on those two factors. This project does indeed align with the definition of interaction that I’ve defined, as it is a two-way communication where the user sends information through his body movement, and the device gives the user information on how strong and fast his movement is and depending on that the user will change his motion and this process repeats. Products with similar concept do exist, however in many cases it is very unaffordable more over the feedback interms of the pressure and the tempo is very limited and is not detailed. Forexampl it would onyl give 3 diffrent colours of light to signify whether it is done right , slow, or too fast etc.

Hopefully, if this project is successfully completed, it could further, integrate the use of blowing into the mouth and making the device more realistic to a human body, while keeping in mind that the purpose is to make an affordable yet informative CPR trainer.

 

 

 

 

Final Project Proposal

Final Project

Name: Shenshen Lei

Instructor: Eric&Young

Group Partner: Annabel Smit 

For our final project, we aim to design an interactive game system that likes physical controlled online Bingo. Users May try to throw a ball on a certain place, and the ball would run into a tube. The end of the tube match with different shapes of buttons on the Arduino Board. When the button was pushed, the Processing page would then show some series of pictures. After that, the user will have a certification, maybe a piece of paper or other symbol stuffs to record their collected pictures. Customers who collect all kinds of pictures would win a gift. It could also be assimilated as a lottery. 

Plan: 

We decided to the Arduino part and the Processing part separately. To set up the Arduino that can sense the ball, we need a pushing switch. For the processing design, we may employ mouse-pressed or key Pressed function along with random choosing, and we also need to do some Processing paintings. After that, we will use some paper card and plastic materials to create the outlook of the game machine. We are also thinking about adding more functions such as group game that calls for cooperation or has chaining topic to keep people’s interests in playing the game.

Significant: 

Although this game is mostly for fun and depends on statistic data along with the user’s fortune, it does have concrete interaction aspect and a system that encourage people to have further interaction with the machine. Comparing with the midterm project that I have created, we want to make this project have more direct interaction with the users. Moreover, in this project, we have not thought to make a project that could be produced on a larger scale or to truly enter the market. This kind of idea based on our target to design an interactive project that helps people to relax and have fun. 

Week 11, Final Project Proposal Essay (Leon)

A. Project Title: LOSING CONTROL

B. Project Statement of Purpose *

Inspired by the “T-Rex” game conducted by Google Chrome when the internet is not connected,

and the sliding block puzzle “Klotski” originated in the early 20th century,

I have made up my mind to operate an interesting and meaningful game with a simple structure.

Relating to my current thought and experience,  I came up with an idea of making a game that can materialize the feeling of losing control by processing to send the audiences this sense of feeling and make a strong resonation towards them. People always feel better when they could acknowledge that there is somebody also understanding their feeling.

C. Project Plan *

Firstly, I intended to design a relatively big circle as the background and put a relatively small circle inside.

Secondly, I will give the small circle an increasing speed with a random direction (will be changed into one of the four random directions in every second), and a relatively higher but fixed speed which can be conducted by the keyCode “up”, “down”, “left”, and “right”.

Thirdly, when the small circle inside unavoidably hits the bigger circle, the game ends and will show the audiences the length of the time that they are still having control of the smaller one.

D. Context and Significance *

The projects and the interactions I have researched are all standing for the human nature of interacting. This really inspired me that a great interaction must be natural, must be something that is easy to understand, and easy to interact with. And in this way, it perfectly
suited the significance of nature declared in my previous definition of interaction.

The unique thing of this project is that it not only brings the audiences an interesting game with a natural interaction way but also sends the audiences a sense of materialized feeling and a precious aesthetic mood. And the strong resonation it makes is exactly where its value is.

Week 10, Rudi’s

In this week’s recitation, we got our hands on the sharing of the values between Arduino and Processing. With the examples given, it was easy to get a value by just using the existing code and the code left was same as the code written before. But I didn’t understand all of the code, especially the part of getting values. I only had an idea that the values were saved in an array. Also, though seeming small, the sequence of uploading and playing the Processing is important. The program which creates the values should be opened first. Additionally, it is helpful to find mistakes by using serial print where you can directly see whether getting values is wrong or the program of output is wrong.

 

 

 

//A to P (Arduino)
// IMA NYU Shanghai
// Interaction Lab
// For sending multiple values from Arduino to Processing


void setup() {
  Serial.begin(9600);
}

void loop() {
  int sensor1 = analogRead(A0);
  int sensor2 = analogRead(A1);
  

  // keep this format
  Serial.print(sensor1);
  Serial.print(",");  // put comma between sensor values
  Serial.print(sensor2);
  Serial.println(); // add linefeed after sending the last sensor value

  // too fast communication might cause some latency in Processing
  // this delay resolves the issue.
  delay(100);
}
//A to P (Processing)
// IMA NYU Shanghai
// Interaction Lab
// For receiving multiple values from Arduino to Processing

/*
 * Based on the readStringUntil() example by Tom Igoe
 * https://processing.org/reference/libraries/serial/Serial_readStringUntil_.html
 */

import processing.serial.*;

String myString = null;
Serial myPort;


int NUM_OF_VALUES = 2;   /** YOU MUST CHANGE THIS ACCORDING TO YOUR PROJECT **/
int[] sensorValues;      /** this array stores values from Arduino **/

int x= 0;
int y = 0;
void setup() {
  size(500, 500);
  background(0);
  setupSerial();
}


void draw() {
  updateSerial();
  printArray(sensorValues);

  x = sensorValues[0];
  y = sensorValues[1];
  x = int(map(x,0,1023,0,500));
  y = int(map(y,0,1023,0,500));
  ellipse(x,y,15,15);
}



void setupSerial() {
  printArray(Serial.list());
  myPort = new Serial(this, Serial.list()[13], 9600);
  // WARNING!
  // You will definitely get an error here.
  // Change the PORT_INDEX to 0 and try running it again.
  // And then, check the list of the ports,
  // find the port "/dev/cu.usbmodem----" or "/dev/tty.usbmodem----" 
  // and replace PORT_INDEX above with the index number of the port.

  myPort.clear();
  // Throw out the first reading,
  // in case we started reading in the middle of a string from the sender.
  myString = myPort.readStringUntil( 10 );  // 10 = 'n'  Linefeed in ASCII
  myString = null;

  sensorValues = new int[NUM_OF_VALUES];
}



void updateSerial() {
  while (myPort.available() > 0) {
    myString = myPort.readStringUntil( 10 ); // 10 = 'n'  Linefeed in ASCII
    if (myString != null) {
      String[] serialInArray = split(trim(myString), ",");
      if (serialInArray.length == NUM_OF_VALUES) {
        for (int i=0; i<serialInArray.length; i++) {
          sensorValues[i] = int(serialInArray[i]);
        }
      }
    }
  }
}



//P to A (Processing)
// IMA NYU Shanghai
// Interaction Lab


/**
 * This example is to send multiple values from Processing to Arduino.
 * You can find the arduino example file in the same folder which works with this Processing file.
 * Please note that the echoSerialData function asks Arduino to send the data saved in the values array
 * to check if it is receiving the correct bytes.
 **/


import processing.serial.*;

int NUM_OF_VALUES = 2;  /** YOU MUST CHANGE THIS ACCORDING TO YOUR PROJECT **/


Serial myPort;
String myString;

// This is the array of values you might want to send to Arduino.
int values[] = new int[NUM_OF_VALUES];

void setup() {
  size(255, 255);
  background(0);

  printArray(Serial.list());
  myPort = new Serial(this, Serial.list()[ 6 ], 9600);
  // check the list of the ports,
  // find the port "/dev/cu.usbmodem----" or "/dev/tty.usbmodem----" 
  // and replace PORT_INDEX above with the index of the port

  myPort.clear();
  // Throw out the first reading,
  // in case we started reading in the middle of a string from the sender.
  myString = myPort.readStringUntil( 10 );  // 10 = 'n'  Linefeed in ASCII
  myString = null;
}


void draw() {
  

  // changes the values
  values[0] = mouseX;
  background(mouseX);
  if (keyPressed == true) {
    values[1]=1;
  } else {
    values[1]= 0;
  }

  // sends the values to Arduino.
  sendSerialData();

  // This causess the communication to become slow and unstable.
  // You might want to comment this out when everything is ready.
  // The parameter 200 is the frequency of echoing. 
  // The higher this number, the slower the program will be
  // but the higher this number, the more stable it will be.
  echoSerialData(200);
}

void sendSerialData() {
  String data = "";
  for (int i=0; i<values.length; i++) {
    data += values[i];
    //if i is less than the index number of the last element in the values array
    if (i < values.length-1) {
      data += ","; // add splitter character "," between each values element
    } 
    //if it is the last element in the values array
    else {
      data += "n"; // add the end of data character "n"
    }
  }
  //write to Arduino
  myPort.write(data);
}


void echoSerialData(int frequency) {
  //write character 'e' at the given frequency
  //to request Arduino to send back the values array
  if (frameCount % frequency == 0) myPort.write('e');

  String incomingBytes = "";
  while (myPort.available() > 0) {
    //add on all the characters received from the Arduino to the incomingBytes string
    incomingBytes += char(myPort.read());
  }
  //print what Arduino sent back to Processing
  print( incomingBytes );
}

// P to A (Arduino)
// IMA NYU Shanghai
// Interaction Lab


/**
  This example is to send multiple values from Processing to Arduino.
  You can find the Processing example file in the same folder which works with this Arduino file.
  Please note that the echo case (when char c is 'e' in the getSerialData function below)
  checks if Arduino is receiving the correct bytes from the Processing sketch
  by sending the values array back to the Processing sketch.
 **/

#define NUM_OF_VALUES 3    /** YOU MUST CHANGE THIS ACCORDING TO YOUR PROJECT **/


/** DO NOT REMOVE THESE **/
int tempValue = 0;
int valueIndex = 0;

/* This is the array of values storing the data from Processing. */
int values[NUM_OF_VALUES];


void setup() {
  Serial.begin(9600);
}

void loop() {
  getSerialData();

  // add your code here
  // use elements in the values array
  // values[0]
  // values[1]
  if (values[1] == 1){
  tone(3, values[0]*4);
  }
  else{
    noTone(3);
  }
}


//recieve serial data from Processing
void getSerialData() {
  if (Serial.available()) {
    char c = Serial.read();
    //switch - case checks the value of the variable in the switch function
    //in this case, the char c, then runs one of the cases that fit the value of the variable
    //for more information, visit the reference page: https://www.arduino.cc/en/Reference/SwitchCase
    switch (c) {
      //if the char c from Processing is a number between 0 and 9
      case '0'...'9':
        //save the value of char c to tempValue
        //but simultaneously rearrange the existing values saved in tempValue
        //for the digits received through char c to remain coherent
        //if this does not make sense and would like to know more, send an email to me!
        tempValue = tempValue * 10 + c - '0';
        break;
      //if the char c from Processing is a comma
      //indicating that the following values of char c is for the next element in the values array
      case ',':
        values[valueIndex] = tempValue;
        //reset tempValue value
        tempValue = 0;
        //increment valuesIndex by 1
        valueIndex++;
        break;
      //if the char c from Processing is character 'n'
      //which signals that it is the end of data
      case 'n':
        //save the tempValue
        //this will b the last element in the values array
        values[valueIndex] = tempValue;
        //reset tempValue and valueIndex values
        //to clear out the values array for the next round of readings from Processing
        tempValue = 0;
        valueIndex = 0;
        break;
      //if the char c from Processing is character 'e'
      //it is signalling for the Arduino to send Processing the elements saved in the values array
      //this case is triggered and processed by the echoSerialData function in the Processing sketch
      case 'e': // to echo
        for (int i = 0; i < NUM_OF_VALUES; i++) {
          Serial.print(values[i]);
          if (i < NUM_OF_VALUES - 1) {
            Serial.print(',');
          }
          else {
            Serial.println();
          }
        }
        break;
    }
  }
}


Final Project Essay(Marcela)

Echo Chi

My idea of the final project is to build a smart alarm system which aims to alarm the user something is being moved. Its title is “where is my thing?”.

Since it is so common for me to lose or can’t find something and I am so worried that I spend a lot of time to look for them. Sometimes, these things are so important that I need to buy a new one. After asking and observing others, I found that almost everyone has been troubled in the same situation as me. So, when I was looking for my missing things, I always thought I can own a track system so that I can know where they are. Also, during my searching, the toughest problem is to memorize where it does disappear. So, when thinking about the final project, the first idea came into my mind is to build a smart system which can tell me when something is going farther and farther away from me, which means I drop it behind.

How to achieve this? My project may contain sensors. Users can set a distance and if the distance is larger than what the user’s setting, the result will be shown on the computer screen by processing. Also, it will connect to an alarm, if the distance is extending out of the standard, the alarm will make sounds. The farther distance the sensor senses something is far away from the sensor, the tone of the alarm will be higher. In addition, the computer screen will change colors or show the warning signals. In the coming weeks, I will spend almost all the time on coding but the next week, I am going to think about the progress and change to this system model because I know that the sensor cannot recognize a certain thing, so if something is in the front of the sensor, it may cause mistakes.

The preparatory research makes me think more about how to let the project tell me more, which means how to enlarge the outputs. So in this project, the sound and sights can both tell the users something. My research is talking about the project “Headlight”, which is a system let people change their surroundings to interactive dynamic images and sounds, which taught me I can turn the distance into the sound and sight. Also, my project, in my opinion, has achieved part of my definition of interaction since the images and sounds are changed by the people’s behavior and also these signals make people realize something and make something change. But the behavior people do to the project is so poor, and I am going to make some progress on it next week.

Interaction Lab Final Project Essay 11/16 by Cyrus Guo

Final Project Proposal

Documented on: November 16th, 2018

Documented by: Cyrus Guo

Instructor: Professors Eric & Young

Aim: State the core ideas for the final project

Final Project Proposal Essay

   Project Title

A.P. Snake

   Project Statement of Purpose *

The purpose of this project is to integrate Arduino and Processing to make a new, interactive spin on the classic game “snake”.  While looking at some Arduino and Processing projects, such as the flappy bird game project from howtomechatronics, I realized that recreating a classic video game with a more interactive twist is what I wanted to do for this project.  Just recreating a classic game would work, but to add interaction, an additional sensory input component makes the project much more interesting. Additionally, I want to have the entire game system self contained; screen and all. This may be difficult based on the materials that I have access to, but I want to do it anyways. I will have to purchase a small screen from online and find a suitable arduino board that is compatible with it.  In the end, the overall goal is to make a small, portable, and interactive game of Snake updated for the 21st century.

   Project Plan *

To create my A.P. Snake, I will need to do more research on Arduino and Processing interaction, see what is possible and what isn’t, and start building prototypes as soon as possible for user testing. Also, I want to use some sort of digital fabrication such as 3D printing and laser cutting, so I will need to review those processes as well.  Trying to make the system self contained will be very difficult as well, because an external screen (whether LED, IPS, or serial monitor) will require more components to connect everything together. First, I will focus on completing the functional part of the project (arduino+processing and sensors), then the screen component, then the portability portion. 

   Context and Significance *

The biggest inspiration for my project is the traditional “Snake” game.  However, this game isn’t interactive enough, so I want to add sensors as input instead of traditional game buttons. Because of Snake’s easy rules, the game is suitable for kids and adults alike, with kids enjoying the interactivity and adults actively trying to compete to achieve higher scores.  This project is unique because of it’s sensor inputs and it’s portability.  The interaction occurs not only between arduino and processing but also between the sensors and the person playing the game. 

 

Sources:

Initial Reference ideas (processing and arduino):  https://howtomechatronics.com/projects/arduino-radar-project/  

Flappy Bird project: https://www.youtube.com/watch?v=Rc_sbgp6Eho

 

final proposal

The title of my project is AstroBlast. My project would be based off of the popular game Astro Blaster. This would be for entertainment purposes, and would be interactive between the computer and the user. The user would have to use the sensor to move the spaceship around, and try to dodge things that are thrown at it. The game would get more challenging as time goes on, because objects would come down faster and the game would speeden up. My project combines the use of both the Arduino and Processing. For the animation, I would use processing to create the layout of the game, including the object that would move around, and the objects that would be falling down. I would also be able to manipulate the background through the coding in processing. Another code that I would add to processing is something that would signal the objects coming down faster as time goes on, and something that signals the spaceship to move when the sensor is moved. As to when it comes to the Arduino, the sensor would be connected, and the values of the Arduino would have to reflect on the processing code. One thing that I focused my research on was mostly games, because the objective of my project would be to used for enjoyment and something various age groups can use. My preparatory research and analysis were various games that included sensors. For example, one of the games that I read about was using an ultrasonic measurement module to fly a plane in a game. This is what led me to using a sensor as a way to control the movement of the object in my game. Another alternative that could be used for this game could be a joystick. Although, I would like to use the sensor for it to differ from the typical arcade game, and for it to have an alternative take on it. Interaction is when there is a reciprocal action, by both the user and the object. The output is either triggered by a motion or action by the other party/parties. There is no set amount of interaction, as different circuits require different levels of interaction. Different forms of interaction including moving, speaking, and touching. My project aligns with this definition because the action of the game is being triggered by the motion of the user.

Final Project: Part 1 (Definition of Interactivity) – Leon’s Class

Before the start of the course, our idea of what interaction means was very vague. Personally, my impression of “interaction” was mainly the image of two or more people having a conversation.  Then the first reading that we got was the first Chapter “WHAT EXACTLY IS INTERACTIVITY?” of the Book The Art of Interactive Design by Chris Crawford. This was the first access to a thorough discussion of what “interaction” was and had constantly been a source of reference for me while I was thinking about interaction throughout the course. The first definition stated in the passage is “a cyclic process in which two actors alternately listen, think, and speak.” The author further adds to this definition the idea of interaction being a degree from low interactivity to high interactivity.

However during the course, we had several opportunities to come up with our own definition of interaction and while I was making the definitions, the definition constantly shifted to different directions everytime I made them and was never concrete. Then I realised this was mainly due to the fact that I did not have a goal for what I wanted to achieve by coming up with my definition, or did not have criteria on what was a good definition. Thus, going back to what I believe the purpose of a definition should be I had reconsidered my definition. Firstly, for a definition to be functional it should serve the purpose of differentiating the noun its modifying from others. Moreover, it should minimise subjectivity as much as possible in order to make what it is describing to be as clear as possible. Through reconsidering my criteria of what a definition should achieve and the projects including the midterm project that we’ve done, the idea of interactive as a degree felt unsatisfactory. Firstly, the different levels of interaction seemed less of a spectrum but more of a staircase through my observation of different “interactive projects.” For example, a project the would constantly react to your movement, while the reaction of the user is not affected purposely by the product. This is an example of a mirror that constantly follows the position of the user.  Or a project that reacts once to one movement of the user which could be as simple as the light in a refrigerator as stated in the text. Or a project that reacts to the user, and the user reacts to the device considering what the device outputs, and repeats alternately. As can be seen, all the examples above have a clear difference rather than a degree. Moreover, the range from low to high interactivity seems too large and while discussing with my classmates, where the product stands in terms of the degree of interaction was much too subjective. As a result, the line between reacting and interacting became very vague.

The last example is what I believe is closest to what interaction should be and is something that we strongly kept in mind while deciding our mid-term project. We believed interaction should invoke processing/thinking everytime an output by the other actor is received and that would lead to a purposeful device. As a result, we made a product called “Finger Map” which depending on where you point, it would output a sound that reflects the distance the user would change direction as a result. This process would repeat as long as the user walks.

Keeping the above factors in mind the criteria I have determined to define interaction is the following:

  • The actor A ‘s action is the result of rationally deciding the most suitable action as a result of actor B’s action or the result of actor B purposefully guiding actor A, depending on the action of A
  • The two actors influence each other, in other words both actors send information to the other actor and receive information from the other actor.
  • The interaction between the 2 actors must exceed above 3 pair of response.

Ixlab Final Project Proposal Essay, MIKE JUNG

Throughout Interaction Lab, learning and experimenting about interaction lab, I am having alot of fun, and sometimes we face hard obstacles. The more I learn about interaction and how to use the techniques, I got more interested and into learning the techniques more. I define interaction as a source that help interact human senses to any object. Interaction is not only limited to touch but also smell, heat, waves, and more and more. As we get closer to the end of the course, I still think my definition have not changed much, since my definition is still compatible with the devices we have seen, research, and made. Although my definition of interaction did not change much, I still learned and and gained knowledge about interaction lab. As an example of Jeff and my midterm project, we had to give a further explanation on why  our sensors were not working. And even though it was a mistake we now know how the sensors work, and was able to fully understand our problems. From these mistakes and experiences, Jeff and I decided to work together as a group again to make progress and show that we could do better.

For our project, we (Jeff and I) proposed that we create a new interaction art with combining Arduino and Processing. Since last time, we just used cardboard, we want to give a try of using 3D printed box (laser cutter). Specifically, we will use mouseX,Y and MousePressed in processing. The servos will move according to if the mouse is whether or not pressed. My partner Jeff and I decided to model our final project after a drawing machine called DrawBots by Paul Brown, Bill Bigge, Jon Bird, Dustin Stokes, Maggie Boden, and Phil Husbands. The only difference is the level of complication. Our goal is not to create something that is for a purpose. We are creation this for our purpose of fun.