The 2012 London Olympic Games coincided with my son’s last year of primary school. Each year the school has an “expo” in which students explore and create displays on some theme. In that year the school decided the theme would be the Olympics.
One idea we (my son, wife and I) came up with was a model of an olympic torch with a “flickering flame” effect. This was just one of a number of items that had to be prepared by my son for the “expo”, and some parental assistance was expected, so we helped with that.
My wife created the body of the torch from a cone-shaped industrial cotton reel and cardboard coffee cup, all spray-painted gold.
I considered using a PIC micro-controller and a couple of discrete tri-colour high-intensity LEDs, but given the time and size constraints I decided to use a Freetronics LeoStick Arduino with two high-intensity LED units on a ProtoStick (from Jaycar in Adelaide) powered by a 9V battery. The LeoStick sits inside the coffee cup with cellophane over the top to provide a diffuser (added by my wife), as shown below.
A momentary push-button switch is used to start the “flickering flame” for a short time as shown in this YouTube video.
The serially clocked tri-colour high intensity LED units randomly and rapidly cycle through various colours to produce the effect.
This Freetronics page describes the LED components and their usage in more detail.
The following image shows the individual disassembled components:
Note the large (by comparison to the LeoStick) home-brew 5V regulated power supply to which a 9V battery is connected. The power supply and battery sit inside the conical handle attached to a toggle switch (power on/off) in the base, a water bottle lid in this case.
The following image shows the components connected:
The high-intensity LED units are attached to the ProtoStick via headers soldered to the latter.
The following schematic shows the simple Arduino-based circuit:
The resistor in the schematic is a surface mount component soldered to the ProtoStick.
The code for the project is shown below. As can be seen from the excluded code at the end of the loop() function, I toyed with adding a wake-from-sleep interrupt to conserve power while the circuit was active, but didn’t get that to function within the time available. There was no loss of functionality of course, just a greater drain on the battery because of the unfortunate busy-looping.
/*
* 2012 EMPS Expo Olympic Torch RGB LEDs, for Nicholas.
*
* Arduino (LeoStick)
*
* References:
* - http://www.freetronics.com/pages/leostick-getting-started-guide#.UBOpjJkthmo
* - http://www.freetronics.com/pages/rgbled-rgb-led-quickstart-guide#.UAq-qZktg38
* - http://www.arduino.cc/en/Tutorial/Debounce
*
* dbenn@computer.org, August 2012
*/
#include <avr/sleep.h>
// RGB LED strip pins (clock and serial data).
const int CKI = 10;
const int SDI = 12;
// Button pin
const int BUTTON = 2;
// Button state variables.
int buttonState = LOW;
int lastButtonState = LOW;
// The following variables are longs because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long lastDebounceTime = 0; // the last time the output pin was toggled
const long DEBOUNCE_DELAY = 50; // the debounce time; increase if output is unstable
// Function prototypes.
void wakeupHandler();
void blankLEDStrip();
void randomiseLEDStrip(long millisecs);
void setLEDStrip(int color1, int color2);
void pushLED(int color);
boolean isButtonToggled();
boolean isButtonPressed();
long getRndColor();
void setup() {
pinMode(BUTTON, INPUT);
pinMode(SDI, OUTPUT);
pinMode(CKI, OUTPUT);
randomSeed(analogRead(1));
blankLEDStrip();
}
void loop() {
// When the button is toggled, generate
// random colors with random pauses between
// each for 15 seconds, then blank the LED strip.
if (isButtonToggled()) {
randomiseLEDStrip(15000);
blankLEDStrip();
}
#if 0
// A sleep mode with wake-from-interrupt would decrease power consumption.
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_enable();
interrupts();
attachInterrupt(0, wakeupHandler, RISING);
sleep_mode();
#endif
}
#if 0
void wakeupHandler() {
// When the button is toggled, generate
// random colors with random pauses between
// each for 15 seconds, then blank the LED strip.
// while (!isButtonToggled());
randomiseLEDStrip(15000);
blankLEDStrip();
}
#endif
// Blank the RGB LED strip.
void blankLEDStrip() {
setLEDStrip(0x00000000, 0x00000000);
}
// Generate random colors for random periods for specified number of seconds.
void randomiseLEDStrip(long millisecs) {
long t1 = millis();
while (millis() <= t1+millisecs) {
setLEDStrip(getRndColor(), getRndColor());
delay(random(100));
}
}
// Set the colors on the RGB LED strip.
void setLEDStrip(int color1, int color2)
{
pushLED(color1);
pushLED(color2);
// Pull clock low to put LED strip into reset/post mode
// and wait for 500 microseconds for completion.
digitalWrite(CKI, LOW);
delayMicroseconds(500);
}
// Push a 24-bit RGB colour data (RRGGBB; red is MSB) out to the LED strip.
void pushLED(int color) {
for (int color_bit = 23 ; color_bit >= 0 ; color_bit--) {
// Low clock signals bit change start.
digitalWrite(CKI, LOW);
// Force mask to be 32-bit instead of 16-but by default.
long mask = 1L << color_bit;
// Write data bit and latch.
digitalWrite(SDI, color & mask ? HIGH : LOW);
digitalWrite(CKI, HIGH);
}
}
// Returns whether the button was toggled (pressed then released).
boolean isButtonToggled() {
boolean toggled = false;
if (isButtonPressed()) {
while (isButtonPressed());
toggled = true;
}
return toggled;
}
// Returns whether the button was pressed since the last time the function was called.
boolean isButtonPressed() {
// Read the state of the switch into a local variable.
int currentButtonState = digitalRead(BUTTON);
// Check to see if we just pressed the button
// (i.e. the input went from LOW to HIGH), and we've waited
// long enough since the last press to ignore any noise.
// If the switch changed, due to noise or pressing...
if (currentButtonState != lastButtonState) {
// ...reset the debouncing timer.
lastDebounceTime = millis();
}
if ((millis() - lastDebounceTime) > DEBOUNCE_DELAY) {
// Whatever the current button state is, it's been there for longer
// than the debounce delay, so take it to be the actual current state.
buttonState = currentButtonState;
}
// Save the current button state. Next time through the loop,
// it'll be the lastButtonState.
lastButtonState = currentButtonState;
return buttonState == HIGH;
}
// Return a random color.
// Proportions of each color component can be tweaked in the selection comparisons.
long getRndColor() {
long primary = random(100);
long rgb = 0xFFFFFF;
if (primary < 50) {
rgb = 0xFF0000 | random(0x100) << 8 | random(0x100);
} else if (primary < 75) {
rgb = 0x00FF00 | random(0x100) << 16 | random(0x100);
} else {
rgb = 0x0000FF | random(0x100) << 16 | random(0x100) << 8;
}
return rgb;
}
Leave a Reply