Final Project

I wrote a paper about the Teach Me Kitty.

Virtual Creature Creator

You can find the class-report & video demonstration at

www.sjstevewon.com/portfolio/vcc

Thanks,

Steve

photos from the final MTI 08 open house

http://flickr.com/photos/blindspot/sets/72157608693453333/

thanks to Amy Bickerton

documenting your MTI project

Documenting your “Making Things Interactive” Project

You may choose a method of documenting your project that you feel is most appropriate for the project and its intended audience.  Regardless of the method you choose, your documentation should be clear, thorough, and have high production values.  (High production values means high-quality photographs, well-produced audio/video, and good writing).

Your document should convey: What you did, why you did it, and how it works. It should be possible for a competent graduate student to build your project by referring to your document.

You must link your document and any supporting materials (video, code, etc). on the class blog.

You may, for example, make an “instructable” (instructables.com) on how to build your project.

You may make a narrated how-to video presentation on your project (similar to Johnny Lee’s Wiimote videos)

Alternately, you may prepare a short paper in SIGCHI format: http://sigchi.org/chipubform/

Your paper would then have the following sections:
Title
Abstract
Introduction (motivation and rationale)
Related work (other similar projects and how yours differs)
Description (of your project: what, how)
Lessons learned
references

Project – See, See

Get Arm here

Massive Arduino Code:

Note: this is for Arduino 0011’s servo library

————————————————————————————–

#include <Servo.h>

// base sweep range
int base_limit_low = 20;
int base_limit_high = 80;
int base_center = 50;

//shoulder sweep range
int shoulder_limit_low = 60; //foward
int shoulder_limit_high = 90; //back
int shoulder_center = 50;

//elbow sweep range
int elbow_limit_low = 60; //up
int elbow_limit_high = 90; //down
int elbow_center = 75;

//wrist sweep range
int wrist_limit_low = 10; //down
int wrist_limit_high = 90;//up
int wrist_center = 60;

//turn sweep range
int turn_limit_low = 30;  //CW
int turn_limit_high = 80; //CCW
int turn_center = 50;

//grip sweep range
int grip_close = 20; //close
int grip_open = 60; //open

//servo attatchments
Servo base; //analogue 0
Servo shoulder; //analogue 1
Servo elbow; //analogue 2
Servo wrist; //analogue 3
Servo turn; //analogue 4
Servo grip; //analogue 5

//joint positions
int base_pos;
int shoulder_pos;
int elbow_pos;
int wrist_pos;
int turn_pos;
int grip_pos;

//IR stuffs
int lowEnd = 90;
int IRsensor = 5;//analogue pin 5

//video stuffs
int cam1 = 1; //digital 1
int cam2 = 3; //digital 3
int cam3 = 5;  //digital 5
int flash = 250;//blink time
boolean coin = false; //flash counter

//misc
int increment = 1; //degree increment for the servos
int sweep_direction_base = 1; //directional tokens
int sweep_direction_shoulder = 1;
int sweep_direction_elbow = 1;
int sweep_direction_wrist = 1;
int sweep_direction_turn = 1;
int sweep_direction_grip = 1;
boolean reset = false; //reset token
int pulse1 = 30;
int pulse2 = 50;
int reset_time = 5000; //initial reset time
unsigned long time;

void setup()
{
base.attach(14); //analog pin 0
shoulder.attach(15); //analog pin 1
elbow.attach(16); //analog pin 2
wrist.attach(17); //analog pin 3
turn.attach(18); //analog pin 4
//grip.attach(19); //analog pin 5

base.setMaximumPulse(2200); //set max pulse
shoulder.setMaximumPulse(2200); //set max pulse
elbow.setMaximumPulse(2200); //set max pulse
wrist.setMaximumPulse(2200); //set max pulse
turn.setMaximumPulse(2200); //set max pulse
Serial.begin(9600);

//initialize joint positions
base_pos = base_center;
shoulder_pos = shoulder_center;
elbow_pos = elbow_center;
turn_pos = turn_center;
wrist_pos = wrist_center;
//grip_pos = grip_open;

//cameras
pinMode(cam1, OUTPUT); //arm cam
pinMode(cam2, OUTPUT);
pinMode(cam3, OUTPUT);
}

void loop()
{
time = millis();
if(reset == false)
{
while(time<reset_time)
{
reset_all();
time = millis();
}
reset = true;
}

int val = readVal(IRsensor);// read in IR
//Serial.println(val);
//sweep_all();

int i = time % flash;
Serial.println(i);

if(isValid(val)) //if in proximity
{
freezeALL();

if((time % 5) == 0) //mod for the flshing so it won’t interfere with the arm
{
Serial.println(“flash mode”);
flsh_mode();
}
}
else //not in proximity
{
digitalWrite(cam1, HIGH); //default camera setup
digitalWrite(cam2, LOW);
digitalWrite(cam3, LOW);

sweep_all(); //do the sweep with the arm
}
}

///////////////RESET FUNCTIONS
void reset_all()
{
base_reset();
//delay(250);
shoulder_reset();
// delay(250);
elbow_reset();
//delay(250);
wrist_reset();
// delay(250);
turn_reset();
//delay(250);
grip_reset();

delay(pulse1);
Servo::refresh();
}

void base_reset()
{
base.write(base_center);
Servo::refresh();
}

void shoulder_reset()
{
shoulder.write(shoulder_center);
Servo::refresh();
}

void elbow_reset()
{
elbow.write(elbow_center);
Servo::refresh();
}

void wrist_reset()
{
wrist.write(wrist_center);
Servo::refresh();
}

void turn_reset()
{
turn.write(turn_center);
Servo::refresh();
}

void grip_reset()
{
grip.write(grip_open);
Servo::refresh();
}

//////////// SWEEP FUNCTIONS
void sweep_all()
{
base_sweep();
delay(pulse1);
Servo::refresh();

shoulder_sweep();
delay(pulse1);
Servo::refresh();

elbow_sweep();
delay(pulse1);
Servo::refresh();

wrist_sweep();
delay(pulse1);
Servo::refresh();

turn_sweep();
delay(pulse1);
Servo::refresh();
}

void base_sweep()
{
if(base_pos <= base_limit_low)
{
sweep_direction_base = 1; //go east
//delay(pulse2);
}
if(base_pos >= base_limit_high)
{
sweep_direction_base = -1; //go west
//delay(pulse2);
}
if(sweep_direction_base == 1) //east
{
base_pos = base_pos+increment;
base.write(base_pos);
}
if(sweep_direction_base == -1) //west
{
base_pos = base_pos-increment;
base.write(base_pos);
}
}

void shoulder_sweep()
{
if(shoulder_pos <= shoulder_limit_low)
{
sweep_direction_shoulder = 1; //go up
//delay(pulse2);
}
if(shoulder_pos >= shoulder_limit_high)
{
sweep_direction_shoulder = -1; //go down
//delay(pulse2);
}
if(sweep_direction_shoulder == 1) //up
{
shoulder_pos = shoulder_pos+increment;
shoulder.write(shoulder_pos);
}
if(sweep_direction_shoulder == -1) //down
{
shoulder_pos = shoulder_pos-increment;
shoulder.write(shoulder_pos);
}
}

void elbow_sweep()
{
if(elbow_pos <= elbow_limit_low)
{
sweep_direction_elbow = 1; //go up
//delay(pulse2);
}
if(elbow_pos >= elbow_limit_high)
{
sweep_direction_elbow = -1; //go down
//delay(pulse2);
}
if(sweep_direction_elbow == 1) //up
{
elbow_pos = elbow_pos+increment;
elbow.write(elbow_pos);
}
if(sweep_direction_elbow == -1) //down
{
elbow_pos = elbow_pos-increment;
elbow.write(elbow_pos);
}
}

void wrist_sweep()
{
if(wrist_pos <= wrist_limit_low)
{
sweep_direction_wrist = 1; //go up
//delay(pulse2);
}
if(wrist_pos >= wrist_limit_high)
{
sweep_direction_wrist = -1; //go down
//delay(pulse2);
}
if(sweep_direction_wrist == 1) //up
{
wrist_pos = wrist_pos+increment;
wrist.write(wrist_pos);
}
if(sweep_direction_wrist == -1) //down
{
wrist_pos = wrist_pos-increment;
wrist.write(wrist_pos);
}
}

void turn_sweep()
{
if(turn_pos <= turn_limit_low)
{
sweep_direction_turn = 1; //go up
//delay(pulse2);
}
if(turn_pos >= turn_limit_high)
{
sweep_direction_turn = -1; //go down
//delay(pulse2);
}
if(sweep_direction_turn == 1) //up
{
turn_pos = turn_pos+increment;
turn.write(turn_pos);
}
if(sweep_direction_turn == -1) //down
{
turn_pos = turn_pos-increment;
turn.write(turn_pos);
}
}

//freeze arm at the current position
void freezeALL()
{
shoulder.write(shoulder_pos);
//Servo::refresh();
elbow.write(elbow_pos);
//Servo::refresh();
wrist.write(wrist_pos);
//Servo::refresh();
turn.write(turn_pos);
//Servo::refresh();
base.write(base_pos);
delay(pulse1);
Servo::refresh();
}

/////////////////////////////////IR stuff
int readVal(int sensorNum) //mass sampling to blur out noise
{
int val = analogRead(sensorNum);
val+= analogRead(sensorNum);
val+= analogRead(sensorNum);
val+= analogRead(sensorNum);
val+= analogRead(sensorNum);
val = val/5;
return(val);
}

boolean isValid(int input) //check to see if something is in proximity
{
if(input>lowEnd)
{
Serial.println(“true”);
return true;
}
else
{
Serial.println(“false”);
return false;
}
}

////////////////////// camera control
void flsh_mode()
{
if(coin == false) //all off
{
digitalWrite(cam1, LOW);
digitalWrite(cam2, LOW);
digitalWrite(cam3, LOW);
coin = true; //flip
Serial.println(“flash mode 1″);
}
else //all on
{
digitalWrite(cam1, HIGH);
digitalWrite(cam2, HIGH);
digitalWrite(cam3, HIGH);
coin = false; //flip
Serial.println(“flash mode 2″);
}
}

Exercise 03 – iBlast

Coming Spring 2009!

The idea is  to broadcast a rather personal devise, an iPod, to the general public. The device literally creates a “social circle” of reception that requires the audience to be in proximity with the source.

I emptied out the cassette compartment for the Ipod, and embedded a radio transmitter kit inside.

Exercise 02 – R.L.D.M.D.

Real Life Dramatic Moment Device

Abstract: This device dramatizes the everyday life with your own choice of soundtrack!

Why: Why not? We deserve to live life in silver-screen quotations.

Use: Whenever and wherever appropriate and inappropriate.

Schematic:

Arduino code:

————————————————————————————–

int sensor = 0; //IR read-in pin :: analogue
int pinOut = 7; //relay-control pin  :: digital
int counter = 0;
int play_time = 1500;
int add_num_reading = 14;
int delay_rate = 300; //1/3 of a second :: 10/30 frames

int lowEnd = 280; //the low end of the proximity reading
int highEnd = 1100; //the high end of the proximity reading

void setup()
{
pinMode(pinOut, OUTPUT);
}

void loop()
{
int val = 0;

val = readVal(sensor);

//the following condition forces the target to be in porximity for a set amount of time
if(isValid(val))
{
counter++;
}
else
{
if(counter>0)
{
counter–;
}
}
delay(300); //wait 1/3 of a second :: 10/30 frames to initialize another sampling

if(counter>6) //make sure the object is in proximity for some duration; avoid passing objects
{
digitalWrite(pinOut, HIGH); //turn on iPod
delay(play_time); //leave the iPod on for the durration of play_time
if(!isValid(readVal(sensor)))
{
counter = 0; //reset counter
digitalWrite(pinOut, LOW);//turn off iPod
}
}
}

int readVal(int sensorNum) //mass sampling function
{
int readVal;
readVal = analogRead(sensorNum); //initial reading

for(int i=0;i<add_num_reading;i++) //addtional number of samplings
{
readVal += analogRead(sensorNum);
}

return (readVal/add_num_reading+1); //return the average of (the initial readi + additiona; readings) :: smooth out noise
}

boolean isValid(int input) //this function verifies whether of not an object is in proximity
{
if(input>lowEnd && input<highEnd)
{
return true;
}
else
{
return false;
}
}

Exercise 01 – Electric Magic Hat

Switch exercise

I hacked into a wireless light switch from As Seen on TV, and controlled it with Arduino

Construction:

Switch –> Arduino –> Relay –> Wireless Light Switch (parent)

Wireless Light Switch (child) –> Christmas Lights

Arduino code:

————————————————————————————–

int ledPin = 13; //relay-control pin
int inPin = 2; //read-in pin
int val = 0;

void setup()
{
pinMode(ledPin, OUTPUT);
pinMode(inPin, INPUT);
}

void loop()
{
val = digitalRead(inPin);  //read pin 7

delay(100);
if (val == 0)  //if pressed -> randomized flahing
{
digitalWrite(ledPin, HIGH);  //Light On
int TIME = random(50, 300);
delay(TIME);
digitalWrite(ledPin, LOW);  //Light Off
}
else
{
digitalWrite(ledPin, LOW);  //Light Off
}
}

elevator pitch template

The elevator pitch (short form – thanks to Eric Saund)

For <customer description>

who <customer’s defining need>,

<your product name>  is a <product category>

that <product differentiator>,

unlike <nearest competitive solution>,

(optional: which <competitor’s weakness>,)

<your product’s value proposition*>.

* A value proposition is a clear statement of the tangible results a customer gets from using your products or services.

3-D input device

I mentioned this 3-D capacitive input interface for Arduino (on Instructables.com) in class yesterday. It’s basically one corner of a cube with the 3 sides covered with aluminum foil, attached to the Arduino using shielded cable and a couple of resistors. It claims to report the distance of your hand from each of the three faces of the hemi-cube, so you can those as x, y, z coordinates to control… anything! One idea that springs to mind is setting the R/G/B values for your mood lighting. If it’s accurate enough, you could also try to hack it into your favorite cad program (you *are* already using VR goggles for that, right?)