With lessons learned from doingincline decline's massive, static and extremely heavyweight ceiling, we got started on the frames for walls have ears. Unlike the previous wooden model, each frame is now made up of coroplast (corrugated plastic sheets) and styrofoam, making it extremely lightweight. With each frame being able to mount separately on the wall, we are no longer limited to one static frame, but a series of modules behind the massive lycra frame. This means we can experiment with the arrangement and not be restricted to a fixed arrangement, especially when going to install on site. Now the setup is versatile and light.

In addition to building the frames, all modules and our circuit are fully hooked up and ready for programming as you can see in the test below. As of now the balloons are striped naked. Next week with the addition of spandex/ lycra on top; walls have ears ​will really be coming together.

Three MICS setup around the lab. Any speech in the room directly inflated a 9' weather balloon. Sections of speech gets stored in a buffer. When the balloon is in idle mood, buffer is on delay, sounding as if there are lost voices stored in the balloon. As of now when you hit a switch the balloon will deflate spilling the contents of buffer at first from inside the balloon (with speaker setup inside) and slowly ramps to the second speaker directly above where the ballon chamber spill. Please see video below for a bit of clarification. 

Below you can see a short video of our experiment and  the grant application I did, trying to get money to make the Proportional Pressure Controller accessible. Click on full screen to be able to properly view it:

At first I was after simulating the collapse of the wave function based on QBist (quantum bayesianis) theory, where through the subjective act of measurement one instance of the many probable locations of collapse is experienced. This was the conceptual basis of project derived from recent fascination with quantum theories revolving the collapse which has far reaching grip on our understanding of time and space (both micro & macro).

In order to do this I was trying to create an illusion where a participant in the installation, through the act of looking anywhere in the space in front of him/ her, would make a drop of water appear and suspend exactly in that location (as long as he/ she kept the gaze). Technically it would be possible through a series of linear actuators spread throughout space that precisely release x drops of water per second where the viewer is looking (location in space determined through eye-ball tracking). Furthermore the placement of drop in space needs to be tracked so whenever it passed at the same y location where the spectator is looking, the strobe would flash and freeze that frame after frame creating the illusion of suspension (stroboscope technique) and therefore making it seem as if the act of perceiving literally manifests into a material reality, challenging our conception of how physics of our everyday reality works. I am still perusing this idea, but due to complexity of installation and also amounts of nodes (actuators) need to release drops in space, it became obvious that it needs to evolve gradually.

now the actual installation is the first step exploration into that direction...

Instead of tackling the simulation of the collapse i decided to take a step back and focus on relativity. Main focus then became the construction of time, concept of now vs. the actual slice of time in space (never fixed and the same, constantly shifting positions in past and future based on velocity and position in space). Meaning there is no shared moment in time. What we in the moment perceive as now is actually 85ms behind and the further the object is from our location the further it resides in the past. Various relationships as such is visualized in the poster above.

Given 4 channels of control through the dimmer pack i decided to control the frequency and brightness of a series of lights fixed in space. The challenge was to develop a program that would take into consideration Einstein's theory of special relativity and through tracking of movement in space animate these four light according to speed and position of the viewer in space and their relative positions to each node. In a very straightforward way i programmed these relations based on relativity so that the closest node reacted the fastest with the most brightness, and consequently the further away the more delay in time and dimmer the light.

In the video below there are 4 variations of the program. Total of 3 angles that i shot the installation. For every shot i go through 4 variations, each separated by a white flash in the video. Here are the four variations in order:

1. fade:
   the closest you are to a node the brighter it is, others are adjusted according to your distance between them and will fade faster or slower based on velocity.
   
   
2. flash fade:
   same thing as above except the lights blink all the same time based on how fast you are moving. The faster one moves the more their time slows down, so the blink simulates that.
   
   
3. relative flash + reverse ramp fade:
   closest node blinks more instantaneously and further the node the more delay in response and longer the second. I reversed the fade based on how in the experience walking towards the 'now' moment made more sense, rather than the now projected above, where it couldn't be seen.
   
   
4. oscillating relative flash + reverse ramp fade & feedback:
   same as the above but added some noise by reducing threshold in tracking and also created a feedback loop where the presence of the light itself was taken into account, meaning the light emitted from each node would increase and decrease the delay others (feeding back to itself in a loop).
   

Please look at the videos of the main patch and tracking to see it working in real-time.

Tracking patch:

Main max patch (3rd variation):

Setup:

The story telling balloon project is an exploration into making audible activity in space into something tangible, visible and feel-able through air). The project captures spoken word in space and as words are spoken gradually inflates the balloon until it’s full and then deflates, spilling its contents back out in the space. The output scenario is not yet fixed. Possible scenarios include projection of words or playback of words simultaneously as the balloon deflates. Given that the balloon if gone beyond its capacity will explode, the project needs a safe kill switch. Two reliable options came to mind: a pressure sensor inside a chamber or some conductive material that would act as kill switch when the pressure of the balloon strategically placed will make the connection once balloon is full and deflate the balloon. The max patch is on its way but was not included for the prototype.

1. mic setup faraway to bypass feedback loop (in 2nd iteration instead of threshold there will be voice recognition recording any actual conversation where by it is speaking and not just any noise that will activate the valve)
2. amplitude over certain threshold will active pneumatic valve
3. amplitude under certain threshold will shut off pneumatic valve
4. process keeps iterating until balloon is full and this is where the kill switch comes into play
5. when balloon is filled the top of it will touch the bottom of the cabinet where 2 pieces of conductive tape are hanging
6. ballon pushes against the tape and makes a connection which in turn turn on the solenoid for deflation
7. simultaneously the word spoken into the balloon will playback in reverse based on the time of deflation
8. ie. if the total time of inflation (words spoken) is 30seconds and deflation time is 10 seconds then the playback will speed up by 3 times and playback in reverse while the balloon is deflating
9. with voice recognition the words would ideally by scattered onto where the balloons deflate
   

void setup()
{
  pinMode(12, OUTPUT);
  pinMode(2, INPUT);
  pinMode(13, OUTPUT);
  pinMode(4, INPUT);
}
void loop()
{
  if(digitalRead(2) == HIGH)
  {
    digitalWrite(12, HIGH);
    delay(10000);
  }
  else
  {
    digitalWrite(12, LOW);
  }

  if(digitalRead(4) == HIGH)
  {
    digitalWrite(13, HIGH); 
  }
  else
  {
    digitalWrite(13, LOW);
  }
}