Building Lumens

Often, it isn’t until after you build something that you realize all the ways in which it could have been made better. After a few days of living with Lumens we’ve decided to go back and make improvements where we can. This installation is going to be up for 4 months and none of us want it to become a full time job maintaining things. One of the things that became obvious to us durring the build process, but we just didn’t have time to deal with it then, was the need for reset switches on the outside of the box. The boxes were built to house all the electronics safely, but with the circuit board mounted inside it’s hard to access and difficult to reprogram if you can’t easily reset it. While we were building, and even up to about 30 minutes before the opening, we were constantly updating the program on all the boxes on a regular basis.

Another thing we’ve seen is that from time to time the microcontrollers seem to lock up. They stop responding to input from the proximity sensor and ignore serial commands coming from the computer. A simple reset gets them going on their way again. Each circuit board has a small reset mounted directly on it. If in the process of resetting, you bump something else on the board, you’re just making more work for yourself. Most things are soldered in, but a few things, like the fan and the proximity sensor, are socket mounted. When these things get knocked off, it’s a really big pain to get them back in place. So, an external reset switch is the answer.

Lumens opened tonight at Greylock Arts in Adams, at the MCLA Gallery 51 Annex in North Adams, and on Turbulence.org. The above photo is courtesy of Ryan Hutton, The North Adams Transcript. Ryan even shot a great video of the opening and put it on YouTube. Thanks Ryan!

The opening was a huge success, everything worked! But it was looking pretty bad right up until we opened the doors. Five minutes before both galleries went down because I stupidly chose to reset something. Lesson learned, don’t make any major changes five minutes before showtime. The people of Adams where lined up outside the door, waiting to see the lamps light up, and nothing was working. I was sick to my stomach.

Days before the opening I had setup Apple Remote Desktop in both spaces so I could troubleshoot and fix bugs no matter where I might be. ARD is great, it’s a fantastic way to be in two places at once. But then I needed to reset the DSL modem in the North Adams space and ARD stopped working. Things were so frantic in the days leading up to the opening that I never had a chance to fix it. All I needed to do was get the port forwarding working correctly, and I just never had the time.

And there I was, five minutes before the opening, in desperate need to be in two places at once. So I got in the car and drove the 5 miles back and forth between both spaces all night long, troubleshooting, and keeping things happy. I broke my PowerBook’s (Yes, I said PowerBook, antique, I know.) power port in the process, only making things worse. Now my laptop wouldn’t charge, and it was loosing charge fast. And because I had been using ARD I didn’t think to keep spare displays, keyboards, and mice in both spaces in case of emergency, should I need to administer a computer the old fashioned way. Another lesson learned, every computer needs a mouse, keyboard, and display, even if you plan to administer it remotely.

It’s truly amazing that Lumens worked at all, given that we never had a chance to fully test it. The only time all three spaces were online simultaneously was in that moment, five minutes before the opening, when everything stopped working. But when it came back up, it worked all night, without a hitch. Enjoy photos of the opening below.

Fellow Lumens artist Ven Voisey explains Lumens to the B-HIP interns.

The MCLA Gallery 51 Annex was packed in North Adams.

People standing outside the MCLA Gallery 51 Annex in North Adams.

Many artists contributed lamps. Marianne R. Petit’s lamp was made from a back brace she had to wear as a child.

North Adams Transcript reporter Ryan Hutton navigates the lamps at Greylock Arts in Adams.

Lumens project manager Marianne R. Petit speaks with the B-HIP interns about the many challenges involved in building Lumens.

A B-HIP intern browses the lamps in Lumens on Turbulence from the MCLA shuttle bus. Thanks to Wireless Zone of North Adams for providing wireless access to our laptops.

Visitors browse the lamps at Greylock Arts in Adams.

The working title for this project has always been Ripple, and the vision that we all have had for this, has always been that the lamps should respond to people as they move through the space, as if they were wading in a pool of water. We didn’t want the light to look stiff or programmatic at all. Achieving this kind of effect has always required that we get a certain density of lamps in each space. I also assumed that it would require a lot of fussing with dimmer code in Arduino, but now that we’ve assigned lamps to every cluster and we can finally see the effect of lamps fading on and off through the space, I can honestly say that this water-like effect has more to do with the somewhat random placement of lamps around the room than with any subroutine.

The biggest problem that we are having is that the proximity sensors are getting false readings as lamps within their field of vision turn on and off. The entire room begins to oscillate in this increasingly chaotic fashion. It’s really hard to get any kind of meaning out of ones actions within the space. None of us are very happy with the effect because it just seems totally random.

Just a few hours before the opening I discovered that the above was the cause of our problems because I had mis-set the threshold variable for the sensor on the Arduino. This variable defines the point at which the microcontroller should turn the bulbs on. The sensor is constantly sending a voltage to the Arduino’s input pin. This voltage is always fluctuating up and down slightly as the sensor takes in it’s surroundings. We have been using Sharp Infra-Red Proximity Sensors, specifically the 2Y0A02, which has a range of up to 150 cm, 60 inches, or 5 feet, depending on which unit of measure you prefer. When the sensor is tripped by someone walking past or up to it the voltage goes up and the Arduino can detect this. These sensors can also indicate the distance of a subject from the sensor through voltage fluctuation.

We considered using several other types of sensors including ultrasonic range finders, force sensing resistors, and even video tracking, but ultimately went with the IR proximity sensors. To make working with these IR sensors easy you’ll want to pick up some of these cables as well.

Otherwise the dimming code is quite simple (Note the following code does not use sockets to communicate from one space to another. It has been simplified to only show dimming.):

// i've defined my sensor pin as a constant.
#define sensorPin 0

// the threshold var. consider this a starting point. every sensor is different.
int threshold = 250;
// the voltage on the input pin is stored in this variable.
int sensorValue = 0;
// used for dimming.
int lumenValue = 0;

// this is called on startup
void setup() {

    // the atmega168 has 6 input pins numbered 0 - 5. i chose 0 for my input pin. see the sensorPin constant defined at top.
    pinMode(sensorPin, INPUT);
    // the atmega168 has 6 pwm output pins numbered 3, 5, 6, 9, 10, and 11. we're going to use all of them.
    pinMode(3, OUTPUT);
    pinMode(5, OUTPUT);
    pinMode(6, OUTPUT);
    pinMode(9, OUTPUT);
    pinMode(10, OUTPUT);
    pinMode(11, OUTPUT);
}

// this is called repeatedly as long as the microcontroller is on.
void loop() {
    // analogRead is a built in method that reads a given pin.
    sensorValue = analogRead(sensorPin);
    // if the sensor value is above or equel to the threshold.
    if (sensorValue >= threshold) {
        // turn on all the lamps.
        // analogWrite is a built in method that writes a pwm wave to the given pin.
        // paramter 1 is the pin number. parameter 2 is the voltage value (between 0 and 255).
        analogWrite(3, 255);
        // so that all 6 lights come on in sequence instead of all at once use the built in delay method.
        // the parameter is given in milliseconds.
        delay(100);
        analogWrite(5, 255);
        delay(100);
        analogWrite(6, 255);
        delay(100);
        analogWrite(9, 255);
        delay(100);
        analogWrite(10, 255);
        delay(100);

        analogWrite(11, 255);
        delay(100);
        // set lumenValue to 0 every time the lights are turned on to full.
        lumenValue = 0;
    } else {
        // if lumenValue is below 255 (the max value for analogWrite).
        if (lumenValue<256) {
            // subtract lumenValue (ever incrementing, see below) from 255.
            analogWrite(3, 255-lumenValue);
            analogWrite(5, 255-lumenValue);
            analogWrite(6, 255-lumenValue);
            analogWrite(9, 255-lumenValue);
            analogWrite(10, 255-lumenValue);
            analogWrite(11, 255-lumenValue);
            // this delay makes the fade nice and sexy. not to short, not too long.
            delay(5);
            // increment lumenValue.
            lumenValue++;
        }
    }
}

The simple truth is there wouldn’t be a Lumens without the help of Larry Alice. Above, Larry is helping me debug a Lumens circuit board. He has given me advice every step of the way, and lately he has been giving up entire days of his time to come and help us debug stuff. Larry is a local artist with an electronics and programming background. Without his help and guidance I’m convinced that none of this would be working. And I’d probably be curled up in a corner crying right now.

Our friend John Schimmel came up this weekend on a rescue mission. We have been falling farther and farther behind on our schedule, and with the opening looming John was generous enough to offer his time, expertise, and sense of humor to us this weekend. John is a resident researcher at NYU’s Interactive Telecommunications Program.

John’s work has been an inspiration to Lumens. One of his projects, Fireflies, are networked nightlights that consist of LEDs “caught” in mason jars like real fireflies. Tapping on the lid allows you to send messages to others. Fireflies were part of the LEDs Are Pretty exhibit at Greylock Arts last fall.

He made numerous suggestions and improvements to the Lumens code, and also pointed out that we were using the wrong proximity sensors. The ones we had ordered had a range much shorter than what we needed. That explains why things weren’t working as well as we had hoped. Thanks John!

It’s important to note that Lumens is part of an effort called DownStreetArt spearheaded by Jonathan Secor of MCLA Gallery 51 to bring visitors to Main Street in North Adams. Jonathan has been working very hard to open four new galleries on Main Street this summer, and to promote the downtown area to tourists attending MASSMoCA. Three of the new galleries opened today. Lumens will open a bit later on July 10th. In addition to Lumens, DownStreetArt features Maya III by Jarvis Rockwell, The North Adams Artists coOp Gallery, and Primary Secondary Volumes 1 and 2. Gallery 51 also opened an exhibition of artist Rich Remsberg’s work tonight titled Terms of Surrender.

Main Street in North Adams during the DownStreetArt Opening.

Jarvis Rockwell’s Maya III, a giant toy pyramid.

The North Adams Artists coOp Gallery features the work of over 16 local artists.

Jonathan Secor, Mark Mulherin, and Ana Maria Secor stand in front of Mark Mulherin’s The Grandfather Paradox on Main Street in North Adams.

It’s been a long time coming, but this weekend, we started building out Lumens. We setup an assembly line and just started cranking out circuit boards. We’ve tested one of them, and it seems to work. I hope the rest do. We plan to build out 36 boards total, 16 for each space, with 4 spares. Parts have been coming in from every direction. Our primary suppliers have been Digi-Key, SparkFun, Trossen Robotics, and of course the local Radio Shack.

B-HIP intern Abbi Hermosa started work today at Greylock Arts. Abbi comes to us just in time as we are about a month away from opening Lumens. We’re going to need all the hands we can get. We’ve asked Abbi to blog about her experience in the Berkshires this summer. You can follow her blog here.

Above is a circuit diagram for what I hope to build. Its basically just this PComp tutorial modified to use all six PWM pins on the Arduino board. Quite honestly I don’t know what I’m doing here. So use this at your own risk.

We’ve put off some of the electronic challenges for too long now. Some decisions have to be made. I’ll be the first to admit that I know next to nothing about electricity. So, take everything I say with a grain of salt. And certainly don’t get yourself killed following my blog. I started by reading as much as I could about light bulbs and in particular dimming light bulbs here, here, here, and here. I found this cool project by SeBsZ that was inspirational, but because it was designed for 230V AC @ 50hz, it wasn’t as useful to me as it might be to someone in Europe. The U.S. uses 110V AC @ 60hz. For a breakdown of who uses what and why read this.

Electricity comes into our homes as Alternating Current or AC at 110V or higher, and household light bulbs are typically designed to operate from this high voltage. AC power distribution was pioneered by Nikola Tesla and pushed into the mainstream by George Westinghouse. This method was rapidly adopted worldwide because it was superior to Thomas Edison’s DC distribution methods. However, the Arduino, and most personal electronic devices for that matter, use Direct Current or DC at a much lower voltage, often between 3V and 20V.

AC and DC are generally not interchangeable, one exception being light bulbs. Light bulbs only care about the voltage they are being given, not the type of current. This got me thinking. 12V light bulbs are easy to come by at hardware stores and online, here, for instance. They are typically used in automotive and boating applications where the power is coming from a battery. If I’m understanding all this correctly, an Arduino could potentially control and dim low voltage light bulbs directly from it’s PWM pins. This might be just the ticket for us. I’m going to get my hands on some low voltage bulbs and do some testing.

At the heart of all this is a need to communicate between several different platforms. Some of these platforms, Flash/ActionScript for instance, can communicate just fine, on it’s own, with a PHP script running on a web server. A microcontroller running locally however, and connected to a computer via USB, needs a little helping hand, or proxy. This is because the microcontroller is communicating serially and the web server is listening over a socket. Something needs to bridge this gap. I chose REALBasic for this because it’s an environment that I’m fairly comfortable with. I know a lot of “real” programmers look down their noses at REALBasic, but I think it can’t be beaten for quick and easy, down and dirty desktop application development. Here’s a great link with a lot of useful information about sockets in REALBasic.

Below are some of the highlights from my REALBasic serial to socket proxy application for the two or three people who may be interested:

// the window1 built in Open method
Sub Open()
// setup some variables
dim x as integer
dim serialCount as integer
dim lumenPorts() as serial
dim result as variant
// lumenSocket is my custom socket class
// it is a sub-class of the built in TCPSocket class
// the socket handles communication between the local server and the remote server
lumenSocket.Address = "yourdomain.com"
lumenSocket.Port = 1024
lumenSocket.Connect()
// get the number of available serial ports
serialCount = system.serialportcount
// if there are serial ports available
if serialCount > 0 then
	// count through available serial ports
	for x = 0 to SerialPortCount - 1
		// match only serial ports within a certain name range
		// all of the usb adapters i got start with A4 or A1
		if (system.serialport(x).Name.InStr(0, "A4") > 0 or system.serialport(x).Name.InStr(0, "A1") > 0) then
			// lumenSerial is my custom serial class
			// it is a sub-class of the built in Serial class
			// communication between the local lamps and the local server happen over serial
			lumenPorts.append new lumenSerial
			// set all the properties
			lumenPorts(ubound(lumenPorts)).Baud = 8
        	lumenPorts(ubound(lumenPorts)).Bits = 3
        	lumenPorts(ubound(lumenPorts)).Parity = 0
			lumenPorts(ubound(lumenPorts)).Stop = 0
			lumenPorts(ubound(lumenPorts)).SerialPort = system.serialport(x)
			// try to open the port
			result = lumenPorts(ubound(lumenPorts)).Open
		end
	next
	dim portCount as Variant
    portCount = ubound(lumenPorts)
	// alert if serial ports are missing
	// i'm looking for 14 serial ports total
	if UBound(lumenPorts) < 0 then
		MsgBox "No Serial Ports Were Found!"
    elseif UBound(lumenPorts) < 13 then
      MsgBox "Some Serial Ports Appear To Be Missing!"
    end if
end if

// the lumenSocket built in DataAvailable method
Sub DataAvailable()
	// setup some variables
	dim command as String
	dim i as integer
	// read the socket in
	command = me.ReadAll()
	// commandIsValid is a custom global method used to validate a command
	// it returns true or false
	if commandIsValid(command) = true then
		// loop through all the serial ports
		for i = 0 to ubound(lumenPorts)
			// write to each serial port what came in over the socket
			lumenPorts(i).Write(command)
		next
	end if

// the lumenSerial built in DataAvailable method
Sub DataAvailable()
	// setup some variables
	dim command as string
	dim i as integer
	// read the serial in
	command = me.readAll()
	// lumenNetwork is a global boolean variable used to tell the local app if the server is up or down
	if lumenNetwork = true then
 	   // if the network is up write the command to the socket
 	   // append a Char(0) to signify the end of a command to ActionScript's built in XMLSocket class
 	   // the PHP socket server script then verifies this command and if valid sends it to all connected clients
		lumenSocet.Write(command+Chr(0))
	else
		// if the network is down feedback on yourself
		// loop through all the serial ports
		for i = 0 to ubound(lumenPorts)
			// commandIsValid is a custom global method used to validate a command
			// it returns true or false
			if commandIsValid(command) = true then
				// the the command was valid so send it to each lumenPort
				lumenPorts(i).Write(command+Chr(0))
			else
        		// the command is not valid
        		// do nothing
      		end if
    	next
	end if

It’s been a long time since I’ve messed with electronics, and when I did it was only for a brief time during my first semester at ITP. Back then we used the BX24, pictured below.

My PComp final project was a radio controlled car built with the BX24. I had fun with it, but that wasn’t really my focus at the time so I moved on to the things that interested me. It didn’t help that I was a pretty awful programmer at the time. I still think I am, but somehow I just keep hacking my way through problems until things finally start to work.

I kept hoping that at some point I’d find the time and patience to get back into electronics post grad-school, but it just never happened. There was always some other, usually pointless, project consuming all my time. I am going to use this project as an excuse to get back into electronics though.

Tom was generous enough to lend us some Arduino boards to play with when we saw him last. If you are looking to get started this is a great starter kit. I downloaded the software and used this as a starting point. It’s surprisingly easy to get going. Much easier than I remember the BX24 being. The first thing i did was make an LED blink, pretty simple, but exciting to see it working. There is a lot to learn and not much time. Our opening date has been set for July 10th.

My next experiment was to see if I could get a proximity sensor to control the on/off state of an LED. The following is the resulting code:

// define the pins to be used on the microcontroller
#define sensorPin 0
#define ledPin 13

// define the initial value of the sensor variable
int sensorValue = 0;
// compare the sensorValue to this variable to determine if something is in front of the sensor
int threshold = 200;

void setup() {
	// set the led pin to output
	pinMode(ledPin, OUTPUT);
	// open the serial port
	Serial.begin(9600);
}

void loop() {
	// read the sensor
	sensorValue = analogRead(sensorPin);
	// print the sensor value
	Serial.println(sensorValue, DEC);
	// set the led on or off based on the sensor
	if (sensorValue >= threshold) {
		analogWrite(ledPin, 255);
	} else {
		analogWrite(ledPin, 0);
	}
}

Sean, Ven and myself have been meeting pretty regularly since November to discuss what it is we should do either as a group or individually. Some of the ideas that have been discussed include: A virtual tug of war, rippling street lamps as people walk by, a networked dance floor, as well as a high school football game between North Adams and Adams where the teams would swap jerseys.

While doing some research into the dance floor idea I came across this really cool MIT student project called the 1E Disco Dance Floor. It’s a 128 square foot 1,500 LED dance floor. Be sure to check out the video. It’s totally crazy!

We haven’t really settled on anything yet. We just keep bouncing ideas off of each other. Hopefully something will stick.

This morning we had a brainstorming session with Tom Igoe. Tom is a colleague of Marianne Petit (my partner in crime at Greylock Arts), at NYU’s Interactive Telecommunications Program. Tom is the area head for what’s called Physical Computing. PComp is basically a way of sensing the physical world through the use of sensors, and using microcontrollers, computers, and software to interpret this information, ultimately to control other aspects of the physical world through the use of lights, displays, motors, and other feedback mechanisms.

Tom is a really special guy, and we are so lucky to have him as a consultant for this project, whatever direction it takes.