Month: March 2010

Pixelache #2: Kerava groworld installation

Lina Kusaite and I installed the groworld project as part of Camp Pixelache at Kerava Art Museum. It was the first time the plant eyes game had been exposed to so many public – but as I’ve come to expect, younger visitors needed surprisingly little explanation to figure out how to play (i.e. none), while older people needed a little help. It was also the first showing of the huge pataforest drawing.

The arduino and plant sensor worked constantly throughout the day (not surprising as it’s sister has been working tirelessly for months) feeding the game with environmental information from the test subject plant – a pink Gerbera.

The camp in general was an interesting experience. The day started (after some last minute setup) with barcamp style discussions – I took part in one on Art and renewable energy before having to switch modes and present Fluxus and talk about livecoding with Gabor as part of the puredyne sprint debriefing. It was good to connect the two threads by using the groworld installation downstairs as an example of fluxus being used.

Aymeric Mansoux presenting the puredyne penknife.

Pixelache #1 Suomenlinna puredyne sprint

Part one of my pixelache experience was on the ice surrounded island of Suomenlinna, where Gabor and I spent 3 days working on fluxus. With the help of the puredyne sprint team we got the debian packaging working on launchpad – which is Ubuntu’s system for organising software packages and making sure they build on the various architectures and Ubuntu OS versions. We now have a fluxus ppa so people running a debian based system can directly get updates from us with apt-get upgrade.

We also spent a little time discussing the situation with proprietary graphics card drivers and Linux. This has recently become a personal matter, as my graphics card is no longer supported by ATI for current Linux kernels. We talked about avoiding locked away features as artistic constraint, and looked at people trying to do something about this like the xorg crack pushers and phoronix. One plan is to make the more cutting edge xorg code availible as a puredyne package so we can quickly test these free software drivers for installations and performances.

Kansallisteatteri Building Projection

The Kansallisteatteri is the Finnish National Theatre, and thanks to Miska Knapek and Ville Hyvönen I have the opportunity to try a quick bit of building projection as part of the Pixelache festival. I’m going to try growing plants from bits of the building that seeds would be able to rest on (i.e. any upward facing surfaces):

This is a test animation for the growing – they look quite a lot better now, but I like the style of this movie:

More on the plant sensor

The plan is to have some plant sensing working for a groworld installation we are doing at Camp Pixelache so I’ve made the circuitry a little more durable with a bit of soldering:

Here’s the circuit diagram – the values of components are influenced by what I happen to have in my collection of surplus/donated stock but are based on Nik’s original circuit:

The code running on the arduino can be found here.

This is the code that reads the arduino in fluxus. It contains some hastily written auto calibration, which records the highest and lowest values received from each sensor and scales the output between 0 and 1 using these values. This isn’t necessarily the right thing to do in all situations.

;; p l a n t   e y e s  [ copyright (c) 2010 foam vzw : gpl v3 ]

#lang scheme/base

; read values from arduino on the serial port, and hand them out to the game

(provide (all-defined-out))

(define serial (open-input-file "/dev/ttyUSB0"))
;(define serial #f)

(define current-raw '(0 0))
(define light-range '(999999 0))
(define moisture-range '(9999999 0))
(define current-cali '(0 0))

; return the raw sensor values
(define (sensor-light)
  (car current-raw))

(define (sensor-moisture)
  (cadr current-raw))

; return the calibrated sensor values
(define (sensor-cali-light)
  (car current-cali))

(define (sensor-cali-moisture)
  (cadr current-cali))

(define (fit a l h)
  (if (zero? (- h l)) 
      0
      (exact->inexact (/ (- a l) (- h l)))))

(define (sensor-update)
  (when (and serial (char-ready? serial))
    (set! current-raw (sensor-process (read-line serial)))
    
    ; some auto calibration
    (set! light-range 
          (list 
           (if (< (sensor-light) (car light-range))
               (sensor-light) (car light-range))
           (if (> (sensor-light) (cadr light-range))
               (sensor-light) (cadr light-range))))
    
    (set! moisture-range 
          (list 
           (if (< (sensor-moisture) (car moisture-range))
               (sensor-moisture) (car moisture-range))
           (if (> (sensor-moisture) (cadr moisture-range))
               (sensor-moisture) (cadr moisture-range))))
    
    (set! current-cali (list (fit (sensor-light) (car light-range) (cadr light-range))
                             (fit (sensor-moisture) (car moisture-range) (cadr moisture-range))))
    (printf "current-cali ~a~n" current-cali)                           
    (printf "ranges ~a ~a~n" light-range moisture-range)))

(define (convert n)
  (string->number n))

(define (sensor-process str)
  (let ([data (regexp-split #rx"," str)])
    (list
     (convert (list-ref data 0))
     (convert (list-ref data 1)))))

Plant -> Game interface

I’ve reconstructed some of the plant sensing hardware we developed during the summer and adapted the plant eyes game to use the sensors to reflect changes in the real plant’s environment. Currently, light levels change the perception of time to the game plants. When it gets dark the plant slows down, so the world around it speeds up. This is shown by altering the speed of the non-plant life, the insects – for instance butterfly wing flaps slow down as the plant receives more light. Moisture levels affect the health of the plants in the game, changing their colour from healthy green to ill to a dried up yellow/brown. Here’s a before and after shot of watering a test pilot plant:

Code and schematics to follow.

The hidden history of the Monopoly board game

As I’ve been researching the ideas of Jane McGonigal lately, I was interested to find out the real history of the Monopoly board game from Dmytri Kleiner at the weekend. From wikipedia, thanks to the research of Ralph Anspach:

In 1903, the Georgist Lizzie Magie applied for a patent on a game called The Landlord’s Game with the object of showing that rents enriched property owners and impoverished tenants. She knew that some people would find it hard to understand the logic behind the idea, and she thought that if the rent problem and the Georgist solution to it were put into the concrete form of a game, it might be easier to demonstrate. She was granted the patent for the game in January 1904. The Landlord’s Game became one of the first board games to use a “continuous path,” without clearly defined start and end spaces on its board. A copy of Magie’s game, dating from 1903–1904, was discovered for the PBS series History Detectives. This copy featured property groups, organized by letters, later a major feature of Monopoly as published by Parker Brothers.

While the official history on the Hasbro monopoly website picks up the story a little bit later on, and leaves off all details of its original, critical nature:

It was 1934, the height of the Great Depression, when Charles B. Darrow of Germantown, Pennsylvania, showed what he called the MONOPOLY game to the executives at Parker Brothers. Can you believe it, they rejected the game due to “52 design errors”! But Mr. Darrow wasn’t daunted. Like many other Americans, he was unemployed at the time, and the game’s exciting promise of fame and fortune inspired him to produce the game on his own.

Heres an image from Lizzie’s original patent:

post chmod +x art

Back from Groningen, and my mind is full of all sorts of crazy ideas after GOTO10’s mini festival. Although mini in size, the quality of this event was very high.

The day after arriving, Gabor and I did our best to introduce our workshop participants to livecoding and fluxus, from the basics of scheme to some more visually juicy aspects:

The next day the roles were reversed as we took part in workshops lead by some of the previous day’s participants. This was the ‘speed geeking’ event, we had 30 minutes to learn about a new project and contribute something towards it before moving on to the next. We looked at games as explorations of the struggle between supermarkets and open markets, by playing and helping to refine the rules of a boardgame prototype designed by Selena Savic. There was also a creative strategy involving recycling digital trash by Loredana Bontempi called ddump. I recycled a presentation using open office into a glorious piece of digital art. Then Emanuele Bonetti showed us a new way of sharing image references called pickpic which promoted online collaboration. This was a good format for fast presentation of ideas – I think the time was short enough to keep it slightly chaotic and therefore giving it a fresh, informal feeling.

The evening ended with ‘Petcha Gnucha’ mixing up presentations of work from the Piet Zwart Institute with Groningen’s Frank Mohr Institute.

On Saturday there were talks themed around ‘Hocus Pocus’. Martin Howse discussed the concepts surrounding his island2 installation which was being shown in the sign gallery. He took us on a journey through ideas of protected or hidden spaces including stenography, kernel security rings and software design tied to themes of vampirism, pornography, plague and classical concepts of concealment. Dmytri Kleiner gave a talk looking at how political ideologies tend to attach to different network topologies, what it could mean to be a venture communist and why the world needs them. Finally Florian Cramer made a passionate call for digital art to return to the critical, comparing the work of Constant Dullaart (superb name for an artist, can’t be real) with Heath Bunting’s Own, Be Owned, or Remain Invisible.

In the evening it was our turn (IOhannes Zmölnig, no copy paste and I) to livecode for the enjoyment of those equipped with headphones at the placard concert.

I have some footage of my performance, but it’ll have to wait for the moment. I should also mention Breakfast club – which was an approach to try and document discussions about the previous day’s events the morning after. The theory being that you can lure people into a situation involving cameras and microphones by the deployment of freshly baked croissants first thing in the morning. This worked well to get discussion going between the different groups, and is something I’d like to see used more at other events.

chmod +x art

This week it’s finally time for:

At Sign gallery Groningen, the Netherlands. I’m going to be doing a fluxus workshop with Gabor and a scheme bricks placard performance – the first one I’ve tried solo, I think!

chmod +x art The computer as theatre, as writer of love letters, the computer as world, a place for revolution, art as executable. chmod +x art presents artists that turn our ideas, dreams and fantasies about machines and code up side down and show programming as an infinitely intriguing way of creating. Code is a medium. Whether it is used to formulate instructions for a machine, ideas for people or both. The writing of it influences and shapes the creative process of the artist. For that reason, ghost programmers may be left at home. Besides the importance of writing code yourself, it is essential to show that code. Without source, software art remains a magic trick. Do It Yourself and show us your sh*t!