Here are the beginnings of my lamp/sculpture/installation. The headlights are 12 volt and run off the hacked power source from a computer. 3 Darlington transistors with heatsinks are sent a PWM fading signal and Voila! >15 hours!
Follow link bellow for details on creating a 12 volt power source from a computer powersource.
http://www.wikihow.com/Convert-a-Computer-ATX-Power-Supply-to-a-Lab-Power-Supply
I tried to combine two vaguely useful functions into one ugly black project box for this assignment. I plan to market it to paranoid children. Basically, it’s a nightlight that also counts how many times an intruder parent walks past to steal your cookies. 
Schematics, Code, and more camera love after the break (more…)
For some reason the idea of a night light stuck with me from the original assignment prompt, and the idea of little glowing, pulsating lights seemed to fit in perfectly.
So, to begin with, I realized that the LEDs I had acquired were of a differing level of intensity. The green could barely be seen against the red, and the blue outshone them all. So I decided to focus on the transition between the different colors rather than the mixing of the colors themselves.
The kind of technologically embedded objects that intrigue me the most are the ones that revel in the differences their materials posses, rather than try to hide them. In any event, what I did was take a nice little piece of walnut that I had (which had a knot in it) and use it as the body for the night light.
I then hooked up the arduino, breadboard, and LEDs to the back of the piece of walnut so that when they lit up, they would emit a broad glow around the walnut and onto the wall behind it.
It was a simple enough hook up, but what I would have liked to have done is hook up a battery pack so that the light could have stood on its own without the cord coming out its side.
I wanted to play a little with Arduino’s on board analog inputs after the joy of dealing with A/D converters previously. I built a simple lamp with 3 LEDs, packing tape (I moved this weekend – it was around) and a light sensor. I played around with some borrowed code to create the following, which includes a simple serial print function (this streams numbers into the black box at the bottom of your code in Arduino that corresponds to the info coming in from the sensor – great for troubleshooting) so that I could monitor the numbers coming in from the sensor.
Since I have next week’s assignment covered I’ll work towards a more creative housing material that is less, well, sticky.
NOTE: be careful running serial all the time – it’s a good way to freeze-up or crash. Best to monitor then stop it.
Materials:
LEDs
light sensor
resistors
wire
heat shrink tubing
(packing tape)
Code:
/* Analog Read to LED
* ——————
* copyleft 2005 David Cuartielles (modified by Jennifer Gooch)
*
*/
int sensorPin = 0; // select the input pin for the
// potentiometer
int ledPin1 = 11; // select the pin for LED1
int ledPin2 = 12; // select the pin for LED2
int ledPin3 = 13; // select the pin for LED3
int val = 0; // variable to store the value coming
// from the sensor
void setup() {
pinMode(ledPin1, OUTPUT); // ledPin is as an OUTPUT
pinMode(ledPin2, OUTPUT);
pinMode(ledPin3, OUTPUT);
Serial.begin(9600); // opens serial port, sets data rate to 9600 bps
}
void loop() {
val = analogRead(sensorPin); // read the value from
// the sensor
Serial.print(val, DEC); // prints value from sensor
Serial.print(” “); // space in value
if (val > 0)
{
digitalWrite(ledPin1, LOW); // turn the LED on
digitalWrite(ledPin2, LOW); // turn the LED on
digitalWrite(ledPin3, LOW); // turn the LED on
}
if (val > 250)
{
digitalWrite(ledPin1, LOW); // turn the LED on
digitalWrite(ledPin2, LOW); // turn the LED on
digitalWrite(ledPin3, HIGH); // turn the LED off
}
if (val > 500)
{
digitalWrite(ledPin1, LOW); // turn the LED on
digitalWrite(ledPin2, HIGH); // turn the LED off
digitalWrite(ledPin3, HIGH); // turn the LED off
}
if (val > 750)
{
digitalWrite(ledPin1, HIGH); // turn the LED off
digitalWrite(ledPin2, HIGH); // turn the LED off
digitalWrite(ledPin3, HIGH); // turn the LED off
}
delay(100); // delay program for 100 ms
}
Concept: To design a light that mimics a color if shown to it. Design: lamp driver. LEDs are very efficient as they only emit one frequency of light, and because of this the light produced could be perceived as flat and lifeless. Instead i used tungsten bulbs because unlike LEDs they aren’t flat and lifeless. Because the Arduino cannot provide enough current to power a tungsten bulb without damaging the Arduino chip, I had to use transistors to turn a separate power source on to power the bulbs. This also meant that the lamp wouldn’t draw too much current from the laptop. To do this i connected the pwm pins to base of the transistors, and grounded the transistors to the Arduino’s ground in series with diodes to prevent current flowing back through the tungsten bulbs from the Arduino. Because i used the pwm pins i could dim the bulbs the same way one can dim LEDs in the Arduino code.colour sensor. Because I wanted the lamp to detect colors and mimic them, I prototyped a simple color sensor. To do this i connected three light dependent resistors (LDR’s) to the analog inputs of the Arduino, with a 10kohm resistor between them and ground to create a light-dependent voltage divider. I covered each of the LDR’s with a piece of red, green, and blue transparent plastic respectively. This meant that when light of a certain color fell on the LDR’s, it would be absorbed and measured differently by each of them, respective to color. Thus, a color value could be interpreted from the LDR’s and replicated with the tungsten bulbs.notes. At the moment, the color sensor only works effectively when a piece of cellophane is held over the sensor to color the light. In further development a lens could be used to focus images onto the color sensor, thus obtaining a more accurate color value.
Being new to this, I started with the loop tutorial on the Arduino site. I altered the tutorial, which was for six LEDs to work for three LEDs.
Once I got that working, I substituted the code in the tutorial that made the LEDs blink with the code from the Arduino program example, Analog Fading, so they would fade in sequence. Next, I played around with random variables so that the LEDs would fade in and out in random sequence. The I increased the delay for fading in so that it was slower than the fade out. Also, I added a random delay between the fade in/fade out, so that LED would stay on for a random period of time.
int pins[] = { 9, 5, 3 }; // an array of pin numbers
int num_pins = 3; // the number of pins (i.e. the length of the array)
int value = 0;void setup()
{
int i;for (i = 0; i < num_pins; i++) // the array elements are numbered from 0 to num_pins – 1
pinMode(pins[i], OUTPUT); // set each pin as an output
}void loop()
{
int i;int r = random(num_pins);
int rt = random(10);for(value = 0 ; value <= 255; value+=5) // fade in (from min to max)
{
analogWrite(pins[r], value); // sets the value (range from 0 to 255)
delay(1000);
}
delay(timer*rt);
for(value = 255; value >=0; value-=5) // fade out (from max to min)
{
analogWrite(pins[r], value);
delay(30);
}
}
For the lamp, I used a paper candle holder I created last year, which fit nicely over the breadboard. The bluish white light worked well when on.
Unfortunately, the red and green lights didn’t shine so brightly.
I started with the default fading code, and modified it to make 3 consequent fading LEDs.
Steps:
Step 1| At first, without any lamp ideas, I just wanted to make a working code for 3 fading lamp. So I just put the LEDs on the breadboard. It took me a while to figure out that some PWMs are enough for fading sequence. But still green LED is giving out a poor light but I think it is because of lamp itself.
2 | After the code worked as I wanted, I started to think how will I make it look like a lamp. I took out the LEDs from board and bent wires and pins going into the LED to make them attach to each other.
3 | I cut 3 ping pong balls and gathered to each other vertically.
4 | So I put each LED set to one of the bulbs and tried to make them light up consequently.Because of the LEDs light power difference, some of them become dominant to others.
———————————
I really had fun to play around with the LEDs !
And here is the code:
int timer = 255; // The higher the number, the slower the timing.
int pins[] = {
3, 5, 6 }; // an array of pin numbers
int num_pins = 3; // the number of pins (i.e. the length of the array)
int value = 0;
void setup()
{
int i;
for (i = 0; i < num_pins; i++) // the array elements are numbered from 0 to num_pins – 1
pinMode(pins[i], OUTPUT); // set each pin as an output
}
void loop()
{
int i;
for (i = 0; i < num_pins; i++) {
for(value = 0 ; value <= 255; value+=5) // fade in (from min to max)
{
analogWrite(pins[i], value); // sets the value (range from 0 to 255)
delay(30); // waits for 30 milli seconds to see the dimming effect
}
}
for (i = num_pins – 1; i >= 0; i–) {
for(value = 255; value >=0; value-=5) // fade out (from max to min)
{
analogWrite(pins[i], value);
delay(30);
}
}
}
Materials
3 resistors, 3 LEDs, 3 acrylic paper weights (from IKEA), prototyping board, Arduino
Process
After learning how to program one LED to fade in and out, the first step in creating the lamp was to repeat the same behavior for two more LEDs. After looking over the code and finding out how the arduino tells the LEDs what to do through the appropriate jumpers, I augmented the code to provide for 2 additional LEDs on pins 10 and 11. Next, I changed the code to diversify the behavior between the three LEDs as follows
// Fading LED
// by BARRAGAN <http://people.interaction-ivrea.it/h.barragan>
// adapted by Joe Iloreta
int value = 0; // variable to keep the actual value
int ledBluePin = 9; // light connected to digital pin 9
int ledGreenPin = 10;
int ledRedPin = 11;
void setup()
{
// nothing for setup
}
void loop()
{
//GreenIn
for(value = 0 ; value <= 255; value+=5) // fade in (from min to max)
{
analogWrite(ledGreenPin, value); // sets the value (range from 0 to 255)
delay(35); // waits for 30 milli seconds to see the dimming effect
}
//BlueIn
for(value = 0 ; value <= 255; value+=5) // fade in (from min to max)
{
// sets the value (range from 0 to 255)
analogWrite(ledBluePin, value); // sets the value (range from 0 to 255)
delay(60); // waits for 30 milli seconds to see the dimming effect
}
//GreenOut
for(value = 255; value >=0; value-=5) // fade out (from max to min)
{
analogWrite(ledGreenPin, value); // sets the value (range from 0 to 255)
delay(15);
}
//RedIn
for(value = 0 ; value <= 255; value+=5) // fade in (from min to max)
{
// sets the value (range from 0 to 255)
analogWrite(ledRedPin, value);
delay(35); // waits for 30 milli seconds to see the dimming effect
}
//BlueOut
for(value = 255; value >=0; value-=5) // fade out (from max to min)
{
// sets the value (range from 0 to 255)
analogWrite(ledBluePin, value); // sets the value (range from 0 to 255)
delay(55);
}
//RedOut
for(value = 255; value >=0; value-=5) // fade out (from max to min)
{
// sets the value (range from 0 to 255)
analogWrite(ledRedPin, value);
delay(5);
}
}
Enclosure
After testing multiple materials (paper, acrylic panels, tracing paper) to see how the light is shaped by forms, I ended up using three spare paper weights to house the LEDs. Using a drill, I drilled holes in the bottom of each cube big enough to secure the LED, and deep enough into the cube so that the light and “bubbles” encased would create an interesting play of light and shadow.
I also drilled in a screw on the bottom of each cube to tilt the paper weights so that the wires connecting the LEDs to the board could protrude out without destabilizing the cubes.
First, I started off by playing with the arduino microprocessor and then manipulating some basic tutorial code.
Although I had a working code that slightly manipulated the tutorial code, today’s lesson from Mark was very helpful in understanding (at least vaguely) each line of the code.
Playing around with the delay as well as the three deltas, I got a red light that flickers very fast, a blue that pulsates similar to the heartbeat of someone who has just exercised, and a green that is slower, with the fading ins and outs a bit more noticable.
Click Image to Enlarge:
Code:
// Fading 3 LED’s
// 3 PARTS FOR EVERY ARDUINO PROGRAM: DECLARATION, SETUP, & LOOP
// a FADING LED program that uses a count-down timer to gradually dim and brigten an LED.
// modified MDG
// 4 variables
int timer_red = 255;
int timer_blue = 255;
int timer_green = 255;
int delta_red = 20; // Three deltas (amount to dim or brighten).
int delta_blue = 6;
int delta_green = 2;
int brightness_red = 0;
int brightness_blue = 0;
int brightness_green = 0;
int redledpin = 9; // LED’s connect to the three PWM pins on Arduino.
int blueledpin = 10;
int greenledpin = 11;
void setup()
{
//nothing for setup
}
void loop()
{
analogWrite (redledpin, brightness_red);
analogWrite (blueledpin, brightness_blue);
analogWrite (greenledpin, brightness_green);
delay (5);
brightness_red = brightness_red + delta_red;
brightness_blue = brightness_blue + delta_blue;
brightness_green = brightness_green + delta_green;
timer_red = timer_red – 1;
timer_blue = timer_blue – 1;
timer_green = timer_green – 1;
if (timer_red <= 0)
{timer_red = 255;
delta_red = delta_red * -1;
}
if (timer_blue <= 0)
{timer_blue = 255;
delta_blue = delta_blue * -1;
}
if (timer_green <= 0)
{timer_green = 255;
delta_green = delta_green * -1;
}
}
