My Pet Plant – Kenan Gu – Marcela

For my final project, I want to create an intimate and authentic interactive experience for my users. Through my designs, I expect the users to realize the intelligence, autonomy and the diversity of this pet plant’s inner state, thus arising their further awareness of the protection of the plants and overall environment. To make the interaction of my project as authentic as possible, I began by reflecting on how interactions among human beings take place. I acknowledged that the most essential foundation of human interactions is senses. Human receive information with five senses: sight, hearing, smell, taste and touch. Thus, the first and most basic design for my project is that I decided to use sensors as the major input. The following up question is that, since I’m doing this project on my own and the limitations of my capabilities and time, I have to determine what kind of sensors I would like to use. I chose to use light sensor, moisture sensor and press sensor in the first place. For light and moisture sensor, they can be each applied to the scenarios of sunny, rainy day, which are two most fundamental conditions plants will experience in their life and also firmly related to my topic of environmentalism. As for press sensor, I use it with an intention to imitate touching because in my opinion touch is the most intimate interactions two alive entities can have because the physical distance of the two will no longer exist. Secondly, After deciding the main way of input for my project, I began to think about what interactive design I should implement for the processing and outputting. Due to the fact that humans’ interactions are always consists of certain logical sequences and vary corresponding to the change of input, I decided to create different reactions towards different domains of input sensor values for my plant with the usage of “if” function on the processing. For instance, when the values of light sensor(mock sun) are in a relatively low domain, there will be visual conversation bubbles (shown below) reading “it’s a nice day” on the processing. If the values are too high, the sentence will change to something like “the light’s too strong, it’s trying to kill me”. Also, I pay particular attention to the relations and interactions of the two different values abstracted from light and moisture sensor. If the values of light sensor are high but the values of moisture sensor are low, then there will be warnings like “feed me with some water”. At time time, when you give the plant a proper amount of water, the sentence you get will be “Get some Relief”. The purpose of designing multiple reactions is to make the project as intimate and humane as possible. The material I used for building the physical model of the plant is quite simple — it is a real plant I bought online. Initially I thought about building a physical model of fake plants with either 3D print or laser cutting. However, the details of the fake models can never be as rich as a real plant and will even leave the users with an implicit psychological implication that what they are interacting with is virtual and fake, which contradicts with my initial goal. Thus, after careful thinking, I chose to use a real plant.

Most of the work I’ve accomplished during the process of production is within the domain of software, in another word, the coding part. At the very beginning, I intended to create several complicated animations instead of using the unchangeable bubbles as the output. However, I found out later that this needed massive work and calculating that I can’t finish it on my own. After several consulting with my peers and a few instructors, I decided to use images to replace the initial idea of animations. Secondly, as I’ve demonstrated in the last paragraph, since the interaction my project will present sometimes are related to more than one value, I encountered some errors and failures when writing the “if” function to achieve my goal. I made several conditions overlapping together and the result I got were the invalidation and misplacement of interactions. I solve the issue by separating single-variable conditions and multivariable conditions, then put different visual images into the categories determined by those conditions. Thirdly, I failed when trying to integrate sounds into my project. Every time when I put sound under the if function, there will be unpredictable noises. At first I thought it was because of the incompatibility of the sound format, but it turned out that the “if” function should take the responsibility. When under if function, the sound file will be played thousands of time as long as the relevant values exceed several assigned limits, thus leading to the overlapping effect which will be mistakenly identified as noises. At that time I didn’t realize there was the “stop” function to solve this problem, so I just got rid of all sound effect. Lastly, due to the fact that the light and press sensor are too sensitive, the interactions the users will get will be not really stable. I was forced to reconsider if I should use these sensors or not. For the light sensor, my initial plan of using flashlight to be the light source was proved to be unrealistic because the positions and angles of the flashlights are uncontrollable. This means that I have to design a light source with fixed position. Thus, I built a container( Drawing 1) made by cupboard for my plant and solidified the position of two LED lights as the light source on the container. For the press sensor, since I can’t think any potential proper interactions I can make with it to increase the interactive level of my project and the fact that the values extracted from it almost represent as dichotomous, after careful discussions with my peers, I just removed it from my project.

Drawing 1

In the user testing session, I’ve received some really constructive suggestions. The first is that quite a few peers and professors suggested me to add an introductory mechanism for my project. Since they were unsure about what they should do with this plant, so they just naturally touch the plant or say something to it without acknowledging the existence of the buttons for the light or the water besides. In addition, even though some of the people who realized how to interact with my project in a proper way think the interaction seems too abrupt since it just appeared suddenly. Based on that, I designed an introductory interface in my project (sketch 1) shown below to inform my users that they can either “shine on” or “feed” the plants. Another improvement I have based on this issue is that I added a distance sensor to detect the position of my users. With that the plants will automatically wake up and present an introductory conversation bubbles when the users are within a certain distance, or the plant will not have any reactions or interactions because it is “asleep”. I think this two changes make my interaction more clear and authentic. The second feedback I found constructive is that someone told me it was hard to identify how much light or water the users need to give to the plant that can be considered as proper. To address that, I drew two bars like the sketch 2 shown below at the top left of  the display of the processing to show how many real-time “sunlight” and “water” the plant have currently. The fill color of the bars will change from green to red due to various situations. This design, in my opinion, makes my project more user friendly and entertaining, thus more appealing for the users to interact with.

Sketch 1

Sketch 2

My project is designed with the goal of creating an intimate and authentic interactive experience for the users to interact with the plant through the visualization and externalization of the inner state of the plant, thus raising people’s empathy towards the “silent plants” and their awareness of environmentalism. Based on my previous posts, my definition of interactions is that it should be a complicated and self-motivational “input-processing-output” process with a goal of stimulating great values and insights. In my opinion, my project aligns with my definition in a sense that it is a well-round “input-processing-output” interactive process with a clear logic of considerations of human interactions. Although it is not really that complicated, it retrieved the essence of  the diversity and sequence of interactions among humans and successfully applied it on the interactions between human and machines. The part I think my project not aligned to my definition of interaction is that although I tried a lot of designs to make it more authentic and entertaining, it is still lack of the characteristics of self-motivational. In the presentation in class, I could see that people are still uncertain and confused about how they should actually interact with my project without my instructions. Also, the multiple reactions I expect my users to have seem a little bit chaotic if they don’t do it in a fixed sequences, which definitely reduced the entertainment, intelligence and authenticity of my project. At the same time, various designs I chose, such as distance sensor and press buttons can’t be done simultaneously on one’s own, which is disruptive. Overall, the interaction is not that mature and self-motivational. If I have time, I will surely try to integrate sound into my whole project, or even use some as the dominant way of interaction because I realized that the visual word will be less impressive and easy to understand by human than verbal stimulations. However, this failure and unexpected situation of the eventual effect of my project taught me that we should always cling to our worthy trying ideas no matter how difficult it seems to accomplish cause maybe it will be the highlight of your interaction. Overall, I’m really happy about this whole journey of building an interactive project on my own and at least I’ve made something that is meaningful and contains the basic element of interaction. From this experience, the major takeaway I get is that idea wins. As long as you got ideas, you make full use of your imaginations and apply your creativity on your project, even though you may not that expert at coding or the functions you use are relatively basic, you can still create an innovative and excellent interactive experience.

In conclusion, this project is created and accomplished with two distinct values throughout the whole process. Firstly, it demonstrates my understanding of interaction and serves as a collection of what I have learned in this course, which is important for my future study because it gave me the opportunity to acknowledge the difficulty as well as the fulfillment of building a mature and completed project. You need to put a lot of effort into this project that it can look at least not that shabby, along the way there will be tons of setbacks and faults you need to identify and correct and you may suffer the mental stress and anxiety because what you want to achieve is always more than what you can in reality. This further inspired me to appreciate how human interactions are so sophisticated and show respect to those computer engineers who spark themselves for creating so many highly-interactive products for making the world better, for granting us with the tools of changing the world. Secondly, as I’ve illustrated several times, I want my project function to provoke people’s awareness towards the long-lasting ignorance and invisibility of plants, which constitute a significant element of the live species in the earth. In an era when climate change becomes the most critical issues and seems to be impossible to solve, we should always keep in mind that the plants undertake the most sufferings from climate change but still contribute the most to try to address this issue caused mainly by human civilizations. Plants can’t express their own feelings verbally or visually, but we can make them “talk and express” with the assistance of technology. My project is just an initiative, a tiny start, but I believe there have already been someone who share the same concerns and thoughts with me are working on making the society even a better place. I’m really grateful for taking this course because it not only taught me new skills which are essential in this rapidly changing world, but also presents me the glorious beauty of the conjunction of art and technology.

Comments:

In this recitation, I learned how we can make really cool and interesting animations with the processing. The fact that we can create animation with processing is important because it lays a foundation for the construction of  highly interactive projects. Since the world is in a constant state of movement and dynamic, thus animation is an essential part of integrating real-life interaction into our projects. This recitation made me understand that even simple animation can be really interesting and worthy viewing. 

One of the most interesting function I use is the random function with keypressed function. This function allows the background to change in a fast frequency while press the keys, thus turning the processing display into a really fascinating and artistic. Other interesting functions I used:

• Rotate
• ColorMode
• Translate
• PopMatrix
• PushMatrix

Codes and Videos of recitation exercise:

Codes: 

float angle = 0;
int x;
void setup(){
size(500,500);

}

void draw(){
background(0);
angle = frameCount;
rectMode(CENTER);
pushMatrix();
translate(width/2,height/2);
rotate(radians(angle));
rect(x,0,100,100);
x=0;
popMatrix();

if(mousePressed){
x= 100;
}
if(keyPressed){
background(random(0,255),random(0,255),random(0,255));
pushMatrix();
translate(width/2,height/2);
rotate(radians(angle));
rect(x,0,100,100);
x=0;
popMatrix();
}
}

Videos:

Codes and Videos of Homework:

Codes:

int v = 100;
int speed = 4;
int i = 0;
int j = 0;
int z = 0;
int speedb = 1;
int w = 0;
int h = 0;
int eX;
int eY;

void setup(){
size(600,600);

}

void draw(){
//ellipseMode(CENTER);
background(#FFFFFF);

noFill();
strokeWeight(20);
colorMode(HSB, 100, 100, 100);
stroke(i, j, z);
i = i + speedb ;
j = j + speedb ;
z = z + speedb ;
if (i > 100 | j> 100 | z > 100| i < 0| j < 0| z < 0 ){
speedb = – speedb;
}

ellipse(eX, eY, v, v);
eX = width/2 + w;
eY = height/2 + h;
v = v + speed;
if (v > 280 | v < 80){
speed = -speed;
}

}

void keyPressed() {
if (key == CODED) {
if (keyCode == LEFT){
w = w – 6;
} else if (keyCode == RIGHT) {
w = w + 6;
}
}

if (key == CODED) {
if (keyCode == UP) {
h = h – 6;
}
else if (keyCode == DOWN) {
h = h + 6;
}
}
}

Videos:

Reflection on My Essay

     In this recitation, the project I created is to use the potentiometer to control the speed of the videos presented in Processing. This interaction is fairly simple from the surface. However, this interaction can be a initial step of some really complicated projects of “Computer Vision”. In Golan Levin’s article, he referred to “Computer Vision” as “a broad class of algorithms that allow computers to make intelligent assertions about digital images and videos”. The most representative example of “Computer Vision” in the contemporary world, as mentioned in the article, is the tracking of human behaviors, including facial expressions, verbal language and body language. Then, the quantitative variables taken from the human behaviors are intellectually identified and processed by the computers in order to achieve multiple functions and generate innovative interactions. My recitation project also contains this process. The behaviors of mine controlling the potentiometer create changes of variables that can lead to the outcome of the changing of certain parameters in the visual representations(here is the speed of the video). The similarity between the definition of “Computer vision” and my project is that the visual representations on the computers respond to human behaviors. The difference is that for those typical example of “Computer Vision” like tracking, the computer continuously respond to human behavior with autonomy and without the intervene of human beings. While in my project, the computer will not respond until you actively engage in the computational system (here the linkage is the potentiometer, which can be seen as a appetix of the system). Thus, as I illustrated, my project is the initial and primitive model of the “Computer Vision”.

    This article inspired me a lot for my final projects. Before reading that, I didn’t realize that the direct identification of human behaviors without the assistance of medium, such as keyboard, mouse or joystick can be that difficult. This inspired me to think more about the distinctions between human and computers with a focus on the huge differences of language and ways of expressions. For my final project, I planned to use mouse and keyboard as the major equipment for conducting interaction. After reading this article, now I am thinking about a more direct and thus more interactive way of interaction between my projects and users. I will keep on figuring a better solution out in the future three weeks.

Codes of My Project

Code for Arduino:

void setup() {

 Serial.begin(9600);

}

void loop() {

 int sensor1 = analogRead(A0);

 

 // keep this format

 Serial.print(sensor1);

 //Serial.print(“,”);  // put comma between sensor values

 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);

}

Code for Processing:

import processing.serial.*;

import processing.video.*;

Movie myMovie;

String myString = null;

Serial myPort;

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

int[] sensorValues;      /** this array stores values from Arduino **/

void setup() {

background(0);

 size(480, 480);

 myMovie = new Movie(this, “1.mp4”);

 myMovie.loop();

 setupSerial();

}

void movieEvent(Movie myMovie) {

 myMovie.read();  

}

void draw() {

 updateSerial();

 printArray(sensorValues);

 // use the values like this!

 // sensorValues[0]

 // add your code

image(myMovie, 0, 0);   

 float newSpeed = map(sensorValues[0], 0, 1023, 0.1, 5);

 myMovie.speed(newSpeed);

 //

}

void setupSerial() {

 printArray(Serial.list());

 myPort = new Serial(this, Serial.list()[ 7 ], 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]);

       }

     }

   }

 }

}

Completed Video of My Project

Project Title

The title of my final project is “Your Pet Plant”

Project Statement of Purpose

Environmental issues such as climate change, pollution and sustainability have often been considered as the most significant issues in the 21th century since they are tightly connected with human beings’ fate in the future. However, one of the obstacles for addressing these environmental issues is that the public are not aware of how urgent and severe the situation is. The “Yellow Vest Movement”, along with other protests against “environmental taxation” around globe, and the America’s shocking and surprising withdrawal of the “Paris Agreement” intended for global corporation in addressing climate change. All of these political and social events happened in the last decade keep dividing our collectivity and reminding me of the lack of the awareness and consensus. Moreover, as one of the most important element of addressing environmental issues, plants are continuously ignored. When asking for the potential solutions, people mainly focus on strategies like limitation of carbon emission or innovation of new energy, while forget that plants play an important role in maintaining the stability of the climate and purification of the pollution. From my research, I learned that the ignorance of plants derived from their subjectivity. Unlike animals, plants aren’t able to engage in a direct interaction with humans with verbal, facial, body signals. Thus, the emotional attaches between us are limited by this insufficiency of language. For this reason, I would like to create this kind of “Pet Plant” to externalize and visualize the interactions between human and plants in order to stimulate and deepen people’s recognition of plants as a living entity, which may eventually raise public awareness of environmental issues.

Project Plan

The major structure of my project would be an instant imitation. I will create a visual image of a plant with processing, users can interact with the plant in the processing by pointing the mouse on different parts of the plants and see different animations the plant will present as reactions for expressing its emotion and thoughts. Meanwhile, I want to build a physical model with Arduino so that every instruction of the user can be transform into the physical world instantly. I think through this interaction and imitation from virtual world to physical world, the user are more likely to build on a close relationship and emotional connections with those “plants” since they can feel the real existence of them. My plan is to firstly finish writing the code in processing by the end of next week (week 12). Then I would try to build the physical model and connect the physical with the virtual plant in week 13 by recitation. For week 14 when we are supposed to finish out final project, I am planning to do some user tests in order to identify the shortcomings of my project and seek improvement.

Context and Significance

The idea of my final project originated from a project I’ve accidentally encountered on “Creative Applications Network”. The project is called “Pour Reception”. The designers of this project use water as a “digital interface” to control the radio. Different behaviors with regard to the two bottles and the water within represent different instructions. For instance, pouring water from one bottle to the other is the to switch stations and putting your fingers into the water is to pause. This project is really striking to me since it is artistically appealing. Technically, this innovative interface is not practical since the interaction may be a little bit complicated but for me it is really artistic and elegant, which help slow down the frequency of life and strengthen the relationship between humans and items. According to my preparatory research and analysis, one important feature I added on to my definition of interaction is that the interactive project should be motivational and appealing to the audience. In the previous project I research, the aesthetic value of its interaction is the appealing point. This project gave me the inspiration that the interactions we create must get in touch with our inner state and provide us with high-level, psychological and valuable satisfaction that they can be truly motivational. Thus, for my final project, I would like to anthropomorphize and externalize the interaction between human and plants in attempt to help build initial emotional attachments. However, I think my plan still have lots of space for improvement. Initially, I want to design a mutual interaction, which suggests that you can not only implement the instructions from the Processing to the Arduino, but you can also reversely interact with the physical model to change the visual representations in the Processing. Concerning the explicit hardness, I would make this idea as a backup if I can finish my plan beyond the schedule. I think this project has a bright prospect if we can design a wireless control system so that people can interact with plants that are far away from them with their electronic devices.