lithium flowers bloom » Introduction to Physical Computing

Update on Physical Computing Final

L.J — Sun, 07 Dec 2008 07:05:19 +0000

I’ve been working with Liesje on the pcomp final and we had a lot of fun playing with magnets. Now it comes to a crucial question what are we gonna do to put some real pcomp into this project. Finally today we came to narrow down our ideas and focused on a still exciting solution! We still want to keep the organic look and feel of this piece and we’re adding a little bit servo-driven motion just to strengthen the interaction and exaggerate the motion of the magnets.

some 3 days ago pictures.

Proposal for Pcom Final

L.J — Wed, 12 Nov 2008 08:48:27 +0000

The biggest challenge for me so far is to narrow down the options and ideas. The semester is too short to explore everything that interests me, so that makes it even harder to decide on a “final” project.

Proposal 1: The Sphere

I’m taking the visualizing the five senses class this semester and am always curious about extending the senses by means of physical computing. I couldn’t be happier if I’m able to combine these two courses to visualize the sight data and give it a more visually appealing presentation. That’s how I came up with the idea of “the sphere” (sounds like it goes well with my midterm cube).

The sphere is a toy ball mainly with a camera wrapped inside of elastic and transparent material (I don’t know what’s that yet). It should be able to be thrown between people and to bounce against walls and floors. It could also serve as a general purpose remote control.

The core of the sphere is composed of following:

CMOS camera (which takes pictures!)
microcontroller (controlling everything and serving the data to xbee)
xbee module (talking wirelessly to another peer xbee connected to the computer)
battery (power supply for everything)
suspension system (maybe? foam?)
accelerometer and other potential sensors that are required to fulfill the visualization
wires … and stuff

The ideal size will be a little bigger than the tennis ball and smaller than a volleyball. It’s encouraged that people can play with the ball in pair or group. Due to the nature of the xbee communication and the fact that it does not have any external memory so it’s bounded to the computer, it’s not supposed to be a totally outdoor sport but I think apprently it’ll take much better pictures with the sunshines outdoor. Anyway the intention is to make the ball as durable as possible and involve as much people interaction as possible. So we’ll see.

The wrapping material should be:

soft
elastic?
transparent (or having a channel for the camera to take pictures)
using force/flex sensor to log enormous shape change

Basically I’m looking for something like rubber but transparent. Not sure if I can find one. If not I will also consider creating a woven structure by vines or bamboo. (pic.)

On the other side (the visualization):

another xbee module is reading the data in real time to a processing sketch, or whatever client application that logs the data to the file system;
ideally the data would be visualized in real time;
the images taken are arranged in a collage in a virtual 3d space according to the position and orientation while it’s taken.
data logged with different groups of people playing with the ball could be visualized separately and compared side by side
other 2D visualizations are open options.

Since the sphere is designed for general purpose use, the post process could also be extended to music composing, gaming or any other applications that require multidemensional inputs.

Proposal 2: Physical Interface for a 16×16 (or less) pixel matrix

I don’t have a very nice name for this piece yet. Basically I’m inspired by a project called Shade Pixel. It looks definitely inspired by Rozin’s wooden mirror though. Similar project called SnOil is accomplished with oil and electromagnets. I would like to look for a right fabric to build this surface. Instead of the solenoids I wish to try the electromagnets to pull down the fabric surface, I really don’t appreciate that cone look of the holes. (link to yet another similar project.)

On the input side, I wish to make a website that allows the visitors to create whatever pattern within that 16×16 matrix in black and white. Whenever there is an update on the website, the physical interface morphs to the new pattern and so on. The inspiration is from one of my favorite simple site tiny.

The biggest challenge is, pretty much the same as previous one, to find out a right material, in this case, for the surface. This point is to break the boundary of the online space and make a change happened in the cyberspace directly impacts the real world. Of course if someone wishes to make it a one way instant message system I’m still more than happy to see that.

Everyone with crazy ideas of the keyless entry must be living in a dorm!

L.J — Fri, 07 Nov 2008 20:51:15 +0000

I ran into this post today and apparently it’s a similar but much savvier implementation of my unlocking system.
Really like the touch sensor use!

What’s really sad is I was locked again outside my bedroom two weeks ago at midnight. I cannot always stick my arduino to the door.

Nice work Alex!

Check out the video below:

UPDATED: Pcom lab catch up and GO OUT

L.J — Wed, 29 Oct 2008 15:59:59 +0000

The transister lab looks fun because I like these DC motors since young. They have a unique smell while spinning really fast. In my impression they could work very well with just 2 AA battery (3V) in a toy car, so I’m curious about how would it be with 9 or 12V.

First I hooked up the circuit according to the website walkthrough, using the 9V output from the arduino. Surprisedly it didn’t work, even in the simplified program without the potentiameter. I checked the circuit for a couple of times and tried to hook the motor directly to the batteries, 5V from the arduino and 12V from the wall through the adapter, all approaches worked.

It came to me a sad conclusion that the 9V output on my arduino is broken. So I tested the circuit with the 9V from my another arduino and it worked. Is it that the arduino cannot output 5V and 9V at the same time? I haven’t tested this hypothesis yet.

some photos and videos (the motor was spinning so hard that I had to tape it to the board):

I’l catch up with the H-bridge lab next week.

—— a happy going-out seperator ——

I was having a group meeting on a short film for commlab and someone just mentioned Michel Gondry while Marco turned around from the table beside and told us that Michel Gondry was going to give a talk right that evening at Strand. I hesitated for a while since I have another project due the next morning, but it was not long. We were really lucky that Marco got us there one hour earlier before the talk started at 7. Huge crowd started to gather since 6:30 and by then we were already sitting within 10 meters from the stage. I did take some photos but the memory card of my phone seems half broken and seriously it does not make much sense to take photo of people in a talk.

The talk started by showing some of Michel’s recent work, then a short interview between him and his PR guy, and another short video, and another short interview and so on. The screening including some excerpts from his latest film “be kind rewind” but my favorite is the music video he did for “Mad World” by Gary Jules and Michael Andrews. Not only Donnie Darko is one of my favorite and I love the song SOOOO MUUUCHHH but this music video is so moving and so well made in one long take. It’s like a combination of all my loved things. Check out the video below:

Michel also talked about the “protocal” of filmmaking and sharing within the community. It’s more discussed in his new book that I haven’t read yet so I’m not sure I totally understand that. He actually accused his PR guy for charging too high on the book (?). And once while Michel is still talking the guy started to check the time, Michel suddenly stopped and turned to him and said “Don’t look at your watch while I’m still talking. It’s VERY rude.” It became a little bit awkward in the atmosphere for a while. But I like it.

CUBE was not built/burnt in a day

L.J — Wed, 22 Oct 2008 16:12:27 +0000

ACT 0: BRAINSTORMING THE CUBE

ACT 1: ARDUINO ONLY SOUND ANALYSIS

pcom midterm: microphone + arduino beat detection from Leejay Xia on Vimeo.

pcom midterm: mircophone + arduinobeat detection log from Leejay Xia on Vimeo.

ACT 2: THE MACHANICS

pcom midterm: the skeleton from Leejay Xia on Vimeo.

ACT 3: IT WORKED!!!

pcom midterm: rhythm awareness dance pattern from Leejay Xia on Vimeo.

on two arduinos:

ACT 4: …UNTIL WE BURNT OUT THE CORE SERVO

The only motion left was the up-down. But it still works!

pcom midterm: dance! from Leejay Xia on Vimeo.

ACT 5: NOT THE WORST DANCE IN THE WORLD

pcom midterm: dance! from Leejay Xia on Vimeo.

PCom Update: multiple serial input

L.J — Wed, 15 Oct 2008 06:11:52 +0000

I’ve been mostly working on viz class and pcom mid term over the weekend. One big thing is I once made the eight-buck-deal RF Link work in the studio, but never succeeded in testing again since I went back to the dorm. I used software serial library to utilize digital pins as serial input/output and leave the original serial port for computer monitoring, but the RL Links still feel like a black box to me. The transmitter side looks working perfectly while I hooked up a USB cable and tried to read the TX stream, however the receiver side keeps getting rubbish data. More efforts are to be invested on this issue!!

Just a quick update on the multi-serial-input, shown as the video below (yes I still love my force sensors):

It’s pretty simple, just using two serial inputs. But the concept of encoding data and protocol is pretty clear.

Arduino Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

int leftPin = 4;
int rightPin = 5;
int leftValue,rightValue;

void setup()
{
beginSerial(9600); //set up communication back to pc
}

void loop()
{
leftValue = analogRead(leftPin);
rightValue = analogRead(rightPin);

//if (abs(leftValue - rightValue) > 50)
//{
Serial.print(leftValue,DEC);
Serial.print(44,BYTE);
Serial.print(rightValue,DEC);
Serial.print(44,BYTE);
Serial.println();
//}
}

Processing Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

import processing.serial.*;

Serial myPort;
String data;
int leftValue = 0;
int rightValue = 0;

void setup()
{
size(800, 600, P3D);
directionalLight(126, 126, 126, 0, 0, -1);
ambientLight(102, 102, 102);
noStroke();
myPort = new Serial(this, Serial.list()[0], 9600);
ellipseMode(CENTER);
}

void draw()
{
background(0);
float leftR = map(leftValue,0,1023,0,PI/2);
float rightR = map(rightValue,0,1023,0,PI/2);

translate(width/2, height/2);

rotateX(-PI/12);
rotateZ(rightR - leftR);
stroke(160,10);
fill(150,150,150,90);
box(500,10,100);
translate(0,10);

noStroke();
fill(255,0,0);
translate(map(rightValue - leftValue,-1023,1023,-250,250),-25);
sphere(10);
}

void serialEvent(Serial p) {
String input = p.readStringUntil(10); //make sure you return (Ascii 13) at the end of your transmission
if (input != null)
{
String[] parts = input.split(","); //this will only work if you put commas (Ascii 44) between things in your transmission

if (parts.length >= 2)
{
//println("Raw Input: " + input);
if (abs(int(parts[0]) - leftValue) > 10)
{
leftValue = int(parts[0]);
}
if (abs(int(parts[1]) - rightValue) > 10)
{
rightValue = int(parts[1]);
}
}
}
}

PCom: Serial Input in Processing

L.J — Wed, 08 Oct 2008 15:42:33 +0000

I do enjoy the force sensor I got in week 5′s application class so I’ll definitely use it more in the assignment!

First I revisited the processing codes I wrote for week 2, which now seems to be a total mess. I didn’t know about the serialEvent callback then so I parsed the serial input in the draw loop, and I didn’t use BYTE output in the arduino board so I need to parse it as string. It worked pretty well but the revised the version is much better.

Codes:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

import processing.serial.*;

Serial myPort;
int window = 800;
int[] values = new int[window - 100];
int index = 0;
int input = 0;

void setup()
{
size(window,window);
background(0,30);
smooth();
// List all the available serial ports:
//println(Serial.list());
myPort = new Serial(this, Serial.list()[0], 9600);

for (int i = 0;i<window - 100;i++)
{
values[i] = 0;
}
}

void draw()
{
background(0,20);
for (int i = 0; i < window - 100;i++)
{
int j = i + index;
if (j >= (window - 100))
{
j = j - (window - 100);
}

stroke(255,0,0,80);
line(50 + i, (window - 50), 50 + i, (window - 50) - (values[j] * (window - 100) / 1024));
stroke(255,0,0,100);
point(50 + i, (window - 50));
point(50 + i, (window - 50) - (values[j] * (window - 100) / 1024));
}
}

void serialEvent(Serial p) {
input = p.read();
println("input:" + input);
values[index] = input * 4;
index++;
if (index >= window - 100)
{
index = index - (window - 100);
}
}

Then I thought about the nature of the force sensor and really wished I could visualize the “force” in the processing. So I adopted the “string” example bundled in the processing application and integrated it with the serial input.

Codes:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

import processing.serial.*;
// The serial port:
Serial myPort;
int input = 0;
int lastInput = -1;

// Spring drawing constants for top bar
int s_height = 16; // Height
int left = 150; // Left position
int right = 250; // Right position
int max = 300; // Maximum Y value
int min = 20; // Minimum Y value
boolean over = true; // If mouse over
boolean move = false; // If mouse down and over

// Spring simulation constants
float M = 0.8; // Mass
float K = 0.2; // Spring constant
float D = 0.92; // Damping
float R = 60; // Rest position

// Spring simulation variables
float ps = 60.0; // Position
float vs = 0.0; // Velocity
float as = 0; // Acceleration
float f = 0; // Force

void setup()
{
size(400, 400);
rectMode(CORNERS);
noStroke();
myPort = new Serial(this, Serial.list()[0], 9600);
}

void draw()
{
background(102);
updateSpring();
drawSpring();
}

void drawSpring()
{
// Draw base
fill(0.2);
float b_width = 0.5 * ps + -8;
rect(width/2 - b_width, ps + s_height, width/2 + b_width, 350);
}

void updateSpring()
{
// Update the spring position
if(!move) {
f = -K * (ps - R); // f=-ky
as = f / M; // Set the acceleration, f=ma == a=f/m
vs = D * (vs + as); // Set the velocity
ps = ps + vs; // Updated position
}
if(abs(vs) < 0.1) {
vs = 0.0;
}

// Test if mouse is over the top bar
/*
if(mouseX > left && mouseX < right && mouseY > ps && mouseY < ps + s_height) {
over = true;
} else {
over = false;
}
*/

// Set and constrain the position of top bar
if(move) {
ps = map(input,0,255,min,max) - s_height/2;
if (ps < min) { ps = min; }
if (ps > max) { ps = max; }
}
}

void serialEvent(Serial p) {
input = p.read();
println("input:" + input);

if (input > lastInput)
{
move = true;
}
else if (lastInput > input + 10 || input < 10)
{
move = false;
}

lastInput = input;
}

Solution for Lockouts

L.J — Wed, 01 Oct 2008 07:18:57 +0000

Lockouts are irritating. especially when you live in a dorm, at midnight, your roommate is sleeping, and backup keys are two hours away.

Here’s the self-service solution.

I should have made a much more complex combination lock with multiple sensors and flexible customization functionalities, but it’s two in the morning… so maybe next time…

Secret revealed.

It’s kind of low tech in the backstage. All we need are: arduino, plus a servomotor, and, gravity. 8 quarter coins are used as weight. So it’s basically a two dollar solution! (what? the arduino? breadboard servomotor and all the lab kits? well…)

More pictures:

bonus video – playing servomotor with force sensor (warning: not fun to watch at all)

Thanks Li for the force sensor! We”ll have to talk!

Supposed-to-be-easy Electricity Lab

L.J — Wed, 24 Sep 2008 04:23:43 +0000

Spent still over two hours though., most of the time tweaking with the multimeter.

THE REGULATOR

Output: 4.97V
Input:16.47V
Voltage over LED: 2.088V
– over resister: 2.70V

LED IN SERIES

I don’t really have much to say about that…

LED A:2.52V
LED B:2.48V

Seems perfect? Not able to light up 3 LEDs in series though.

LED IN PARALLEL

Voltage over resistor: 2.86V
– over LED: 2.06V

Amperage calculated: 2.06V / 220 Om = 0.013A
Amperage read from meter: 0.013 – 0.014A

VARIANT VOLTAGE WITH A POTENTIOMETER

Voltage over LED while it’s:
– brightest: 3.00V
– medium: 2.60V
– dim: 2.43V
– off: 2.15V

This well explains why 3 LEDs in series didn’t work.

Special thanks to Neo for the power adaptor!

Physical Computing Week 2: Analog!

L.J — Wed, 17 Sep 2008 15:11:07 +0000

Hooking up the following stuff according to the diagram was easy and quick. And a resister of ~~220~~ 10K Om is working ideally to create an ouput range of 0 – 930 (from total darkness to direct shine of torchlight) for the photocell.

I changed the switch from last week to a much smaller one which could be inserted right into the breadboard, to get rid of the mess of the hookup wires. The output was quite straightforward in the arduino console window, so I decided to connect the output to the processing.

This is how it works:

Physical Computing Week 2 from Leejay Xia on Vimeo.

(Quick and Dirty) Code for Processing, it’s based on the example on their site

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

import processing.serial.*;

// The serial port:
Serial myPort;
int window = 400;
int[] values = new int[window - 100];
int index = 0;

void setup()
{
size(window,window);
background(0);
smooth();
// List all the available serial ports:
println(Serial.list());
myPort = new Serial(this, Serial.list()[0], 9600);
for (int i = 0;i<window - 100;i++)
{
values[i] = 0;
}
}

void draw()
{
if (myPort.available() > 0)
{
String inBuffer = myPort.readString();
String[] vals = splitTokens(inBuffer);

for (int i = 0;i<vals.length;i++)
{
values[index] = int(vals[i]);
//println(index+":"+values[index]+"/"+vals[i]);
index++;
if (index >= window - 100)
{
index = index - (window - 100);
}
}
background(0);
for (int i = 0; i < window - 100;i++)
{
int j = i + index;
if (j >= (window - 100))
{
j = j - (window - 100);
}
stroke(255,0,0,90);
line(50 + i, (window - 50), 50 + i, (window - 50) - (values[j] * (window - 100) / 1024));
stroke(255,0,0,100);
point(50 + i, (window - 50));
point(50 + i, (window - 50) - (values[j] * (window - 100) / 1024));
}
}
}

Notes-taking:

I tried also the Thermistors but have not yet find a right resister to tune its output range.
In the current codes, the arduino board must be plugged before the processing applet runs.
This is because the processing init code cannot find a usable serial port to initialize the object. And so far I didn’t see a possible way to initialize it during the draw() loop due to the lack of a try/catch machanism. More exploration to go!
The serial port transmits data much faster than the draw() function loops. Thus everytime we arrive in the draw() loop there might be a bunch of values waited in the buffer. These values need to be splited and stored accordingly. Of course a more complex protocal could be created to sample specific data or behavior.

More Photos: