The FIrst YeAr AT ItP

Flash isn’t still easy to me. Here is my short work, “listening to music.” I wish it’s longer a little bit, It’s short again. Anyhow, now, I love it.

Amanda, Corey and I directed the movie, “ParkChase.” It was totally fun. We went to the Central Park and taped. Even though weather was chilly, Estee and Oscar acted well. They are awesome. Special thanks to actors!!

We all members edited and have a lot of time to discuss for scenes.

Woman: Estee Wah

Man: Oscar Torres
Policeman: Corey Menscher

* When we shoot, putting camera on the same position was difficult because, even though we filmed depending on the each place, we had many unexpected situations, such as passersby, camera checking, and recapturing.. etc..

AfterEffect part was on the Estee’s running. She imagined herself to be murdered on the newspaper….

Corey, Amanda, and I choose the running idea among bunch of other ideas.

Amanda and I drew.

‘Comic is one of the milestones to see the people’s otherness’. This is the most interest concept in this book to me. When people read comics, one single line can make the vacuum world and people substitute themselves by a character and comic environment.

The phenomenon of this is because of one single line instead of detailed description, closure, and unconsciousness. Understanding comics said.

Comics lied in shadow to me, like comics itself it did. I did not know there is a philosophy in comic world. I just had read comics for fun in the past. That’s it. However, in this book, Understanding Comics, It says that comics are the special language that makes symbol, shows the people’s mind, and makes communication in that the mixture of pictures and writing. That is, the combination of received information and perceived information. Through this, it can expand people’s senses with imagination. By following the each box, boxes makes environment of time and motion as well.At this point, there is the ‘Subject’ changed into the ‘Other’. Because of human’s unconsciousness, “closure” allow comics to become real story.

Simple lines instead of the detailed description help it, too. I think the line has the enough room people break into for imagination.

The more I understand about comics, the more I think this sequential art is related on the people’s mind.

The Plant pet was a device and toy that helps people to control their emotion and stress by raising experience. Depending on care(touching a leaf), it can make a growth and dancing. It needs 9 times the number of touching for half inches growth.

<< Plant pet shapes>>

For the final work, I made different color structure. I didn’t like to choose green

color because of the reason it is a plant. However, because shape of the plant pet is now more like cute toys, so, I chose the green one rather than other color.

This is the final work with two motors for growth and dancing.

<<The final mechanism >>

By using the second motor for dancing, I had to install the second motor on the top of the lever. As Tom recommends the position, I would put the second motor the effort side rather than load side of the lever. And, for the balancing the lever and coming down the wire which regulate the height, I put the spring below the lever.

Now, depending on the touching time, the plant pet makes the growth and then if it’s grown up, it makes dancing by people’s touch.

<<Code for controlling two motor by concept>>

int analogValue; // values from a sensor
int analogPin; // pin 0
int count =0; // whenever coming to the first value, count
int countForServo; // whenever count be the odd, another counter count

long currentTimeValue = 0; // values for checking time when values comes
boolean touched = false; // values for whether it’s touched or not
int servoPin1 = 3 ;
int servoPin2 = 9; // analog output pin

int refreshTime = 20; // 20msec for servo
int i=0;

int miniPulse = 600; // miniPulse
int maxPulse = 2400; //maxpulse

int servoPulse1 = miniPulse; // put the minipulse into the servoPulse
int servoPulse2 = miniPulse;

long lastPulse1 = 0; //
long lastPulse2 =0;

int servoSpeed =1;
int servoSpeed2 = 50;
int tempPulse;

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

void loop(){
analogValue = analogRead(analogPin); // anaogread

// if I get the analogvalue and the first value , count
if(analogValue > 20 && touched == false){ // if anaogValue comes in and touched was not changed yet(first value)
count++; // counting
currentTimeValue = millis();
if(count % 1 == 0){

countForServo++;
}
touched=true;

}else if (analogValue <= 20){
touched = false; }

// output depending on how many times i touch sensor
// analogWrite(blinkPin, servoPulse); // analog write if(countForServo >2){ // countforservo becomes over 3

if(servoPulse1 < maxPulse){ // until the pulse become 2400
servoPulse1 += 50; // add 50 and sum up
refreshServo();
}
countForServo = 0; // if countforled become over 3, count become 0
}

if (servoPulse1 >= maxPulse){ // if brightness become over 2400,
servoPulse1 = maxPulse; // brightness become 2400
refreshServo();
tempPulse++;
if(servoPulse1 == maxPulse && tempPulse <30000){
makeServo();
}
else{
tempPulse =0;
}
count =0; // make the count zero
}

if( millis() - currentTimeValue > 3000){ // if it has not gotten any value 3 seconds later from currentTimeValue,

if(servoPulse1 > miniPulse){ // substract 5 and sum up
servoPulse1 -= 5;
refreshServo();
}

if(servoPulse1 <=miniPulse){ // if servoValue becomes below 600
servoPulse1 = miniPulse; // value becomes 600
}
}

// print all values
Serial.print(” analogValue : “);
Serial.print(analogValue);
Serial.print(” count : “);
Serial.print(count);
Serial.print(” countForServo : “);
Serial.print(countForServo);
Serial.print(” servoPulse1 : “);
Serial.print(servoPulse1);
Serial.print(” servoPulse2 : “);
Serial.print(servoPulse2);
Serial.print(” currentTimeValue : “);
Serial.print(currentTimeValue);
Serial.print(” millis : “);
Serial.println(millis());
}

void refreshServo(){
if(millis() - lastPulse1 > 20){
digitalWrite(servoPin1,HIGH);
delayMicroseconds(servoPulse1);
digitalWrite(servoPin1,LOW);
lastPulse1 = millis();
}
}

void makeServo(){
if(millis() - lastPulse2 > 20){
digitalWrite(servoPin2,HIGH);
delayMicroseconds(servoPulse2);
digitalWrite(servoPin2,LOW);
lastPulse2 = millis();
}
servoPulse2 += servoSpeed2;

if(servoPulse2 >=2000){
servoPulse2 = 2000;
servoSpeed2 = -100;
}
if(servoPulse2 < 800){
servoPulse2 = 800;
servoSpeed2 = 100;
}
}

============>

When I made the plant pet prototype, even though a material was paper, it was too heavy to pull because the fulcrum was moved to the left to make big height. Thus, to solve this problem I choose paper which is lighter and stretchable paper than normal one. And, to lessen friction, I made small pulley.

<< pulley and touching leaf >>

After experiments, I decided to use lever mechanism and servo motor.

<<The principle of leverage>>

the point where you apply the force is called the effort. The effect of applying this force is called the load. The load arm and the effort arm are the names given to the distances from the fulcrum to the load and effort, respectively. Using these definitions, the Law of the Lever is :

Load arm X load force = effort arm X effort force.

There are three classes of levers(first, second, and third-class) which represent variations in the location of the fulcrum and the input and output forces. -Wikipedia-

A first-class lever is a lever in which the fulcrum is located in between the input effort and the output load. For the project, I use the principle of the first class lever.

A servo motor makes 180 degree and other motors like DC and Stepper make rotating. So, the mission of mechanism in this project is how the mechanism makes a growth and how long mechanism can lift a plant.

<<Gears>>

< 15teeth Gear/ 30teeth of Gear>

For drawing and buying gears, you can download a free software from the Emachineshop site. ( http://www.emachineshop.com/)

<<Stepper motors>>

To use gear mechanism, I made an experiments controlling stepper motors. The hard part of controlling stepper motor is choosing which lines are for power supply. So, I have to use multimeter and check the resistance between two lines among six lines.

Sometimes,  motor didn’t turn and  was at the standstill and make a tick. However, It was because breadboard’s connection was bad.

So, I had to keep pushing a part of the breadboard and then motor was rotated.

#include <Stepper.h>

#define motorSteps 360
#define motorPin1 8
#define motorPin2 9
#define ledPin 13

Stepper myStepper(motorSteps, motorPin1,motorPin2);

int analogValue; // values from a sensor
int analogPin; // pin 0
int count =0; // whenever coming to the first value, count
int countForStepper=0; // whenever count be the odd, another counter count

long currentTimeValue = 0; // values for checking time when values comes
boolean touched = false; // values for whether it’s touched or not

int i=0;

void setup(){
myStepper.setSpeed(60);
Serial.begin(9600);
pinMode(ledPin,OUTPUT);
blink(3);
}

void loop(){
analogValue = analogRead(analogPin); // anaogread

// if I get the analogvalue and the first value , count
if(analogValue > 20 && touched == false){ // if anaogValue comes in and touched was not changed yet(first value)
count++; // counting
currentTimeValue = millis(); // the value of millis currentTimeValue

if(count % 3 == 0){ // every three times

countForStepper++; //counting

}
touched=true; // 그리고 터치는 바로 false가 된다.
}else if (analogValue <= 20){ // 그렇지 않고 analogValue가 20보다 작으면
touched = false; // 터치불린 밸류를 false로 만듬
}

// output depending on how many times i touch sensor
// analogWrite(blinkPin, servoPulse); // analog write

if(countForStepper > 3){ // countforservo becomes over 3
myStepper.step(1);

count =0; // make the count zero
countForStepper = 0;
} // if countforled become over 3, count become 0

if( millis() - currentTimeValue > 3000 && millis() - currentTimeValue < 5000){ // if it has not gotten any value 3 seconds later from currentTimeValue,
for(i=0; i<15; i++){
myStepper.step(-1);
delay(500);
}

}

// print all values
Serial.print(” analogValue : “);
Serial.print(analogValue);
Serial.print(” count : “);
Serial.print(count);
Serial.print(” countForStepper : “);
Serial.print(countForStepper);
Serial.print(” currentTimeValue : “);
Serial.print(currentTimeValue);
Serial.print(” millis : “);
Serial.println(millis());
}

// Blink the reset LED:
void blink(int howManyTimes) {
int i;
for (i=0; i< howManyTimes; i++) {
digitalWrite(ledPin, HIGH);
delay(200);
digitalWrite(ledPin, LOW);
delay(200);
}
}

According to my final project idea, the first step for the final project is making code for touching with sensor. touching mechanism is like this. When people touch a plant-pet, the pet will recognize care. Then, 9times touch will make a growth little by little.

1. A sensor experiment with LED

<<IR sensor data graph>>

Regardless of any sensors, depending on how many times i touched sensor, LED will be getting brighter and dimmer.

<code>

int analogValue; // values from a sensor
int analogPin; // pin 0
int count =0; // whenever coming to the first value, count
int countForLed; // whenever count be the odd, another counter count
long lastTimeValue = 0;
long currentTimeValue = 0;
int pressedStart = false;
int blinkPin = 3; // analog output pin
int brightness; // degree for change

long lastValue[2]; // previous value and time
long currentValue[2]; // current value and time

void setup(){
Serial.begin(9600);
lastValue[0] = currentValue[0] = analogValue; // put the analogvalue in first array - setting
lastValue[1] = currentValue[1] = millis(); // put the time in the second array - setting
}

void loop(){
analogValue = analogRead(analogPin); // anaogread

lastValue[0] = currentValue[0]; // put the current value into the last value
currentValue[0] = analogValue; // put the analog value from analogread into the current value
lastValue[1] = currentValue[1]; // put the current time value into the last time value
currentValue[1] = millis(); // put the time value from millis() into the current time value

// if I get the analogvalue and the first value , count
if(analogValue > 3 && lastValue[0] * currentValue[0] == 0){
count++;
//lastTimeValue = millis() ;
currentTimeValue = currentValue[1] ; // 첫번째 아날로그밸류가들어오면 그떄의 시간을 다른곳에 저장

if(count % 2 ==1){ // and count become the odd number
countForLed++; // countforled be counted
}
}

// output depending on the how many times do i touch sensor
analogWrite(blinkPin, brightness); // analog write
if( countForLed >3){ // countforled become over 3
if(brightness<255){ // until the brightness become 255
brightness +=10; // add 10 and sum up
}
if(brightness >=255){ // if brightness become over 255,
brightness =255; // brightness become 255
count =0; // count zero
}
countForLed = 0; // if countforled become over 3, count become 0
}

if (millis() - currentTimeValue > 1000){
brightness– ;
count = 0;
if(brightness < 0){
brightness = 0;
}
}

// print all values
Serial.print(” analogValue : “);
Serial.print(analogValue);
Serial.print(” count : “);
Serial.print(count);
Serial.print(” countForLed : “);
Serial.print(countForLed);
Serial.print(” brightness : “);
Serial.print(brightness);
Serial.print(” currentTimeValue : “);
Serial.print(currentTimeValue);
Serial.print(” millis : “);
Serial.println(millis());

}

2. A sensor experiment with servo motor

Unlike LED, a servo motor needs to be considered with time values. And, Because touching is based on the time- if I didn’t touch for 3 second, led was getting dimmer-, I was confused about how to make code with servo at first. However, once i got the concept for controlling servo motor, I made the code. For controlling servo motor, minimum pulse, maximum pulse, and refresh time( 20 micro second for this servo) is needed. For looking for the angle and putting it on exact position, digital write is needed as well.

<code>

int analogValue; // values from a sensor
int analogPin; // pin 0
int count =0; // whenever coming to the first value, count
int countForServo; // whenever count be the odd, another counter count
int blinkPin = 13;
int brightness;

long currentTimeValue = 0; // values for checking time when values comes
boolean touched = false; // values for whether it’s touched or not
int servoPin = 2; // analog output pin

int refreshTime = 20; // 20msec for servo
int i=0;

int miniPulse = 600; // miniPulse
int maxPulse = 2400; //maxpulse
int servoPulse = miniPulse; // put the minipulse into the servoPulse
long lastPulse = 0; //

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

void loop(){
analogValue = analogRead(analogPin); // anaogread

// if I get the analogvalue and the first value , count
if(analogValue > 20 && touched == false){ // if anaogValue comes in and touched was not changed yet(first value)
count++; // counting
currentTimeValue = millis(); // 그 때의 밀리스값을 currentTimeValue에 저장하기
if(count % 3 == 0){ // 3번 터치할때마다
countForServo++; // 모터를 위한 카운트를 센다
}
touched=true; // 그리고 터치는 바로 false가 된다.
}else if (analogValue <= 20){ // 그렇지 않고 analogValue가 20보다 작으면
touched = false; // 터치불린 밸류를 false로 만듬
}

// output depending on how many times i touch sensor
// analogWrite(blinkPin, servoPulse); // analog write // 서보모터는 아날로그 라이트로 쓸수 없다.
if(countForServo > 3){ // countforservo becomes over 3

digitalWrite(blinkPin,HIGH);
delay(servoPulse);
digitalWrite(blinkPin, LOW);

if(servoPulse < maxPulse){ // until the pulse become 2400
servoPulse += 50; // add 50 and sum up
if(millis() - lastPulse >= refreshTime){ // if lastPulse is over 20
digitalWrite(servoPin,HIGH); // digitalWrite High
delayMicroseconds(servoPulse); // same as servopulse’s length, delay(pwm)
digitalWrite(servoPin, LOW); // digitalWrite Low
lastPulse = millis(); // put the time into lastPulse
}
}

if (servoPulse >= maxPulse){ // if brightness become over 2400,
servoPulse = maxPulse; // brightness become 2400

if(millis() - lastPulse >= refreshTime){ // 그 펄스대로 딜레이
digitalWrite(servoPin,HIGH);
delayMicroseconds(servoPulse);
digitalWrite(servoPin, LOW);
lastPulse = millis();
}
count =0; // make the count zero
}
countForServo = 0; // if countforled become over 3, count become 0
}

if( millis() - currentTimeValue > 3000){ // if it has not gotten any value 3 seconds later from currentTimeValue,

if(servoPulse > miniPulse){ // substract 5 and sum up
servoPulse -= 5;

if(millis() - lastPulse >= refreshTime){ // digitalWrite
digitalWrite(servoPin,HIGH);
delayMicroseconds(servoPulse);
digitalWrite(servoPin, LOW);
lastPulse = millis();
}
}

if(servoPulse <=miniPulse){ // if servoValue becomes below 600
servoPulse = miniPulse; // value becomes 600
}
}

// print all values
Serial.print(” analogValue : “);
Serial.print(analogValue);
Serial.print(” count : “);
Serial.print(count);
Serial.print(” countForServo : “);
Serial.print(countForServo);
Serial.print(” servoPulse : “);
Serial.print(servoPulse);
Serial.print(” currentTimeValue : “);
Serial.print(currentTimeValue);
Serial.print(” millis : “);
Serial.println(millis());
}

Whenever I grow my own plants, I always make them die. I don’t know why. Besides, whenever I come back to home, sometimes, without any talking, I want something that could give me a comfort. This is my beginning of this project.

I think people want to have an object to take care of and at the same time they want to be taken care of. Besides, I always think that this is similar to that people make an interaction- listening, thinking, and speaking. By having counterpart and reflecting by others, people can confirm who they are and get some energy to live.

I don’t want to make a living creature. but, through this plant, I want to people could get a consolation and relieve their loneliness and stress.

<Concept>

the Plant-Pet can be grown depended on how many times people take care of it.

Here are sensors that I have to make experiment.

1) Photocell/ Ultrasonic /Approximate sensor

2) Humidity / Thermistor sensor

<Another example of “a carebot”>

1)Gecko - a petrol-bot

2)Omo

This is a relational object by Kelly Doson. She call it “Omo”. This is “carebots” or “Companion robot.”

She said that Omo’s role is empathic and sometimes unexpected rather than normative. Omo breathes and senses the breathing of anyone interacting closely with it, matching—or seeking to lead—patterns of breathing. Omo does not always privilege soothing.

<drawing for the project>

This is the mechanism of umbrella

creeping plants /