For this final project, I looked at different ways to conduct electricity which might mean the form of a lighting object could change. A major challenge in creating lighting is hiding wiring and traditionally the form has also centered around the source of light. As LEDs are changing that I wanted to think about how the form might be able to change.

I went to Material Connexion where I saw many kinds of conductive fabrics and metallic composite materials. I had thought about the possibility of weaving LEDs into a mesh but given then need for a positive and negative lead this seemed to be not as possible.

I also did research online into different types of conductivity and other materials that might be suitable, and one of the things I found that I thought feasible was a salt solution.

If I was going to have exposed wiring a consideration was also safety, but I didn’t find any conclusive answer in my research about what might be a safe level of current or voltage exposure.

All of these considerations led me to a couple of things in my designs, such as setting up the LEDs in parallel to allow low voltage and multiple LEDs, as well as to deploy a positive and negative “lead”.

In one design I set up two boxes with a concentrated salt water solution (4 tsps in 150ml), one being the positive side and one the negative. I found at lower concentrations the resistance was much more variable and at this concentration it started to become very consistent at around 1 ohm. The salt water was supposed to act as both conductive material and diffuser for the light.

The LEDs I used were 3.3V/25mA forward current. However with 5 of them, one 3V battery didn’t supply sufficient power. 2 3V batteries created a nice amount of light and it didn’t seem to require further resistance, even though I thought the salt water may not create enough.

It did actually create a nice light, but I had a lot of issues making the containers watertight so they couldn’t be stood up as originally envisaged.

The second design I created was based on a more standard conductive material but I used it in a different form. I knitted and crocheted 28 gauge silver plated wire and inserted it into an acrylic box which served as a frame and light diffuser. In one case I used one 3.5V very high brightness LED and 2 3V batteries, so I also wove a resistor into the knitted conductive mesh.

In the other case I used 3 3.3V medium high brightness LEDs with one 3V battery.

Ordinarily this kind of case would be difficult to use without having an extra hidden compartment for the wiring and sources of electricity.

For both of these I created a lid that snapped on and off with a magnet, or could be rotated, and in doing so, was the switch for the light.

8 November

• material research – conductive materials, materials for diodes

15 November

• further material research – relationship of materials to circuits
• develop concept of final form

22 November

• in-class progress review
• drawings, mock-ups of final proposal
• material choices to explore further

29 November

• research conclusions finalized

4 December

• working towards final presentation
• refining fabrication, testing

13 December

• final presentation

For this project, I created a tail that clips around your waist, which is controlled by your head movement. The head movement is detected by a dual-axis accelerometer and based on the readings, it directs a servo motor to move which in turns wags your tail.

Fabrication was a real challenge for this project. Some of the issues I encountered were being able to hide the arduino and battery (they sit under a headband and are hidden at the front by a “fur” trim and ears) and hiding wires from the controller and accelerometer to the servo motor, which was located at the back of the belt, just below the waist. These wires needed to allow for head movement without coming apart – an improvement to this project would be elasticized connecting wires.

I also tried a number of iterations for the tail, initially beginning with a segmented wooden snake which I was going to wrap in fur. The snake turned out to be too heavy for the servo motor to operate reliably, and in the end the fur alone attached to a wooden lever was the most successful and best mimicked a tail wagging.

As far as the code goes, I took an existing script for the accelerometer (0-1000) and translated its values to the servo (0-179). I set a baseline of “upright” where the tail didn’t move between -200 and 200 in both directions, and then set conditions for how the tail would move based on the further movement than that. Sometimes the movement of the tail is proportional to the degree of deviation from upright and sometimes it moves to a predetermined position.

/*
Memsic2125

Read the Memsic 2125 two-axis accelerometer. Converts the
pulses output by the 2125 into milli-g’s (1/1000 of earth’s
gravity) and prints them over the serial connection to the
computer.

The circuit:
* X output of accelerometer to digital pin 2
* Y output of accelerometer to digital pin 3
* +V of accelerometer to +5V
* GND of accelerometer to ground

http://www.arduino.cc/en/Tutorial/Memsic2125

created 6 Nov 2008
by David A. Mellis
modified 30 Aug 2011
by Tom Igoe

This example code is in the public domain.

*/
#include <Servo.h>

// these constants won’t change:
const int xPin = 2; // X output of the accelerometer
const int yPin = 6; // Y output of the accelerometer
int valX;
int valY;
int i;// variable to read the value from the accelerometer to the servo
Servo myservo;

void setup() {
// initialize serial communications:
Serial.begin(9600);
// initialize the pins connected to the accelerometer
// as inputs:
pinMode(xPin, INPUT);
pinMode(yPin, INPUT);
myservo.attach(9);
}

void loop() {
// variables to read the pulse widths:
int pulseX, pulseY;
// variables to contain the resulting accelerations
int accelerationX, accelerationY;

// read pulse from x- and y-axes:
pulseX = pulseIn(xPin,HIGH);
pulseY = pulseIn(yPin,HIGH);

// convert the pulse width into acceleration
// accelerationX and accelerationY are in milli-g’s:
// earth’s gravity is 1000 milli-g’s, or 1g.
accelerationX = ((pulseX / 10) – 500) * 8;
accelerationY = ((pulseY / 10) – 500) * 8;

valX = map(accelerationX, -1000, 1000, 0, 179);
valY = map(accelerationX, -1000, 1000, 0, 179);
//if (accelerationX > accelerationY && accelerationX > 50) {
if (accelerationX > 200 || accelerationY < -200) {
myservo.write(valX);
delay(100);
myservo.write(-valX);
delay(100);
}
if (accelerationX <= -200) {
myservo.write(valX);
delay(60);
}

if (accelerationY >=200) {
myservo.write(179);
delay(180);
myservo.write(-179);
delay(180);
}
// }
//else {
//myservo.write(valY);
//delay(30);
// myservo.write(-valY);
//delay(30);
// }
// print the acceleration
Serial.print(accelerationX);
// print a tab character:
Serial.print(“\t”);
Serial.print(accelerationY);
Serial.println();

delay(100);
}

The idea for this project was to make a small desk lamp where the amount of light was controlled by opening the top of the light using a potentiometer. The LEDs come on when the angle of the servo motor goes past 1 degree and the top opens up to the limit of the servo motor (180 degrees). At this point the light is fully exposed and shining up:

The major challenge with the enclosure was to anchor the motor sufficiently so that it would rotate the top rather than rotating itself.

Code:

// Controlling a servo position using a potentiometer (variable resistor)
// and using the same input to turn on an LED once the angle of the servo goes past 1 degree
// Credit to Michal Rinott <http://people.interaction-ivrea.it/m.rinott> for servo position code

#include <Servo.h>

Servo myservo; // create servo object to control a servo

int potpin = 0; // analog pin used to connect the potentiometer
int val; // variable to read the value from the analog pin
int ledPin = 13; // variable to write to the LED

void setup()
{
myservo.attach(9); // attaches the servo on pin 9 to the servo object
pinMode(ledPin, OUTPUT); //
}

void loop()
{
val = analogRead(potpin); // reads the value of the potentiometer (value between 0 and 1023)
val = map(val, 0, 1023, 0, 179); // scale it to use it with the servo (value between 0 and 180)
myservo.write(val); // sets the servo position according to the scaled value
delay(15); // waits for the servo to get there
if (val>6) {
digitalWrite(ledPin, HIGH);
}
else {
digitalWrite(ledPin, LOW);
}
}

// Controlling a servo position using a potentiometer (variable resistor)
// and using the same input to turn on an LED once the angle of the servo goes past 1 degree
// Credit to Michal Rinott <http://people.interaction-ivrea.it/m.rinott> for servo position code

#include <Servo.h>

Servo myservo; // create servo object to control a servo

int potpin = 0; // analog pin used to connect the potentiometer
int val; // variable to read the value from the analog pin
int ledPin = 13; // variable to write to the LED

void setup()
{
myservo.attach(9); // attaches the servo on pin 9 to the servo object
pinMode(ledPin, OUTPUT); //
}

void loop()
{
val = analogRead(potpin); // reads the value of the potentiometer (value between 0 and 1023)
val = map(val, 0, 1023, 0, 179); // scale it to use it with the servo (value between 0 and 180)
myservo.write(val); // sets the servo position according to the scaled value
delay(15); // waits for the servo to get there
if (val>6) {
digitalWrite(ledPin, HIGH);
}
else {
digitalWrite(ledPin, LOW);
}
}

This is the animation I created for my LOL shield:

And this is the array I used in the code:

{1, 0, 1, 0, 1, 0, 1, 0, 1} ,
{0, 3, 0, 3, 0, 3, 0, 3, 0},
{7, 0, 7, 0, 7, 0, 7, 0, 7},
{0, 15, 0, 15, 0, 15, 0, 15, 0},
{31, 0, 31, 0, 31, 0, 31, 0, 31},
{0, 63, 0, 63, 0, 63, 0, 63, 0},
{127, 0, 127, 0, 127, 0, 127, 0, 127},
{0, 255, 0, 255, 0, 255, 0, 255, 0},
{511, 0, 511, 0, 511, 0, 511, 0, 511},
{0, 1023, 0, 1023, 0, 1023, 0, 1023, 0},
{2047, 0, 2047, 0, 2047, 0, 2047, 0, 2047},
{0, 4095, 0, 4095, 0, 4095, 0, 4095, 0},
{8191, 0, 8191, 0, 8191, 0, 8191, 0, 8191},
{0, 16383, 0, 16383, 0, 16383, 0, 16383, 0},
{16382, 0, 16382, 0, 16382, 0, 16382, 0, 16382},
{0, 16380, 0, 16380, 0, 16380, 0, 16380, 0},
{16376, 0, 16376, 0, 16376, 0, 16376, 0, 16376},
{0, 16368, 0, 16368, 0, 16368, 0, 16368, 0},
{16352, 0, 16352, 0, 16352, 0, 16352, 0, 16352},
{0, 16320, 0, 16320, 0, 16320, 0, 16320, 0},
{16526, 0, 16256, 0, 16256, 0, 16256, 0, 16256},
{0, 16128, 0, 16128, 0, 16128, 0, 16128, 0},
{15872, 0, 15872, 0, 15872, 0, 15872, 0, 15872},
{0, 15360, 0, 15360, 0, 15360, 0, 15360, 0},
{14336, 0, 14336, 0, 14336, 0, 14336, 0, 14336},
{0, 12288, 0, 12288, 0, 12288, 0, 12288, 0},
{8192, 0, 8192, 0, 8192, 0, 8192, 0, 8192},
{0, 0, 0, 0, 0, 0, 0, 0, 0},
{18000}
};

Three projects I found interesting at MakerFaire:

I am interested in folding and origami and this project combined that with the ability to mechanically unfold and fold back flat again:

This project combined sound and light. Each acrylic tube had a sensor on top and correlated to a note and lighting effect. The sound quality was not bad and the lighting through the material used created a nice effect. It was only 7 notes though so it would be nice to be expanded to really create music:

This was a modular set of lights that you could pin together as you pleased. There was a base providing initial charge and I think they could be removed from that base and had some battery storage ability. I didn’t think the fabrication or aesthetic component was of a really high standard but it’s an interesting idea:

My project for this week is a night light/music box for a child. When you switch it on, it plays a lullaby and the light comes on. As the melody plays the light dims until the tune ends and the light is off.

http://www.youtube.com/watch?v=YTbKSK98DwY

I think the code could be a bit cleaner with the fading but I’m not sure how. Perhaps one way would be to create a variable that tracks time and then a function for the analog write which relates the brightness of the light to the time elapsed as a proportion of the total time.

/* lullaby_switch_dimming
*
* Each time the input pin goes from LOW to HIGH (e.g. because of a push-button
* press), the melody begins and the light goes on. As the melody progresses the
* light fades until it goes completely off with the end of the melody.
*
*/
#include “pitches.h”

int inPin = 2; // the number of the input pin
int outPinled = 9; // the number of the output pin for the LED
int outPinspeaker = 7; // the number of the output pin for the speaker
int brightness = 255;
int fadeAmount = 5;

void setup() {
pinMode (inPin, INPUT);
pinMode (outPinled, OUTPUT);
pinMode (outPinspeaker, OUTPUT);
}

void loop() {
reading = digitalRead(inPin);

if (reading == HIGH) {
analogWrite(outPinled, 255);
tone(outPinspeaker, NOTE_E5);
delay(200);
analogWrite(outPinled, 245);
noTone(outPinspeaker);
delay(50);
analogWrite(outPinled, 235);
tone(outPinspeaker, NOTE_E5);
delay(250);
analogWrite(outPinled, 205);
tone(outPinspeaker, NOTE_G5);
delay(1000);
analogWrite(outPinled, 195);
tone(outPinspeaker, NOTE_E5);
delay(250);
analogWrite(outPinled, 185);
noTone(outPinspeaker);
delay(50);
analogWrite(outPinled, 175);
tone(outPinspeaker, NOTE_E5);
delay(250);
analogWrite(outPinled, 165);
tone(outPinspeaker, NOTE_G5);
delay(1000);
analogWrite(outPinled, 160);
tone(outPinspeaker, NOTE_E5);
delay(250);
analogWrite(outPinled, 155);
tone(outPinspeaker, NOTE_G5);
delay(250);
analogWrite(outPinled, 150);
tone(outPinspeaker, NOTE_C6);
delay(500);
analogWrite(outPinled, 145);
tone(outPinspeaker, NOTE_B5);
delay(750);
analogWrite(outPinled, 140);
tone(outPinspeaker, NOTE_A5);
delay(200);
analogWrite(outPinled, 135);
noTone(outPinspeaker);
delay(50);
analogWrite(outPinled, 130);
tone(outPinspeaker, NOTE_A5);
delay(500);
analogWrite(outPinled, 125);
tone(outPinspeaker, NOTE_G5);
delay(500);
analogWrite(outPinled, 120);
tone(outPinspeaker, NOTE_D5);
delay(250);
analogWrite(outPinled, 116);
tone(outPinspeaker, NOTE_E5);
delay(250);
analogWrite(outPinled, 112);
tone(outPinspeaker, NOTE_F5);
delay(500);
analogWrite(outPinled, 108);
tone(outPinspeaker, NOTE_D5);
delay(450);
analogWrite(outPinled, 104);
noTone(outPinspeaker);
delay(50);
analogWrite(outPinled, 100);
tone(outPinspeaker, NOTE_D5);
delay(250);
analogWrite(outPinled, 96);
tone(outPinspeaker, NOTE_E5);
delay(250);
analogWrite(outPinled, 92);
tone(outPinspeaker, NOTE_F5);
delay(1000);
analogWrite(outPinled, 88);
tone(outPinspeaker, NOTE_D5);
delay(250);
analogWrite(outPinled, 84);
tone(outPinspeaker, NOTE_F5);
delay(250);
analogWrite(outPinled, 80);
tone(outPinspeaker, NOTE_B5);
delay(250);
analogWrite(outPinled, 76);
tone(outPinspeaker, NOTE_A5);
delay(250);
analogWrite(outPinled, 72);
tone(outPinspeaker, NOTE_G5);
delay(500);
analogWrite(outPinled, 68);
tone(outPinspeaker, NOTE_B5);
delay(500);
analogWrite(outPinled, 64);
tone(outPinspeaker, NOTE_C6);
delay(950);
analogWrite(outPinled, 60);
noTone(outPinspeaker);
delay(50);
analogWrite(outPinled, 57);
tone(outPinspeaker, NOTE_C5);
delay(200);
analogWrite(outPinled, 54);
noTone(outPinspeaker);
delay(50);
analogWrite(outPinled, 51);
tone(outPinspeaker, NOTE_C5);
delay(250);
analogWrite(outPinled, 48);
tone(outPinspeaker, NOTE_C6);
delay(1000);
analogWrite(outPinled, 45);
tone(outPinspeaker, NOTE_A5);
delay(250);
analogWrite(outPinled, 42);
tone(outPinspeaker, NOTE_F5);
delay(250);
analogWrite(outPinled, 39);
tone(outPinspeaker, NOTE_G5);
delay(1000);
analogWrite(outPinled, 36);
tone(outPinspeaker, NOTE_E5);
delay(250);
analogWrite(outPinled, 33);
tone(outPinspeaker, NOTE_C5);
delay(250);
analogWrite(outPinled, 30);
tone(outPinspeaker, NOTE_F5);
delay(500);
analogWrite(outPinled, 28);
tone(outPinspeaker, NOTE_G5);
delay(500);
analogWrite(outPinled, 26);
tone(outPinspeaker, NOTE_A5);
delay(500);
analogWrite(outPinled, 24);
tone(outPinspeaker, NOTE_E5);
delay(500);
analogWrite(outPinled, 22);
tone(outPinspeaker, NOTE_G5);
delay(500);
analogWrite(outPinled, 20);
tone(outPinspeaker, NOTE_C5);
delay(200);
analogWrite(outPinled, 18);
noTone(outPinspeaker);
delay(50);
analogWrite(outPinled, 16);
tone(outPinspeaker, NOTE_C5);
delay(250);
analogWrite(outPinled, 14);
tone(outPinspeaker, NOTE_C6);
delay(1000);
analogWrite(outPinled, 12);
tone(outPinspeaker, NOTE_A5);
delay(250);
analogWrite(outPinled, 10);
tone(outPinspeaker, NOTE_F5);
delay(250);
analogWrite(outPinled, 9);
tone(outPinspeaker, NOTE_G5);
delay(1000);
analogWrite(outPinled, 8);
tone(outPinspeaker, NOTE_E5);
delay(250);
analogWrite(outPinled, 7);
tone(outPinspeaker, NOTE_C5);
delay(250);
analogWrite(outPinled, 6);
tone(outPinspeaker, NOTE_F5);
delay(250);
analogWrite(outPinled, 5);
tone(outPinspeaker, NOTE_G5);
delay(125);
analogWrite(outPinled, 4);
tone(outPinspeaker, NOTE_F5);
delay(125);
analogWrite(outPinled, 3);
tone(outPinspeaker, NOTE_E5);
delay(500);
analogWrite(outPinled, 2);
tone(outPinspeaker, NOTE_D5);
delay(500);
analogWrite(outPinled, 1);
tone(outPinspeaker, NOTE_C5);
delay(1000);
analogWrite(outPinled, 0);
noTone(outPinspeaker);
digitalWrite(outPinled, LOW);
delay(10000);
}
else
noTone(outPinspeaker);
digitalWrite(outPinled, LOW);
}

I didn’t have very much success this week with figuring out how to get a switch to turn on an LED. What I had wanted to do was to create a “mood” lamp, where with one switch you would get a white light, and the next switch would turn on two additional LEDs to create a different ambience.

While I could get my switch to read to the serial reader it didn’t seem to work with the switch code and the LED however.

For the integration of the object, I wanted some base to hide the arduino board and connections, the switch to be accessible on the side at the bottom and for the light to be diffused and accented through a filter.

Bruce Munro is a British light artist and I saw this installation at Longwood Gardens near Philadelphia last year:

He used a lot of LEDs and fibre optic cables to create these effects, and I think he might have also used solar power to power the installations.

Another project I saw more recently in Melbourne, Australia was part of the Light in Winter festival and was by Bruce Ramus. He used voice-activated LEDs to activate this helix. Each night at dusk a different group would sing and the amount and color of light was determined by how and what they sang.

Another project I found of interest was in relation to doing research for my own installation in Brooklyn. While I don’t really love the way it looks, it’s interesting for its simplicity and concept (more details http://www.instructables.com/id/3-piece-solar-powered-LED/#step1):

I’m in my third year of the graduate architecture and lighting design program. I’m currently working on a light art installation with CDR Studio Architects and work as a research assistant for one of my professors, looking at energy efficiency design. Originally from Australia, I have degrees in music, mathematics and economics and have previously worked as a management consultant and business analyst.

My interest in physical computing is really due to my interest in lighting. There are so many interesting lighting installations using technology and lighting technology itself is rapidly evolving. I also design fixtures and am interested in using LEDs in a more unconventional way. I just don’t know enough to execute my ideas, and along the way I have been kind enough to short out a few circuits in the studio for everyone plus some minor electric shocks.

My current project is for a old hospital site in Williamsburg, where we are installing a canopy constructed of plastic bottles outdoors as a way of calling attention to the new usage of the building as a community arts space. This is what we think it will look something like:

We’re also looking at ways to light it so it has a presence at night, and as part of that, we’re experimenting with ways to make solar-powered lanterns with individual bottles: