December 2, 2010

jsdhfj

asdfjsdjf

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.