« November 2009 | Main | December 2010 »

December 23, 2009

Slit Scan Box model

Art Box.jpg

This is the model of my slit scan box. Inside I had installed an i-cam to capture the footage as the people moved a wooden block with a cloth pattern on the bottom, over the surface of the clear plexiglas surface. An LED light was also installed inside in order to make the image of the pattern clear within the enclosed space of the plexiglas surface.

-Mike Ballard
fabric1.jpg

fabric1.jpg
Thumbnail image for fabric3.jpg
fabric2.jpg

Presentation Model

Art Presentation.jpg


This is the layout I had used when presenting my final project. The funny looking rectangle patterns in the backround are the projections of the the images that appear when you interact with the boxes.

December 22, 2009

Independent Project: Mother Me?


One-on-One Sketch-crop8xAdjs.jpg

Sketch reflects initial design for belt

This project is a prototype interactive wearable belt. It has been designed with two focuses in mind. On the one hand, it "heralds" a future in which cloning and "petri-dish pregnancies" are a norm. A woman may choose to carry her fetus to full-term in a wearable incubator (re-sized to match the growth of the fetus). In this senario, the woman's partner may also share in the carriyng-to-full-term.

The second focus relates to women's experiences of strangers giving themselves permission to touch their pregnant stomach. It has two modes of operation: non-touch and touch. In non-touch mode, a red "warning" lights flashes in the capsule with a modeled fetus to discourage touching. In touch mode, a series of interactions are possible. The cast rubber part has two touch zones. Touching the container with the fetus embryo model, triggers a white LED in the fetus to pulse. Depending how the cast rubber part of the piece is touched, different sequences of blue LEDs blink or pulse.

Neutral6xS.jpg

Wearable not activated.

Alarm6xB+SS.jpg

Wearable in Don't-Touch mode

Play6x.jpg

Wearable in Touch mode


The following code reflects the second focus operations. Note: Commented out is code for using a Rogue Robotics sound shield to play sound clips together with the LED lights. The interface is not working at this time.

One_on_One_AllZonesNoSound.pde


Other Related Projects - Alec Rippberger

heart.jpg

This piece of artwork blinks as if it were alive and beating! The closer you approach the faster the heart "beats". I used several LEDs attached to 1k resistors embedded in the semi transparent sculpture of a "heart". These LEDs ran into the digital pins of the arduino and were controlled by the following code:

/* Ping))) Sensor

This sketch reads a PING))) ultrasonic rangefinder and returns the
distance to the closest object in range. To do this, it sends a pulse
to the sensor to initiate a reading, then listens for a pulse
to return. The length of the returning pulse is proportional to
the distance of the object from the sensor.

The circuit:
* +V connection of the PING))) attached to +5V
* GND connection of the PING))) attached to ground
* SIG connection of the PING))) attached to digital pin 7
http://www.arduino.cc/en/Tutorial/Ping

created 3 Nov 2008
by David A. Mellis
modified 30 Jun 2009
by Tom Igoe
*/
// this constant won't change. It's the pin number
// of the sensor's output:
const int pingPin = 7;
//variables for digital pins one through five used as LEDs
int pinSix = 6;
int pinTwo = 2;
int pinThree = 3;
int pinFour = 4;
int pinFive = 5;


void setup() {
// initialize serial communication
Serial.begin(9600);
// set pinmode for LEDs
pinMode(pinSix, OUTPUT);
pinMode(pinTwo, OUTPUT);
pinMode(pinThree, OUTPUT);
pinMode(pinFour, OUTPUT);
pinMode(pinFive, OUTPUT);

}
void loop()
{
int beat = 1000;
int unbeat = 2000;
int rest = 3000;
// establish variables for duration of the ping,
// and the distance result in inches and centimeters:
long duration, inches, cm;
// The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
// Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
pinMode(pingPin, OUTPUT);
digitalWrite(pingPin, LOW);
delayMicroseconds(2);
digitalWrite(pingPin, HIGH);
delayMicroseconds(5);
digitalWrite(pingPin, LOW);
// The same pin is used to read the signal from the PING))): a HIGH
// pulse whose duration is the time (in microseconds) from the sending
// of the ping to the reception of its echo off of an object.
pinMode(pingPin, INPUT);
duration = pulseIn(pingPin, HIGH);
// convert the time into a distance
inches = microsecondsToInches(duration);
cm = microsecondsToCentimeters(duration);
Serial.print(inches);
Serial.print("in, ");
Serial.print(cm);
Serial.print("cm");
Serial.println();

beat = inches * 6;
unbeat = inches * 5.5;
rest = inches * 18;

digitalWrite(pinSix, HIGH);
digitalWrite(pinTwo, HIGH);
digitalWrite(pinThree, HIGH);
digitalWrite(pinFour, HIGH);
digitalWrite(pinFive, HIGH);
delay(beat);
digitalWrite(pinSix, LOW);
digitalWrite(pinTwo, LOW);
digitalWrite(pinThree, LOW);
digitalWrite(pinFour, LOW);
digitalWrite(pinFive, LOW);
delay(beat);
digitalWrite(pinSix, HIGH);
digitalWrite(pinTwo, HIGH);
digitalWrite(pinThree, HIGH);
digitalWrite(pinFour, HIGH);
digitalWrite(pinFive, HIGH);
delay(unbeat);
digitalWrite(pinSix, LOW);
digitalWrite(pinTwo, LOW);
digitalWrite(pinThree, LOW);
digitalWrite(pinFour, LOW);
digitalWrite(pinFive, LOW);
delay(rest);
}


long microsecondsToInches(long microseconds)
{
// According to Parallax's datasheet for the PING))), there are
// 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
// second). This gives the distance travelled by the ping, outbound
// and return, so we divide by 2 to get the distance of the obstacle.
// See: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
return microseconds / 74 / 2;
}
long microsecondsToCentimeters(long microseconds)
{
// The speed of sound is 340 m/s or 29 microseconds per centimeter.
// The ping travels out and back, so to find the distance of the
// object we take half of the distance travelled.
return microseconds / 29 / 2;
}

Over the course of the semester I have worked on several projects that relate to the themes of this course. One project was the creation of a friends website. The project is made 100% percent from scratch, using images and design created and manipulated by me using the Adobe CS4 Suite. The website has several interactive components:
  • The popup windows when hovering the mouse over links
  • The custom made flash music player

I feel that the creation of this site has helped me better understand some of the concepts covered in Making Art Interactive while also expanding my definition of creative interactivity.

Another project that I have undertaken recently is the creation of a flash photo slideshow for my girlfriend' blog. I used Abode Flash CS4 and ActionScript to create a custom slideshow that fits in with the theme of the blog. AdrianesTravels.swf

Final Project - Alec Rippberger


View image
This is the completed physical tree, allowing you to interact with the virtual tree through agitation.
View image
This is the switch that converts physical interaction into the digital realm. The center ball of aluminum foil is attached to a wire that is connected to digital pin 4 of the arduino. The coil of aluminum surrounding the ball is attached to a wire connected to arduino's ground. When the tree is agitated the ball makes contact with the coil completing a circuit and sending digital information to the arduino.

This digital information is then sent to a MacBook Pro computer using the firmata software uploaded to the arduino board. When the data reaches the computer it is converted by another program,serproxy, so that it can be interpreted by Adobe Flash. Flash then interprets the data using a library class known as AS3 Glue.

The flash actionscript code I used:

stop();
import flash.utils.*;
import net.eriksjodin.arduino.Arduino;
import net.eriksjodin.arduino.events.ArduinoEvent;
import net.eriksjodin.arduino.events.ArduinoSysExEvent;
import flash.utils.ByteArray;
import flash.events.Event;
var a:Arduino;
var numEvents:Number=0;
var leaf:uint=0;
var frame:uint=1;
var myTimer:Timer=new Timer(200);
myTimer.addEventListener("timer", checkLeaves);
myTimer.start();

// connect to a serial proxy on port 5331
a=new Arduino("127.0.0.1",5331);

// listen for connection
a.addEventListener(Event.CONNECT,onSocketConnect);
a.addEventListener(Event.CLOSE,onSocketClose);

// listen for firmware (sent on startup)
a.addEventListener(ArduinoEvent.FIRMWARE_VERSION, onReceiveFirmwareVersion);

// listen for data
a.addEventListener(ArduinoEvent.ANALOG_DATA, onReceiveAnalogData);
a.addEventListener(ArduinoEvent.DIGITAL_DATA, onReceiveDigitalData);

//listen for sysex messages
a.addEventListener(ArduinoSysExEvent.SYSEX_MESSAGE, onReceiveSysExMessage);

// triggered when a serial socket connection has been established
function onSocketConnect(e:Object):void {
trace("Socket connected!");
// request the firmware version
a.requestFirmwareVersion();

}

// triggered when a serial socket connection has been closed
function onSocketClose(e:Object):void {
trace("Socket closed!");
}

// trace out data when it arrives...
function onReceiveAnalogData(e:ArduinoEvent):void {
trace((numEvents++) +" Analog pin " + e.pin + " on port: " + e.port +" = " + e.value);
}

// trace out data when it arrives...
function onReceiveDigitalData(e:ArduinoEvent):void {
trace((numEvents++) +" Digital pin " + e.pin + " on port: " + e.port +" = " + e.value);
leaf=leaf+1;
}

// trace incoming sysex messages
function onReceiveSysExMessage(e:ArduinoSysExEvent) {
trace((numEvents++) +"Received SysExMessage. Command:"+e.data[0]);
}


// the firmware version is requested when the Arduino class has made a socket connection.
// when we receive this event we know that the Arduino has been successfully connected.
function onReceiveFirmwareVersion(e:ArduinoEvent):void {
trace("Firmware version: " + e.value);
if (int(e.value)!=2) {
trace("Unexpected Firmware version encountered! This Version of as3glue was written for Firmata2.");
}
// the port value of an event can be used to determine which board the event was dispatched from
// this is one way of dealing with multiple boards, another is to add different listener methods
trace("Port: " + e.port);

// do some stuff on the Arduino...
initArduino();
}

function initArduino():void {
trace("Initializing Arduino");

// set a pin to output
a.setPinMode(13, Arduino.OUTPUT);

// set a pin to high
a.writeDigitalPin(13, Arduino.HIGH);

// turn on pull up on pin 4
a.writeDigitalPin(4, Arduino.HIGH);

// set digital pin 4 to input
a.setPinMode(4, Arduino.INPUT);

// enable reporting for digital pins
a.enableDigitalPinReporting();

// disable reporting for digital pins
//a.disableDigitalPinReporting();

// enable reporting for an analog pin
a.setAnalogPinReporting(3, Arduino.ON);

// disable reporting for an analog pin
//a.setAnalogPinReporting(3, Arduino.OFF);

// set a pin to PWM
a.setPinMode(11, Arduino.PWM);

// write to PWM (0..255)
a.writeAnalogPin(11, 255);

// trace out the most recently received data
//trace("Analog pin 3 is: " + a.getAnalogData(3));
//trace("Digital pin 4 is: " + a.getDigitalData(4));

}

function checkLeaves(eventArgs:TimerEvent):void {
if (leaf>=10) {
nextFrame();
trace("increase");
if (leaf>1000) {
leaf=leaf-100;}
if (leaf>100) {
leaf=leaf-10;}
if (leaf>10) {leaf=leaf-1;}
leaf=leaf-1;

} else {prevFrame();
trace("decrease");
if (leaf>1000) {
leaf=leaf-100;}
if (leaf>100) {
leaf=leaf-10;}
if (leaf>10) {leaf=leaf-1;}
}

}


This code is a modified version of the "simpleIO.fla" example included in the AS3 Glue Class Package. I modified it in several ways:

  1. added "stop();" to the first line of code in order to stop any flash movieclips from running without input from the arduino.

  2. Imported the timer class so that I could use the timer functions

  3. Created a timer that would run a specific function every 2000 milliseconds

  4. Added and defined the variables "leaf" and "frame" to track the input received from the arduino. I later decided not to use the variable "frame" for its original purposes.

  5. Modified the "onRecieveDigitalData" to add 1 to the variable leaf

  6. created the "checkLeaves" function in which the amount of digital input is checked. If the leaf function is higher than a certain threshold the function advances the timeline to the next frame and reduces the amount of the variable "leaf". If the threshold has not been met and the frame is more than 1, the function will advance the timeline to the previous frame and reduce the amount of the variable "leaf".



This diagram shows how the information travels from the physical tree to the digital tree.
MAIWEB.jpg

Interactive Wall

This project uses capacitive sensors to communicate with Processing via the Arduino. I am currently in the process of re-writing the code to work out bugs and such. The wall will be on display in the Rapson Hall courtyard over break and during the first week of the Sping 2010 semester.

Justin Berken

My Slit Scan Project (Final)











When Diane showed me the slit scan program in processing, I almost immediately knew what I was going to do. Taking a little bit of my inspiration Maurice Benayouns identity stealing worms, I wanted to create a structure that could take the interaction of the subject and project it for them to see and change in real time.

I think my idea for making the boxes as the source for one to interact with was that the box as an object is something simple and universally recognized as being something a person is not really afraid to interact with. The construction of the boxes was key to realizing my project and it became quite frustrating in the end when I found my self being held up by their construction. I eventually decided that I would have to build them myself, something I knew I was not proficient in doing, but must be done in order to get there. I had a solid plan that I was sure would work, but with out the boxes complete, I had no way to test it and make sure.

The plan itself was to have three boxes which had openings at the top where individuals could put and move around blocks with fabric patterns on the bottom side. Camera's inside the box would capture the footage and run it through the slit scan program which would take these patterns and their movements and elongate them through time. These images would be projected on the wall for the individuals to see and react with. Lights would also have to be placed inside the box pointing up at the patterns in order for the fabric to be seen by the camera.

A complication arose when I realized I would have to use 3 separate computers to run the slit scan because I did not want them to be part of the presentation. The solution came when I found a white display box that I could stash the computers in as well as set my main display up on top of the box. The boxes themselves were obviously not constructed with the most talented of hands so I used lighting to hide or distract from their defects. As it turned out, once the boxes were completed and I had found a way to install the lights and cameras, the plan had worked out pretty much exactly the way I had envisioned, which doesn't usually happen. I think this had to do a lot with the experience I had in the previous group project, where I learned a sort of method of work which was to start out simple and keep building on that concept. In the end I believe I had a successful project.

The main concept of the presentation from the start was to evolve around the idea of identity, time, and choice. The people interacting with the project have many patterns (identities) to choose from and each one they will effect in their own way. They make their decision and they use the boxes to form (recycle) that pattern the way they wish. As they do, their patterns are mixing with the patterns of those around them and each pattern is connected to one another. These patterns are all effected and tied together by the passage of time.

Most of my other documentation for this project has been lost to the trash can (sketches, blueprints, etc.

Midi Controller

My final project was my first attempt at creating something useful and perhaps artistic on its own accord. The process of construction was a difficult one because as I worked I attempted to give everything a semi-professional appearance. Earlier I had conceptualized a sort of wheel midi controller, however I decided to start somewhere that I knew I could complete given my understanding of arduino and its respective software. I have learned a lot about "depunking" the arduino through the course of this project. The excitement of compiling a program without an array of confusing error messages is incomparable to any enjoyment in life. There are a lot of little tips and tricks that should be published in a special "depunking" the arduino website.

Now I am comfortable enough with arduino that I can make the arduino bend to my will, and due to its processing origins I believe that some processing work might be in order for me as well. This whole project probably learned me a lot.

Back to Midi controller

I first experimented with methods of scaling potentiometer inputs however they follow an interesting curve of scaled values, and every pot. seemed a little bit different. Also when I was experimenting I found that the values seemed to fluctuate considerably, then I developed a method of recognizing a (deliberate) change in values but this too would have to be scaled, Interesting note I put this code aside when I built the 16 pot array and when I used digital outputs power the pots The fluctuations declined considerably. This is when I'm not sure whethe to be happy that it works better or to call the arduino a punk for wasting my time earlier.

Midi interfacing
Midi interfacing is extremely easy - download the midi library from arduino website, There is a midi arduino, but for just a simple midi output, its not completely neccessary.
I like midi communication because this is not limited to computers like the serial communication is. Also it seems more practical in the creation of music whether it be ambient installation, or more directed music.

Look at the diagram and know that what I'm telling you is true:
http://www.tigoe.net/pcomp/code/serial-communication/midi
midi-out-simple-ckt.jpg

The Controller itself was very interesting, I had coded and developed a Led digit display that was going to display the note for each pot. However I didn't get the chance to combine the codes in some holy matrimony? Also the device was clearly reacting to input, but it seemed to provided its own interpretation of this input.

The result: some weird sounds.Image025.jpg
Image023.jpg
Image024.jpg
Image022.jpg
pictures of the device^^^


bass.pde
code of the pot block
annie_log.pde
this one is code for my various experiments with pots and led display


the file below is an audio file of me using the block to make drums and a synth sound recording on reason.
pot block.mp3

My arduino guide

My arduino guide
(or how I learned to stop worrying and love the atomic bomb(arduino))
As you all may know the arduino is a punk and punks cannot be tolerated in the new media realm so here are some tips to depunk your sh-t:

1.Do not use digital ports 1 or 2 (unless you have to) because they can screw up your serial connection. They are the arduino serial communication ports by default. (good for midi)

2. I feel stupid when i do this and so that you too don't have to feel that feeling remember "=" will store a value, or change a variable. "==" is used for comparing values

3.When you add a library to your library I found that it wont work (punk) unless it is in a folder by the same name. If the folder does not exist, I guess you have to make it. I believe that this, in conjunction with arduino being a punk, accounts for 89% of "include" errors.

4.Those punk digital outputs leak. If digital write is == LOW it grounds. use diodes to stop the leaks.

5.

remember the semicolon ";"all hail the holy semicolon.
and "these" {}{}{{{{{}}}}}} check your "these"

6. although the arduino operates on 5v the digital output on these babies is 3.3 not strong enough to flip a 6v relay, like a good boy. However juice it up using 3 digital outputs more amps and then your relays are gonna go WEEEEEEEEEEEEE

7. I learned a lot about soldering and there are some keys, use the wet sponge to get the iron "sticky", pick up a blob and get it nice and shiny. Then do not use wire that's hard to bend, the bendier the easier it is to solder, and the better chance it will work correctly. Remember the heat shrink tubing

8. int (yourvariablehere) = blahblahblah
this value is weak and cannot be negative and cannot hold decimals like a punk.
I wasted a lot of time staring at the program questioning why the world hated me. Then i began to float

:float (yourvariables) and you don't have to go crazy and float everything but when your stuck.

9. Remember that arduino is a punk and punks need love sometimes too.

Translucence and Shadows

For my independent project, I wanted to use the qualities of light and shadow and explore the properties of some translucent, Duralar material. A servo sweep operates and animates a scene composed of film strips and a plastic model tree. Multiple light sources create layers of shadows, with one layer splitting off into three and then reverting.

In this revised version of the project, a plain full screen was used, which was constructed out of a large sheet of Duralar, 3 dowel rods and some leftover presentation board pieces for support and to create a frame.

P1012224.JPG

P1012228.JPG

P1012225.JPG

Haegue Yang (elisa)

Haegue Yang creates abstractions of stories so that they can be experienced more universally - the emotional experiences that we all share.

I experienced the power of Haegue's installation "Yearning Melancholy Red" made of simple objects producing simple experiences of heat, air, movement, light and shapes.

During the lecture, I was hit by the simplicity and delightfulness of the origami shapes and lights installed in the space where the curator first met her. I like to think of art as play in space, and I must not forget that.

She sees her installations as a democratic field of senses - a field of different sensory experiences, not distributed to produce one conclusion, but in every possible direction. The entire space is mapped like a body of work.

She found her interesting material - blinds create unexpected effects, even though they play a persistent role in our lives. These sensations are mundane and basic. You can associate warmth with either pain or pleasure. You can choose your own associations.

Maybe not ever telling any story can get a little bit boring. Can we add more complexity to perception, more depth to increase our longing. An increase of meaning found in an increate of form. I think Olafur Eliasson is at times more successful at this. I have dismissed him as being too into spectacle, but I think some of his work does an amazing job of using interactivity to explore the way we perceive, interact with, and construct the world.

What exactly does Marguerite Duras have to do with the installation?

Analogue Image Project

In the other project that I experimented with, two wheels were set up parallel to one another. One had photographs with holes in their centers. The other was a mini-installation of found material with light coming from behind. A video camera captured only the size of the photographs and projected the constructed worlds onto the wall. Does this make sense??

wheel2.jpg

wheel.jpg


Robin Schwartzman-Final Project

The Lonely Tree is an interactive installation that invites people to kick off their shoes and step off of the concrete to enjoy a picnic lunch under the shade of an apple tree. Once one enters into this world, there are many surprises in store. Please watch the following video for complete documentation.








This piece was made using three Arduinos- two WaveShields and one Motor Shield. To make the flowers and clovers talk, I set up a system of circuits to be connected. When the bottom of each stem (which has a grounded piece of metal on it) makes contact with the underside of it's bush or dirt cluster (connected to separate analog pins), it connects the circuit, thus triggering the sound. The following is the coding I used to make the flowers and clovers talk: flowersigotit.cpp
And here is the code I used to make the tree talk when one steps onto the blanket: treesounds.cpp The blanket works in the same manner as the flowers and clovers-the underside of the blanket is connected to an analog input pin. Then there is a layer of foam squares separating the positive from grounded metal underneath. When one steps on the foam, it connects the positive and negative, thus connecting the circuit and making the tree talk.
Lastly, the following is the code I used to activate the Motorshield. I wired a Ping ultrasonic sensor up to the motorshield so that the eyes would blink at different rates according to a range of motions based off of sound. blinkyeyes.cpp

I consider the piece in its current state a working prototype for a bigger, better, more durable version to come in the near future. Keep your eyes peeled!

Interactive Tree

I was happy to finally get all the components I needed to make a video interactive. I used a sensor and a bit whacker and connected them to a max patch that took input from the sensor and could convert it to numbers that then changed the opacity of the video (I had two videos layered on top of one another). It could also do things like change the exposure or speed of the video. Pretty cool. Andy Mattern showed me how to use the patch. It looks like this:

maxpatch image.jpg

Here's the actual file:

bitwacker input test.pat

I used a sparkfun bitwacker (bit whacker) as my microcontroller instead of our usual arduino because I guess it speaks to max/msp better. Here's a link to how to set up the bit whacker.

With a new distance sensor (because the ultrasonic sensor I bought required an input pulse to be programmed into it from the microcontroller, and by the time I figured that out I didn't have time to learn a new language to program a new microcontroller). In the presentation of the piece the projected video changed as people walked up to it. The tree went from being a plain tree to having gold shine through it.

Presentation.mov

Presentation.movPresentation.mov

Philip Beesley Artist Presentation (Elisa)


Philip Beasley is interested in the boundaries between nature and artifice, and explores this question by creating artificial environments which feel like nature and create an experience for viewers in which they are immersed and play important roles in the creation of the experience.

Orgone Reef is a speculation of what the skin of a building could be like in the future. The project is an interlinking matrix manufactured by a computer-controlled laser cutter. The project probes the possibilities of combining artificial and natural processes to form a hybrid ecology.

Beesley is infuenced by Spiritualism, a 19th century religious movement related to Quakerism which believed that we can communicate with the spirit world.

He's an architect using architectural textiles to bridge the technology research in architecture with the arts.


http://www.philipbeesleyarchitect.com
http://www.fundacion.telefonica.com/arteytecnologia/galeriavida/index_en.htm


As I learned about his work I made a list of words to define: Sensors, proximity detectors, muscle wires: shape memory alloy, actuators, "distributed networks of microprocessors", Capacitors. Now i have a much better sense of what all of these things do.

December 21, 2009

Prelude to Fly on the Wall Project

For continuing with my idea, as I mentioned in class, once I figure out the proper coding I would like to do a little miniseries using the same interaction (scrolling flash using a potentiometer) with different themes. Themes involving small animals with different perspectives would be interesting. For example, with this project I used an insect that had a very low perspective, so using an animal like a bird or something that would be higher up would be cool. Or an animation of something underground, so you would see a worm's perspective or something, I think you get the idea. For the visuals, I would have preferred to have an actual drawn animation, not video format, because animation was originally why I was interested in using arduino with flash. I also think the aesthetic of animation would help realize the piece more for someone who is interacting with the potentiometer handle feel and how that relates to what they look at. Live video seemed to have a disconnect a bit from what i intended, but I think a fabricated reality would be a nice touch to the action of the piece. Then, in terms of how someone interacts with the piece, I've always thought of this as being a little mini series on a website or something like that, where you would interact with it just as how I presented it on my laptop in class. But when thinking about other options for viewing this, I think it would be really interesting to have it be large scale as well. Where the image would be projected against a wall and the entire framing of the wall would be covered. Then if it was in a rectangular or box-like room, when you moved the potentiometer the entire screen projection would move to different areas in the room. So it would take up an entire blank room. For example, when looking forward you would see the entire projection against the wall in front of you and if you scrolled right, then the projection would scroll against the wall over to the wall on your right. In this scenario, the tiny little potentiometer would seem very powerful because a tiny little object/fly/bird/bug/whatever would control the motion of this huge projection in the room. Those are my hopes and dreams for this project anyway, once I figure out step number 3 that is! But if anyone has any thoughts on this, I'd love to hear them.

Final Project

Photo 33.jpg


View image

Here is my coding, painting.pde..

int photocellPin = 0; // the cell and 10K pulldown are connected to a0
int photocellReading; // the analog reading from the sensor divider
int LEDpin = 11; // connect Red LED to pin 11 (PWM pin)
int LEDbrightness; //
void setup(void) {
// We'll send debugging information via the Serial monitor
Serial.begin(9600);
}

void loop(void) {
photocellReading = analogRead(photocellPin);

Serial.print("Analog reading = ");
Serial.println(photocellReading); // the raw analog reading

// LED gets brighter the darker it is at the sensor
// that means we have to -invert- the reading from 0-1023 back to 1023-0
photocellReading = 355 - photocellReading;
//now we have to map 0-1023 to 0-255 since thats the range analogWrite uses
LEDbrightness = map(photocellReading, 0, 355, 0, 50);
analogWrite(LEDpin, LEDbrightness);

delay(100);
}

For my project I created an interactive painting. I inserted a light sensor in the painting that would cause several blue LED lights to light up when there was a lack of light hitting the sensor. I imagined that the painting set up in an area with natural light and would change throughout the day as the light slowly turned to darkness causing the painting to glow bright blue. If i were to make another one of these paintings i would have painted the paintings with the LEDs on so that i could better play off of the light and i could match the colors better. I also wish that i could have gotten my original idea to work so that i could have programmed the LEDs to switch from one to the other based on the light sensor.

FINAL Blinky Glove - Bryce Davidson

It was quite a journey with the Lilypad Arduino, but it worked out in the end. I really learned a lot. I was happy to have learned how to use conductive thread, program pins, work with powering the Lilypad, and physical construction. Here is the pictorial/video history of my project's progress...

Movie 70.mov
Movie 75.mov
GlovePrototype.jpg
Movie 114.mov

and the Code

int ledPin = 10; // LED connected to digital pin 13

// The setup() method runs once, when the sketch starts

void setup() {
// initialize the digital pin as an output:
pinMode(ledPin, OUTPUT);
}

// the loop() method runs over and over again,
// as long as the Arduino has power

void loop()
{
digitalWrite(ledPin, HIGH); // set the LED on
delay(80); // wait for a second
digitalWrite(ledPin, LOW); // set the LED off
delay(80); // wait for a second
}

I am still waiting on the download of the video footage of my performance with the blinky Lilypad glove, but for now, I think it really worked out how I wanted it too. I had hoped to understand the button switch, but I was still able to accomplish what I wanted to with my project which was an interaction between the digital world and the physical world. This is what I really understood Interactive art to be in its essence.

To break down the concept of my performance, I started with the idea of seeing light interact with movement. I wanted to make a complete body suit full of lights and then do a dance performance in it. My first thought was to power this suit with an accelerometer, so that the amount of light was dependant on the amount of movement. I came to realize that my understanding of the arduino and all of its elements would have to grow quite a bit more to realize this idea. But it was for the best when I started to think about the CONTEXT of this idea. Why was I spinning around with lights on my body? Why was I breakdancing? What was this idea about? As I explored this idea, I came to the realization that I wanted to create a story. I wanted to display something that had a pace. A piece that had a beginning, middle and end. I also liked the idea of opposites and extremes. Through this exploration of context and story line, I decided on creating a piece that had an interaction between an animated character and myself as the viewer. In my final performance, the character very slowly approaches a paperclip, a light socket and eventually after a long, drawn out process, the relationship between the two objects interaction. As soon as they connect, he is wildly electrocuted and sent out into the physical world, into my hand (represented by the blinking glove). At this point I explode into dance. The performance is ended abruptly when the character shoots out of my hand and back onto screen. The end. The intention of the piece was to represent a pace of excruciatingly slow build-up and waiting, followed by extreme energy and speed, and an abrupt end. I also wanted to create a representation of a viewer being forced into an imaginary digital character's experience. I think I was able to accomplish this in my piece and I am very happy with the final product. I will post the video as soon as it is downloaded...
-Bryce

Here is an excerpt of my performance
http://mediamill.cla.umn.edu/mediamill/embed.php?subclip_id=795&live=true

Here is the clip of my performance:

bryceinteractivesmall.mov

December 19, 2009

Final Project - Ardrumo - Nick Gentle

SSPX0055.jpg
SSPX0056.jpg
SSPX0057.jpg
My final project was essentially a modified construction of something that had already been created called Ardrumo, which was a series of drum pads wired to the Arduino that would send MIDI information through its USB connection into a program called Ardrumo, which would then communicate the MIDI information through Garageband.

The basic specifications for the Ardrumo can be found here:
http://code.google.com/p/ardrumo/

CODE------------------------------------------------------------------------------------------------------

/*
* Ardrumo sketch
*
* Use with the Ardrumo software here:
* http://code.google.com/p/ardrumo/
* This is designed to let an Arduino act as a drum machine
* in GarageBand (sorry, Mac OS X only).
*/

#define LEDPIN 13 // status LED pin
#define PIEZOTHRESHOLD 5 // analog threshold for piezo sensing
#define PADNUM 6 // number of pads

int val;

void setup() {
pinMode(LEDPIN, OUTPUT);
Serial.begin(57600); // set serial output rate
}

void loop() {

// Loop through each piezo and send data
// on the serial output if the force exceeds
// the piezo threshold
for(int i = 0; i < PADNUM; i++) {
val = analogRead(i);
if( val >= PIEZOTHRESHOLD ) {
digitalWrite(LEDPIN,HIGH); // indicate we're sending MIDI data
Serial.print(i);
Serial.print(",");
Serial.print(val);
Serial.println();
digitalWrite(LEDPIN,LOW);
}
}
}
Here is the basic schematic for how everything is wired:
concept.jpg

Ardrumo:
screenshot.jpg

Unfortunately, my Mac crashed/probable hard drive failure (again) so I'm unable to give a screenshot of how Ardrumo is set up in Garageband. However, I can try to describe it textually. It's essentially one track in Garageband; a MIDI instrument/computer generated instrument track. It should be green. Then, under effects, select >Drums, then >Rock Set or >Hip Hop Set, depending on what kinds of sounds you want. That's basically it. Very little tech knowledge needed to run the Ardrumo through Garageband.

The larger, interactive implication for my idea came about during my periods of boredom either in class or sitting at a table trying to pass time. I, coming from a musical standpoint, am constantly in a state of writing music or "playing music". My constant tendencies to begin drumming with my hands and feet on the floor and on tables helped to construct this idea. I decided that it would be awesome if there were a way to bring my random "noodling" around on my "air" drums to life. Enter the Ardrumo. In a perfect world, I would have the peizo sensing pads somehow infused into table or some other inanimate object. This way, you still get the experience of being in a typical/mute/neutral location, while still being able to create audible drum sounds with your hands (where they would be amplified through speakers). Also in this way, the subject matter is always new and personal to the user.

-Nick Gentle

December 17, 2009

Fly on the Flash











fly on wall video

http://mediamill.cla.umn.edu/mediamill/display/56278

Fly on the wall

fly on the table

Using Flash, Arduino, and a potentiometer.
Here you can see how the potentiometer is used to scroll through the flash video, so that the viewer controls what they see. If anyone has questions about using flash, I can answer animation issues, but I'm not to familiar with the technical issues of connecting arduino with flash. But if you're interested, feel free to contact me. I'd be willing to help people out with flash animations if they ever need it.

December 15, 2009

Final Project Update - Alec Rippberger

For my final project I will be creating a link between the physical and digital realms. Interaction with a physical representation of a tree is linked with an animation of a tree projected onto a screen.

With online virtual communities replacing physical interaction, this installation is meant to make the viewer contemplate our interactions in life. What is more real, the physical or digital representation? Which is more meaningful or beautiful?

tree.swf

In the final presentation of this digital tree the more a viewer shakes the physical tree the more leaves will fall off the digital tree.

I used "serproxy" to act as an intermediate between Flash and the Arduino because the Arduino talks to the computer through the serial ports while Flash will only listen to a type of internet protocol. Serproxy acts as a translator allowing Flash and the Arduino to communicate. Serproxy can be downloaded from the Arduino page HERE. Serproxy was configured as so:

# Config file for serproxy
# See serproxy's README file for documentation

# Transform newlines coming from the serial port into nils
# true (e.g. if using Flash) or false
newlines_to_nils=true

# Comm ports used
comm_ports=1,2,3,4

#THIS IS MY ARDUINO SERIAL
serial_device1=/dev/cu.usbserial-A6008dSs

#BAUD RATE SET TO 9600 LIKE ARDUINO CODE
comm_baud=9600
comm_databits=8
comm_stopbits=1
comm_parity=none

# Idle time out in seconds
timeout=300

# Port 1 settings (ttyS0)
net_port1=5331

# Port 2 settings (ttyS1)
net_port2=5332

# Port 3 settings (ttyS2)
net_port3=5333

# Port 4 settings (ttyS3)
net_port4=5334

To allow the Arduino to trigger the flash animation I used a Flash class called "as3Glue" which can be found HERE. THis flash class allows flash to check inputs and send output to the Arduino board.

I used "Firmata" to allow as3Glue to fluidly communicate with my Arduino. Firmata can be found HERE. I used the standard Firmata code with slight modification:

/*
Copyright (C) 2006-2008 Hans-Christoph Steiner. All rights reserved.

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

See file LICENSE.txt for further informations on licensing terms.

formatted using the GNU C formatting and indenting
*/


/*
* TODO: add Servo support using setPinModeCallback(pin, SERVO);
* TODO: use Program Control to load stored profiles from EEPROM
*/

#include
#include

/*==============================================================================
* GLOBAL VARIABLES
*============================================================================*/

/* analog inputs */
int analogInputsToReport = 0; // bitwise array to store pin reporting
int analogPin = 0; // counter for reading analog pins

/* digital pins */
byte reportPINs[TOTAL_PORTS]; // PIN == input port
byte previousPINs[TOTAL_PORTS]; // PIN == input port
byte pinStatus[TOTAL_DIGITAL_PINS]; // store pin status, default OUTPUT
byte portStatus[TOTAL_PORTS];

/* timer variables */
unsigned long currentMillis; // store the current value from millis()
unsigned long nextExecuteMillis; // for comparison with currentMillis
int samplingInterval = 19; // how often to run the main loop (in ms)

Servo servos[2]; // the servo library can control servos on pins 9 and 10 only

/*==============================================================================
* FUNCTIONS
*============================================================================*/

void outputPort(byte portNumber, byte portValue)
{
portValue = portValue &~ portStatus[portNumber];
if(previousPINs[portNumber] != portValue) {
Firmata.sendDigitalPort(portNumber, portValue);
previousPINs[portNumber] = portValue;
Firmata.sendDigitalPort(portNumber, portValue);
}
}

/* -----------------------------------------------------------------------------
* check all the active digital inputs for change of state, then add any events
* to the Serial output queue using Serial.print() */
void checkDigitalInputs(void)
{
byte i, tmp;
for(i=0; i < TOTAL_PORTS; i++) {
if(reportPINs[i]) {
switch(i) {
case 0:
outputPort(0, PIND &~ B00000011); // ignore Rx/Tx 0/1
break;
case 1:
outputPort(1, PINB);
break;
case ANALOG_PORT:
outputPort(ANALOG_PORT, PINC);
break;
}
}
}
}

// -----------------------------------------------------------------------------
/* sets the pin mode to the correct state and sets the relevant bits in the
* two bit-arrays that track Digital I/O and PWM status
*/
void setPinModeCallback(byte pin, int mode) {
byte port = 0;
byte offset = 0;

// TODO: abstract for different boards
if (pin < 8) {
port = 0;
offset = 0;
} else if (pin < 14) {
port = 1;
offset = 8;
} else if (pin < 22) {
port = 2;
offset = 14;
}

if(pin > 1) { // ignore RxTx (pins 0 and 1)
if(pin > 13)
reportAnalogCallback(pin - 14, mode == ANALOG ? 1 : 0); // turn on/off reporting
switch(mode) {
case ANALOG:
digitalWrite(pin, LOW); // disable internal pull-ups and fall thru to 'case INPUT:'
case INPUT:
pinStatus[pin] = mode;
pinMode(pin, INPUT);
portStatus[port] = portStatus[port] &~ (1 << (pin - offset));
break;
case OUTPUT:
digitalWrite(pin, LOW); // disable PWM and fall thru to 'case PWM:'
case PWM:
pinStatus[pin] = mode;
pinMode(pin, OUTPUT);
portStatus[port] = portStatus[port] | (1 << (pin - offset));
break;
case SERVO:
if((pin == 9 || pin == 10))
pinStatus[pin] = mode;
else
Firmata.sendString("Servo only on pins 9 and 10");
break;
case I2C:
pinStatus[pin] = mode;
Firmata.sendString("I2C mode not yet supported");
break;
default:
Firmata.sendString("Unknown pin mode"); // TODO: put error msgs in EEPROM
}
// TODO: save status to EEPROM here, if changed
}
}

void analogWriteCallback(byte pin, int value)
{
switch(pinStatus[pin]) {
case SERVO:
if(pin == 9) servos[0].write(value);
if(pin == 10) servos[1].write(value);
break;
case PWM:
analogWrite(pin, value);
break;
}
}

void digitalWriteCallback(byte port, int value)
{
switch(port) {
case 0: // pins 2-7 (don't change Rx/Tx, pins 0 and 1)
// 0xFF03 == B1111111100000011 0x03 == B00000011
PORTD = (value &~ 0xFF03) | (PORTD & 0x03);
break;
case 1: // pins 8-13 (14,15 are disabled for the crystal)
PORTB = (byte)value;
break;
case 2: // analog pins used as digital
byte pin;
byte pinModeMask;
for(pin=0; pin<8; pin++)
if(pinStatus[pin] == OUTPUT)
pinModeMask += 1 << pin;
PORTC = (byte)value & pinModeMask;
break;
}
}

// -----------------------------------------------------------------------------
/* sets bits in a bit array (int) to toggle the reporting of the analogIns
*/
//void FirmataClass::setAnalogPinReporting(byte pin, byte state) {
//}
void reportAnalogCallback(byte pin, int value)
{
if(value == 0) {
analogInputsToReport = analogInputsToReport &~ (1 << pin);
}
else { // everything but 0 enables reporting of that pin
analogInputsToReport = analogInputsToReport | (1 << pin);
setPinModeCallback(pin, ANALOG);
}
// TODO: save status to EEPROM here, if changed
}

void reportDigitalCallback(byte port, int value)
{
reportPINs[port] = (byte)value;
if(port == ANALOG_PORT) // turn off analog reporting when used as digital
analogInputsToReport = 0;
}

/*==============================================================================
* SYSEX-BASED commands
*============================================================================*/

void sysexCallback(byte command, byte argc, byte *argv)
{
switch(command) {
case SERVO_CONFIG:
if(argc > 4) {
// these vars are here for clarity, they'll optimized away by the compiler
byte pin = argv[0] - 9; // servos are pins 9 and 10, so offset for array
int minPulse = argv[1] + (argv[2] << 7);
int maxPulse = argv[3] + (argv[4] << 7);
servos[pin].attach(argv[0], minPulse, maxPulse);
// TODO does the Servo have to be detach()ed before reconfiguring?
setPinModeCallback(pin, SERVO);
}
break;
case SAMPLING_INTERVAL:
if (argc > 1)
samplingInterval = argv[0] + (argv[1] << 7);
else
Firmata.sendString("Not enough data");
break;
}
}


/*==============================================================================
* SETUP()
*============================================================================*/
void setup()
{
byte i;

Firmata.setFirmwareVersion(2, 1);

Firmata.attach(ANALOG_MESSAGE, analogWriteCallback);
Firmata.attach(DIGITAL_MESSAGE, digitalWriteCallback);
Firmata.attach(REPORT_ANALOG, reportAnalogCallback);
Firmata.attach(REPORT_DIGITAL, reportDigitalCallback);
Firmata.attach(SET_PIN_MODE, setPinModeCallback);
Firmata.attach(START_SYSEX, sysexCallback);

portStatus[0] = B00000011; // ignore Tx/RX pins
portStatus[1] = B11000000; // ignore 14/15 pins
portStatus[2] = B00000000;

for(i=0; i setPinModeCallback(i,OUTPUT);
}
// set all outputs to 0 to make sure internal pull-up resistors are off
PORTB = 0; // pins 8-15
PORTC = 0; // analog port
PORTD = 0; // pins 0-7

// TODO rethink the init, perhaps it should report analog on default
for(i=0; i reportPINs[i] = false;
}
// TODO: load state from EEPROM here

/* send digital inputs here, if enabled, to set the initial state on the
* host computer, since once in the loop(), this firmware will only send
* digital data on change. */
if(reportPINs[0]) outputPort(0, PIND &~ B00000011); // ignore Rx/Tx 0/1
if(reportPINs[1]) outputPort(1, PINB);
if(reportPINs[ANALOG_PORT]) outputPort(ANALOG_PORT, PINC);

Firmata.begin(57600);
}

/*==============================================================================
* LOOP()
*============================================================================*/
void loop()
{
/* DIGITALREAD - as fast as possible, check for changes and output them to the
* FTDI buffer using Serial.print() */
checkDigitalInputs();
currentMillis = millis();
if(currentMillis > nextExecuteMillis) {
nextExecuteMillis = currentMillis + samplingInterval;
/* SERIALREAD - Serial.read() uses a 128 byte circular buffer, so handle
* all serialReads at once, i.e. empty the buffer */
while(Firmata.available())
Firmata.processInput();
/* SEND FTDI WRITE BUFFER - make sure that the FTDI buffer doesn't go over
* 60 bytes. use a timer to sending an event character every 4 ms to
* trigger the buffer to dump. */

/* ANALOGREAD - right after the event character, do all of the
* analogReads(). These only need to be done every 4ms. */
for(analogPin=0;analogPin if( analogInputsToReport & (1 << analogPin) ) {
Firmata.sendAnalog(analogPin, analogRead(analogPin));
}
}
}
}


I will post the code of the Flash code and more documentation once all bugs have been worked out.

tools for actions

Tools for Actions


16 October 2009 until 13 March 2010
Graham Foundation for Advanced Studies in the Fine Arts
4 West Burton Place, Chicago, Illinois


Contactsheet-Sustainable-Dance-Floor-and-Pee-experience1.jpg


air_de_paris_1.jpg


mtlsoundmap.png

ACT_OL_515R_02.jpg


The Canadian Centre for Architecture (CCA) presents Actions: What You Can Do With the City, an exhibition with 99 actions that instigate positive change in contemporary cities around the world. Seemingly common activities such as walking, playing, recycling, and gardening are pushed beyond their usual definition by the international architects, artists, and collectives featured in the exhibition. Their experimental interactions with the urban environment show the potential influence personal involvement can have in shaping the city, and challenge fellow residents to participate.

December 14, 2009

Bare: Skin Safe Conductive Ink

Bare-skinSafe Ink-imageCrop.jpg

Bare is a conductive ink that is applied directly onto the skin allowing the creation of custom electronic circuitry. This innovative material allows users to interact with electronics through gesture, movement, and touch. Bare can be applied with a brush, stamp or spray and is non-toxic and temporary. Application areas include dance, music, computer interfaces, communication and medical devices. Bare is an intuitive and non-invasive technology which will allow users to bridge the gap between electronics and the body.

web site: http://www.bareconductive.com/home.html

December 13, 2009

Collaboration: crow nod

(post edited)

Carl posted two pics and a description of the action in his blog, November 29. The following is the code.

Crow_sWorld_120_Sweep_Nod.pde

open source resources - 2009

as you continue exploring tangible forms of interactive art these resources and the communities of artists, architects, designers, inventors and other playful people who share their experiences, may be helpful to you and your expereinces may be helpful to them.

. opensourcehardware2009.jpg

December 11, 2009

I want to smash my Arduino - Bryce Davidson

So, I have been exploring how to use a button on the lilypad, and so far it has been quite difficult to figure out. I know the button works, I know the power source works, and I that I know what the code needs to be to get the kind of functioning I want with the button switch, but so far it's not happening. Here is the code I am working with. See any problems? I really want this to work. I know it's possible!!!!!

int ledPin = 10;
int switchPin = 5; // switch is connected to pin 2
int val; // variable for reading the pin status
int buttonState; // variable to hold the last button state

void setup() {
pinMode(ledPin, OUTPUT);
pinMode(switchPin, INPUT); // Set the switch pin as input

Serial.begin(9600); // Set up serial communication at 9600bps
buttonState = digitalRead(switchPin); // read the initial state
}


void loop()
{
digitalWrite(ledPin, HIGH); // set the LED on
delay(80); // wait for a second
digitalWrite(ledPin, LOW); // set the LED off
delay(80); // wait for a second

{
val = digitalRead(switchPin); // read input value and store it in val

if (val != buttonState) { // the button state has changed!
if (val == LOW) { // check if the button is pressed
Serial.println("Button just pressed");
}
else { // the button is -not- pressed...
Serial.println("Button just released");
}
}

buttonState = val; // save the new state in our variable
}


val = digitalRead(switchPin); // read input value and store it in val

if (val != buttonState) { // the button state has changed!
if (val == HIGH) { // check if the button is pressed
Serial.println("Button just pressed");
} else { // the button is -not- pressed...
Serial.println("Button just released");
}
}

buttonState = val; // save the new state in our variable
}

December 9, 2009

jane's One-on-One: prototype I

This project is an interactive wearable belt. The content relates to my and other women's experiences of permission to touch a pregnant stomach strangers give themselves. It will have two modes of operation: non-touch and touch. In non-touch mode red "warning" lights will flash. In touch mode, a series of interactions will be possible. Extracting the container with the fetus embryo model, will trigger a tilt sensor causing either a muscle wire to produce a small movement or a blue LED to glow in the fetus model. Touching the cast rubber will cause different actions depending on how touched. Still deciding on what these should be.

One-on-One Sketch-crop8xAdjs.jpg

December 8, 2009

Final Project Concept

Interactive Concept.jpg

I have become very interested in Processing over the past couple of weeks and have made a slight shift in the direction of the final project. As discussed last week, I am interested in a more "code intensive" project than previously.

The project will use several capacitive sensors to communicate with Processing via the Arduino. The serial inputs will create contained lighting condition on a surface. In addition the inputs will manipulate the duration, tempo, and frequency of an audio signal to create a hybrid sensory experience.

Final Project Progress

For my final project i plan on creating an interactive painting utilizing diffused LED's and light sensors. I am currently trying to work on the programming of the LED's so that I can get multiple LED's to turn on and off based on the light sensor. I have several options for the painting in my head but i have yet to decide which version i will decide to use. I am thinking of either a cityscape/landscape that will become lit up as the viewer blocks the light source or possibly an eclipse in which the moon will block the light sensor embedded in the sun. These options will depend on how far i can get with the programming.
~Tyler

December 6, 2009

Matt's Final Project

For my final piece I'm going to use the arduino with Flash. I want to create an animation that allows the viewer to look right and/or left in the animation. The content for the animation will be a coffee shop, similar to the image shown below. Then the viewer will put themselves in the place of the fly, where they will be able to see what the fly see's. I like the idea of interacting with an animation, so that is basically the concept of the whole piece. I'd like the video animation to be projected against a wall, so that the viewer feels small, like the fly.

coffee_and_cigarettes3.jpg

December 5, 2009

Spark Fun FREE Day 1/7/2010

Whether your love of the arduino is waxing or waning as we near the end of the semester, I hope that you will continue with your own approach to interactive art.

Most fortunately for all of us, Spark Fun [the source of many of our supplies] is having a "give-back" day.

which translates to $100 worth of Spark Fun products free to you when you order online on January 7th, 2010 between 9AM MST and 11PM MST

usdollar100front.jpg


Spark Fun Free Day


enjoy!

seed studio

for those who are less enamored with the electronics side of the arduino, you might be interested in the "plug and play" electronic block kit

here is the sensor shield - the sensors include resistors, etc and are plugged into the ports.

SensorShield.jpg

in general I encourage you to persevere, but I think this might work well for prototyping your ideas and having the opportunity to explore the interaction more deeply before diving into the electronic construction.

rainbowduino

rainbowduino exists to bring the joys of light and color closer to you

here is a demo:

Rainbowduino Demo Video from Seeed Studio on Vimeo.

">

and a wearable "biological clock"

The Biological Clock dress from Sharkbait on Vimeo.

">

December 4, 2009

Final Project Progress-Robin Schwartzman

My "tree installation" has been slowly progressing throughout the semester. As of right now, I have my flower bush complete, with about 50 different flower sounds that are triggered randomly when each flower is picked. I also have completed the clover mound, which is a game of sorts. When a three leaf clover is picked, it yells at you saying something like "nope", "wrong", "not me", and "can't you count?". When you find the four leaf clover and pick it, you are awarded with cheers and applause.
Here are some images of those pieces:

flowers.jpg

clovers.jpg

As far as the coding, right now all of my coding for the flowers and clovers is together with the background music (zip-a-dee-doo-dah) on one waveshield. When I get multiple waveshields, the sounds will be programmed separately so that they can start to build on eachother. The coding is here:

flowers:clovers.doc

I've also made significant progress on the blinking apple tree. He blinks using a system with the stepper motor, an arduino motorshield, some thick aluminum wire, a sewing bobbin and fishing line. Here are two images-one with eyes closed, the next with eyes open. You can also see the picnic blanket hanging behind the tree. I still need to wire up a system underneath the blanket (with foam and aluminum foil) so that when one steps on the blanket, the tree will also talk.

treeclosed.jpg

treeopen.jpg

Here is my coding for the blinking eyes:blinkyeyes.doc

More to come, looking forward to piecing everything together into a cohesive installation.

December 3, 2009

Mike's Slit Scan Proposal

My project will involve using a processing sequence called the slit scan. Images captured by the camera are transfered and elongated through the passage of time stretching an image and its movements. When looking at the effect this sketch has on an image, I found myself thinking of a constantly changing pattern that is being replicated based on the will of movement that object has. This to me is representative of free will which is still restricted and unequivocally connected by the passage of time.

In my project I hope to construct three slit scan stations for people to interact with simultaneously. The results that the slit scan stations will yield will be projected onto a surface for all three participants to see. The participants will create their own slit scan "identities" and change them at their will. The images will be created not from the image of the person, but by predestined patterns fitted to stamps. There will be numerous amounts of stamps to choose from, and every pattern will be unique. The subject will take the stamp and place it on the surface of a pedestal of their choosing and move the pattern to shape the slit scan image before them. All three changing patterns will be projected at the same time, comparing the identities of their slit scan to each other.

Thats pretty much it, in a very confusing nut shell.

-Mike Ballard

MIDI and such

For my final project, I'm planning on utilizing some piezo sensors to run through the Arduino, through the USB port, through a program that I found called Ardumo, and finally through Garageband, to be able to create essentially an electronic drumset using 6 piezo sensors, each with a different drum. I'm not deadset on making it strictly drums, but for simplicity's sake (and I enjoy simple) I might just leave it with drums.

Here is the website where I have been getting the information on how to construct this.

http://code.google.com/p/ardrumo/

Blinking Breakdance

As I have talked about much throughout the semester. I am planning on using the lilypad arduino and lilypad led's to create a bright blinking dance piece. I will sew the LED's, Lilypad Arduino, a switch, and a power source to a fingerless glove. This way, I can control when the lights turn on and off. I will combine this blinky art on my glove with an animation to create a multimedia performance art piece that will reflect extremes in energy and motion. I'm excited to put it together. -bryce

Independent Project

For my independent project this is my objective:

Using the presentation space, I will have a sort of garden using different visual elements. A chair with pressure activated button pads on the seat and back will provide on/off controls. The seat pad will activate the rotating CD flower shown in a previous post of mine. The back pad could activate lighting possibly (I don't know if this is feasible), or some other yet to be created part. A fall-back option is to create a second CD flower for the second pad. Lighting will be used to play with reflective effects off of the CDs.

December 2, 2009

shutters

Shutters from Marcelo Coelho on Vimeo.

">

December 1, 2009

Mystery Well

Mike Ballard, Justin Berken, Elisa Berry, Maj Furani, Matt Wenger

P1013659.JPG


P1013668.JPG


P1013669.JPG


P1013670.JPG