Hunting a Snark? | Rudi Knoops

Icon

exploring uncharted terrain on the New Media map (after Lewis Carroll)

Into Physical Computing

One of the installations I’m currently building for the museum M in Leuven, is a large interactive wall, consisting of 4 projections next to eachother. The interaction is being triggered by detection of presence or movement.
The content is built around 12 objects from the archeology collection. Each object or artefact generates an associative stream of images, as if visualising a stream-of-consciousness.

The technology involved is quite complex. For the time being, it is a combination of motion or presence detection, Arduino (as a Physical Computing platform), Flash, …

one small step into the world of Physical Computing

one small step into the world of Physical Computing

The total width of the projection is ± 1280 x 4 pixels which mounts up to a whopping 5120 pixels horizontally.

Of course, as in every project, ‘things’ need to be sorted out:
Flash export is for example still limited to 2880 x 2880 pixels. I’d hoped for changes with CS4, but alas. Scaling the exported swf to the required resolution is a no go, as not all the visuals will be vectorbased.
The compromise is to use 2 Flash files next to eachother, and use “localConnection” to have the 2 files communicate.
If intermovie communication is necessary in the final product, implementing “localConnection” will be the way to go.

Then there is/was the choice of sensors.
After quite a bit of reading and experimenting, I decided upon using the Ping))) Ultrasonic Range Finder.

The code I’m using now is based upon David Cuartielles Arduino sketch that I expanded with code that I found in the arduino playground: http://www.arduino.cc/playground/Main/UltrasonicSensor and that converts the value of the ultrasound echo into centimeters!  (Thank you Jason Ch!!)

As I’m using several sensors as physical input, I collect the separate readings of the sensors in one string, the different readings separated by a comma.
Here is the Arduino sketch (this sketch is  for 2 ultrasonic sensors:  multiply when using more sensors)

unsigned long echo_01 = 0;
int ultraSoundSignal_01 = 7; // Ultrasound signal pin
unsigned long ultrasoundValue_01 = 0;
unsigned long echo_02 = 0;
int ultraSoundSignal_02 = 8; // Ultrasound signal pin
unsigned long ultrasoundValue_02 = 0;
void setup()
{
Serial.begin(9600);
pinMode(ultraSoundSignal_01,OUTPUT);
pinMode(ultraSoundSignal_02,OUTPUT);
}
unsigned long ping_01(){
pinMode(ultraSoundSignal_01, OUTPUT); // Switch signalpin to output
digitalWrite(ultraSoundSignal_01, LOW); // Send low pulse
delayMicroseconds(2); // Wait for 2 microseconds
digitalWrite(ultraSoundSignal_01, HIGH); // Send high pulse
delayMicroseconds(5); // Wait for 5 microseconds
digitalWrite(ultraSoundSignal_01, LOW); // Holdoff
pinMode(ultraSoundSignal_01, INPUT); // Switch signalpin to input
digitalWrite(ultraSoundSignal_01, HIGH); // Turn on pullup resistor
echo_01 = pulseIn(ultraSoundSignal_01, HIGH); //Listen for echo
ultrasoundValue_01 = (echo_01 / 58.138) ; //convert to Centimeters
return ultrasoundValue_01;
}
unsigned long ping_02(){
pinMode(ultraSoundSignal_02, OUTPUT); // Switch signalpin to output
digitalWrite(ultraSoundSignal_02, LOW); // Send low pulse
delayMicroseconds(2); // Wait for 2 microseconds
digitalWrite(ultraSoundSignal_02, HIGH); // Send high pulse
delayMicroseconds(5); // Wait for 5 microseconds
digitalWrite(ultraSoundSignal_02, LOW); // Holdoff
pinMode(ultraSoundSignal_02, INPUT); // Switch signalpin to input
digitalWrite(ultraSoundSignal_02, HIGH); // Turn on pullup resistor
echo_02 = pulseIn(ultraSoundSignal_02, HIGH); //Listen for echo
ultrasoundValue_02 = (echo_02 / 58.138) ; //convert to Centimeters
return ultrasoundValue_02;
}
void loop()
{
int x_01 = 0;
x_01 = ping_01();
Serial.print(x_01);
//insert a comma to separate the readings
//in Flash you can generate an array from this string
Serial.print(',');
int x_02 = 0;
x_02 = ping_02();
Serial.print(x_02);
Serial.println(0, BYTE);  // necessary for being able to read the data in Flash!!!
delay(100); //delay 1/4 seconds. // set slower to 1000 e.g. depending on the needs
}

Another issue in the Arduino-Flash communication is that the Arduino board does not communicate directly with Flash. In contrast to programmes such as Processing or Max/MSP, you need a socket that transfers the serial data from the Arduino board to Flash.
A solution that works fine for me is the Java applet “Serial Server”, handling the serial communication in the background.

(Screenshot to be inserted)

Explaining the Flash part will be for another day.

Reading “SOFTWARE TAKES COMMAND”

Lev Manovich publishes his latest book “Software Takes Commandon-line – I’m discussing the November 20, 2008 version – and he is open to suggestions for cover art, or illustrations.

softbook_coverA, as shown on Manovichs  website

softbook_coverA, as shown on Manovich's website

Nice idea, on-line pre-publishing, and it will not keep me from bying a print copy when the final version will be available. ;-)

With this book Manovich puts his own book “The Language of New Media” (completed 1999; published by MIT Press 2001) , where he a.o. coined the term ‘software studies’, in perspective.

”New media calls for a new stage in media theory whose beginnings can be traced back to the revolutionary works of Robert Innis and Marshall McLuhan of the 1950s. To understand the logic of new media we need to turn to computer science. It is there that we may expect to find the new terms, categories and operations that characterize media that became programmable. From media studies, we move to something which can be called software studies; from media theory — to software theory.” (p. 5, 6)

“Software takes command” redefines the concept of ‘software studies’ as a new academic discipline: a unique object of study, and at the same time a new research method.

“[...] I think that Software Studies has to investigate both the role of software in forming contemporary culture, and cultural, social, and economic forces that are shaping development of software itself.”
(p. 6)

And if we are to focus on that software layer itself – a layer that permeates all areas of contemporary societies – we need a new methodology. Manovich stresses here that he is writing about cultural software: “software programs which are used to create and access media objects and environments.” (p. 13)

His book is an interesting continuation of exploring and identifying the medialayers – speaking of software-layers would probably be more appropriate – in society, but it does not provide a methodology for software studies. On the other hand, just as he provided us in his book “The Language of New Media” with a language to discuss New Media, Lev Manovich provides us now with a language to discuss what software studies are, could be or should be. That already sounds like being part of a methology.

Anyhow, “Software takes command” is part of a larger effort to establish software studies as an academic field; the video repository of “SoftWhere 2008” looks certainly very interesting in that context.

motion tracking in processing

I’m currently building a playful Processing application for the pre-opening of the new Media & Design Academy building at C-Mine. The pre-opening is scheduled for the weekend of april 25-26 2009. So I have quite some time left to finetune the draft version I have now.

using my old phone as trigger

using my phone as trigger, the red square outlining the blob

Concept = The mirrored video image of people passing in a specific frame is projected lifesize. When you stand still in the frame, you just have the projection of your mirror image. Movement will reveal an extra layer.  Using motion detection, particles of ribbons that follow the movement in the frame are superimposed upon the videosource.

Curious how people will interact with this.

For the time being it’s based on motion tracking as provided in the JMyron processing library.

I took out the visualisation of the blobs (well not yet everything, as keeping some visual reference in an unfinished product is a real time saver while still in production. I just have to outcomment a few lines of code when completely finished.)

And I added:

  • Mirroring of the video input image
  • the 2D ribbon code graceously provided by James Alliban, which I linked to the motion tracking output.

Still to implement:

  • Mirroring of the motion tracking output.
  • Limiting the amount of blobs.  (based on luminance levels, well, in fact on colour)

What I have now works best in a dark setting: writing particles using a light source (my mobile phone).

If you browse James Alliban’s blog, you’ll notice that I got my inspiration from his virtual ribbons experiment. I’m only using his 2D ribbon code though, but combining this with other chunks of code into a real application, forces me to delve deeper into Processing, and will probably prove to be quite a learning experience.

Will be continued…

 

January 2009
M T W T F S S
« Dec   Feb »
 1234
567891011
12131415161718
19202122232425
262728293031  
I'm a lecturer and researcher at the MAD-faculty, C-mine Genk, Belgium. This blog documents my PhD research, where I explore the possibilies of the multiple in audiovisual media. My practice based arts research shows an evolution towards installation-based works.