Some clocks are functional, some are not very practical. This is an ongoing series of clock experiments.

Each clock is written in Processing and presented here using processing.js.

link: [time 00]

Time is our measure of a constant beat. We use seconds, minutes, hours, days, weeks, months, years, decades, centuries, etc. But what if we measured time against rituals, chores, tasks, stories, and narratives? How can we use our memory, prediction, familiar and unfamiliar narratives to tell time?

As a child, I remember using the length of songs as a way to measure how much time was left during a trip. A song was an appropriate period to easily multiply to get a grasp of any larger measure like the time left until we arrived to our grandmother’s place. The length of a song was also a measure I could digest and understand in an instant.

The first iteration of Cinematic Timepiece consists of 5 video loops playing at 5 different speeds on a single screen. The video is of a person coloring in a large circle on a wall.

The frame furthest to the right is a video loop that completes a cycle in one minute. The video to the left of the minute loop completes its cycle in one hour. The next completes in a day, then a month, then a year.

Through various iterations, we intend to experiment with various narratives and rituals captured in a video loop to be read as measures of time.

The software was written in OpenFrameworks for a single screen to be expanded in the future for multiple screens as a piece of hardware.

Cinematic Timepiece is being developed in collaboration with Taylor Levy.

Download the fullscreen app version [http://drop.io/cinematicTimepiece#]

This display lives at the intersection of digital control and analog output. A matrix of lightbulbs painted with thermochromic paint allows for an image to appear and dissipate analogously to the temperature of each bulb.

The overall effect defies our ordinary understanding of materials and time within technological systems.
In this case, lightbulbs are used for heat and not light. And the refresh rate of an image is constrained to the time it takes for the material of the screen to change temperature.

More on thermochromism here.

Here, we’re using 40 watt bulbs. They take a few seconds to warm up and turn white and a couple minutes to cool down and fade back to black.

Built by Alex Abreu, Taylor Levy, and Che-Wei Wang

Thanks to the dozens and dozens of you who helped make this project possible!

Thermochromic Display from che-wei wang on Vimeo.

Turf Bombing is a location-based war game which rewards and encourages traveling to and learning about different neighborhoods.

Teams are assigned by the zip code of your home address. The goal of each team is to gain as much territory as possible.

Territories are acquired as players plant time bombs at different locations. If the bomb is not diffused by a local team member in time, the bomb will explode and the territory will be turned over to the team that planted the bomb.

There are 4 ranks within each team. General > Lieutenant > Sergeant > Civilians. Ranks are determined by the number of successful bombing missions. Higher ranking players have more power and influence.

This game requires a laptop and a wifi connection. Your laptop’s wifi connection is used to triangulate your position. Turfbombing does not and never will collect or track any personally identifiable information about you.

Turfbombing.com is in open beta. New features area in the works. Built by Che-Wei Please give feedback.

Pixel Sandbox is a live pixel whiteboard. Click on a pixel to change its color and draw something. Together.

An applet reads tilt sensor values from my laptop, posts them to sensorbase.org, then a webpage running ajax reads the sensor values and changes a background color. LIVE.

It’s super slow right now because I can’t figure out how to get sensorbase to only send me the latest value in the dataset, so i have to poll through a ton of values until i reach the end of the set. Last polled id number is written and read from a txt file to keep count. Live tilt values to web color updates every 500 milliseconds now.

Procesing Code:

//slog tilt sensor to sensorbase.org example
//cwwang.com

import processing.net.*;
import sms.*;
int x,y,z;

//Client c;
String data;
//boolean httpRequestDone=true;

void setup()
{
  size(200,200);
  //c = new Client(this, "yoursite.com", 80); // Connect to server on port 80
}

void draw()
{
  int[] vals = Unimotion.getSMSArray();

  int multip=5;
  x=abs(vals[0])*multip;
  y=abs(vals[1])*multip;
  z=abs(vals[2]-255)*multip;
  background(x,y,z);
  println(x + " " + y + " " + z);
  slog();

  delay(500);
}

void slog() {

  //i shouldn't be making a client each time, but i don't know what to do when it craps out
  Client c = new Client(this, "yoursite.com", 80); // Connect to server on port 80
  //slog to tom igoes slogger php script that lives on your server http://www.tigoe.net/pcomp/code/category/PHP/253
  c.write("GET http://yoursite.com/slogger.php?x="+x+"&y="+y+"&z="+z);
  // Identify yourself. must keep the space before HTTP
  c.write(" HTTP/1.1nHOST:yoursite.comnn");
  httpRequestDone=false;

  if (c.available() > 0) { // If there's incoming data from the client...
    data = c.readString(); // ...then grab it and print it
    //ok to send next String
    //httpRequestDone=true;
    println(data);
  }
}

The processing sketch sends GET requests to Tom Igoes slogger php script that lives on my server

Here’s the webpage that reads values from sensorbase.org and displays the color based on the tilt values

<html>
<head>
<style type="text/css">

</style>
    	

		<title>Live Background</title>

		<script type="text/javascript" src="ajax.js"></script>

		
		<script type="text/javascript">

			// A variable to hold the interval id
			var interval = null;	

			// A function to call our AJAX PHP script
			function call_ajax()
			{
				makeHttpRequest('getSlog.php',ajax_return);
			}

			// A function that gets called when ajax returns
			function ajax_return(response)
			{
				document.getElementById('m1').style.backgroundColor='RGB('+response+')';
				document.getElementById("m1").innerHTML = response;

				call_ajax();
			}

			// Setup AJAX function, creates a timeout so that we run something periodically
			function setup_ajax()
			{
				call_ajax();
				// Keeps going...
				//interval = setInterval("call_ajax()",5000);
				// Only happens once..
				//interval = setTimeout("call_ajax()",50);
			}			

			// Register setup_ajax with the onload event of the window (when it is done loading)..
			function addOnLoad()
			{
				if (window.addEventListener)
				{
					window.addEventListener('load', setup_ajax, false);
				}
				else if (window.attachEvent)
				{
					window.attachEvent('onload', setup_ajax);
				}
			}
			addOnLoad();

		</script>

	</head>
	<body>
		<small><div id="m1" style="height:35px; width:100%;">
		checking sensorbase.org...
		</div></small>

	</body>
	</html>

To make the httpRequests you need the ajax.js file. You also need the getSlog.php file below to request the sensorbase.org table values (uses the same sensorbase_config.php file from Tom Igoe’s example. It also uses the sensorbase.wsdl file.

<?php

//get sensorbase user password etc
include "sensorbase_config.php";           

$client = new SoapClient("sensorbase.wsdl", array("trace"=>1,"exceptions"=>0));

$fields = "x,y,z";
$tables = "p_{$projectId}_{$tableName}";
$condition = "x>=0 || x<0";
$delta = 1;
$type = 'csv';
$csv=1;

//total hack to get the last $from table value
//sensorbase doesn't return in descending order?

//get sbid number from counter file
$counterFile = "counter.txt";
$cfr=fopen($counterFile, 'r+') or die("can't open file");
$sCount = fread($cfr, filesize($counterFile));
$sbid=(int)$sCount;
fclose($cfr);

while ($csv!=null)
{
$csv = $client->getData($email, $password, $fields, $tables, $condition, $sbid, $delta, $type);
$sbid=$sbid+1;
}
$sbid=$sbid-2;
$csv = $client->getData($email, $password, $fields, $tables, $condition, $sbid, $delta, $type);

//write to counter file
$cfw = fopen($counterFile, 'w');
fwrite($cfw, $sbid);
fclose($cfw);

echo $csv;
//return $csv;

?>

P.Life is a large scale interactive screen designed for the IAC’s 120′ wide video wall. In the world of P.Life, Ps run around growing, living, and dying, as the landscape continuously changes creating unexpected situations challenging their existence.

Scenario
Screen fades from black to dawn and rising sun along a horizon. The bottom third of the screen shows a section through the landscape cutting through underground pipes, tunnels, reservoirs, etc. Towards the top the surface of the landscape is visible as it fades and blurs into the horizon and sky.
A few Ps wander around the flat landscape. A number appears on screen for participants to send an SMS message to with their name. As participants send SMS messages, more groups of Ps appear on screen representing each SMS and wander across the landscape. The landscape begins to undulate as the audience interacts with the screen, creating of hills, valleys, lakes, and cliffs. Ps running across the landscape fall to their death as the ground beneath their feet drops or ride down the side of a hill like a wave as a hill moves a cross the screen like a wave. Ps that fall to their death slowly sink into the ground and become fertilizer for plant-life, which is then eaten by other families of Ps allowing them to multiply.

Features
SMS listener to make new families of Ps
An array of IP cameras to transmit video for screen interaction
Background subtraction to capture the audience’s gestures
or Open CV with blob detection or face detection to capture the audience’s gestures
or IR sensors to capture the audience’s gestures
or Lasers and photo-resistors to capture the audience’s gestures
Multi-channel audio triggers for events in P-Life based on location
Background elements and landscape speed through sunrise to sunset in a 3 minute sequence
Ps with life like motion as they walk, jump, fall, grow, climb, swim, drowned, die, stumble, flip, run, etc.
pixelated stick figures? large head?
Simple 8bit game-like soundtrack
Various plant-life grown from dead Ps

Precedents
Lemmings, N for Ninja, Funky Forrest, Big Shadow, eBoy, Habbo

Technical Requirements
IP camera array
Mulit-channel audio output

This is a one-off hack to retrofit a genuine Western Electric Dreyfuss Telephone Handset into a full fledged Bluetooth handset. A single button at the center of the mouthpiece controls all the functions (pairing, answering calls, etc.), while a blue and red LED indicator glows from within. The handset recharges via USB and lasts 6 hours in active talk-time and 110 hours in standby mode.

Suunto compass re attached to a custom leather strap.

FeedBack PlayBack is a dynamic film re-editing and viewing system. The users’ physical state determines the visceral quality of scenes displayed; immediate reactions to the scenes feed back to generate a cinematic crescendo or a lull. We use material that is rigorously narrative, formulaic, and plentiful: the action movie series Die Hard, starring Bruce Willis. A narrative sequence key breaks any given Die Hard movie into narrative elements, corresponding clips were collected from each of the Die Hard movies. Individual clips fall into high, medium, and low action/arousal categories. The user is seated, and places his or her hands on a Galvanic Skin Response (GSR) detection panel (GSR readings are the same kind of data collected in lie detector test). After calibration, the movie begins showing, and clips are displayed depending on the user’s level of arousal and engagement. The narrative sequence is maintained, though the clips are pulled from any of the movies.

In FeedBack PlayBack, the cinematic converges with the physical present, exploiting the power of fiction to manipulate and alter our state of being at the most basic, primal level. We attempt to synchronize the media and viewer– whether towards a static loop or a explosive climax.

Special thanks to Matt Parker, Die Hard movie expert consultant.

Feedbak Playback is by Zannah Marsh and Che-Wei Wang