[DISCLAIMER: This website and the material covered is for informational purposes only. Electricity is dangerous and can cause personal injury or death, as well as other property loss or damage. Consult an electrician to perform any work that you are not qualified to perform.I take no responsibility for what you do with this knowledge. I cannot be held responsible for any property or damages caused by items you read about on my website. I make no assurances about the accuracy, validity, correctness, safety, and/or performance of devices, designs, and technologies described here. By taking any information or education material from this website, you assume all risks for the material covered, and agree to indemnify, hold harmless, and defend the author from any and all claims and damages as a result of any and all of the information covered.]
I, myself, am strange and unusual, so it seemed like a fun idea to make a flashing sign from the graveyard scene in Tim Burton's movie "Beetlejuice" (starring Michael Keeton, Geena Davis, and Alec Baldwin) for my annual Halloween display.
I found a superb example online made by a clever fellow named Max Corbett who provided a ton of the inspiration for this project (see video below and this). Max drove his sign with an Arduino, a relay, and transistors. He also made his own "bulbs" with LEDs and resistors. It's a very pragmatic design that optimizes for cost, and reuses items that you probably have in your garage.
Another nice feature of Max's design is that it requires very little power. He made his own lights. Each "LED light" consists of a couple LEDs that each require only ~2VDC and a resistor that are hot-glued into a ping pong ball. Clever, right? Max designed his sign to be used primarily indoors, so he was concerned that using relays (solenoids) would be too noisy due to the clicking sound they make when opening and closing. It's a cool design.
Here are the requirements for my sign:
It needs to work outdoors. Which means grounding and waterproofing.
It needs to be durable.
It needs to animate, and the animation needs to be tunable.
It should cost no more than, say, $500.
Max's sign was a great starting point. It gave me the basic dimensions of the sign, and it used an Arduino to drive the light animation. I'm not concerned about noise or cost, so my sign will use standard E26 light bulbs and a 16-channel relay. You can call me lazy but I didn't want to solder my own light bulbs. Max would probably understand. ;-) The nice thing about E26 bulbs is that they're designed for signs, and only consume 7.5W each. By my calculations, fifty-seven E26 bulbs would only require 427.5W (or 3.563 amps) at peak usage (or about seven 60W light bulbs). The sixteen relays draw about 30mA each (or 0.5A). The Arduino and LED light strips use a negligible amount of power, as well.
Max wrote some code to turn the lights ON and OFF via the Arduino. I started with his code, and will be tweaking it a bit to change up the animation. Nothing much, just a few minor changes.
Parts
1/2" plywood for the Sign frame and Arrow.
1/4" plywood for the Border frame
55 S11 (E26) ceramic light sockets
14 AWG braided wire (white and black)
Sheet of acrylic plexigas
Red spray paint
Yellow spray paint
Wood screws (various sizes)
Staples
Solder
Wood glue
Lettering (Balloon font 33" wide x 4.05" high)
Caulk (for weatherproofing)
Tools
Measuring tape
Straight edge
Table Saw
Drill
Soldering Iron
Sand Paper
Heat gun 1-3/8" hole saw
Stapler (or staple gun)
Construction
The basic dimensions of the sign are 43" wide x 24" high. The width of the frame is 3". The arrow segment is 9.5" wide x 70" tall. I cut the 1/2" plywood for the frame and the arrow first.
I used a staple gun to hold them together temporarily. Next, I cut holes for each of the light sockets with a 1-3/8" hole saw.
I screwed the arrow onto the back of the frame with wood screws.
I attached 2.75" wide triangles to the bottom of the arrow -- making the maximum width of the arrow 16". Next, I cut out holes for the light sockets on the arrow with the 1-3/8" hole saw. I sawed off the portion of the arrow intersecting the middle of the frame with a hand saw. I cut 4" strips of 1/4" plywood, and stapled them around the border of the sign. I didn't have to do this, but it made putting on the 4" strips in the interior of the sign easier to attach.
I cut and attached wood blocks to shore up corners and borders. I filled screw holes and cracks with wood putty, and caulked around the entire sign to seal joints. When dry, I sanded the entire sign.
I glued the 1-3/8" ceramic light sockets into their holes, let that dry, and painted the sign with several coats of spray paint.
I cut a clear acrylic sheet to fit the center of the sign. It's possible to get custom made sheets in a particular color from a company such as TAP Plastics. Cutting acrylic requires a special saw blade (see parts list above) and techniques because acrylic can shatter and/or melt. See How to cut Plastic Sheet for more details.
I cut an inner 1/2" border on top of and behind the acrylic sheet to hold it in place.
I ordered the lettering from doityourselflettering.com. I measured and put a piece of tape all along the top of the sticker, removed the backing, gently applied the sticker until it lays flat, and remove the topping. Beautiful.
Wiring
There is 1 input neutral (white) wire. I ran a single neutral line around the perimeter of the entire sign, connecting to the neutral wire of each light socket.
There are 14 input hot (black) wires (B1, B2, B3, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11). These are effectively the different channels that I will control with the Arduino/relays. I connected each like-named hot wire to the next (B1 -> B1 -> ... -> B1; B2 -> B2-> ... -> B2; A1 -> A1 -> ... -> A1; etc). I soldered the wires together, put heat shrink tubing over the joint, and sealed with a heat gun.
Here's a test of just the B2 lights ...
Here's a canonical example of how the Arduino and the relays drive the lighting. First, I provided power to the Arduino and the Relay boards. I connected the GND from the Arduino to the Relay board. I connected an output pin from the Arduino to an input pin on the Relay board. At some interval, the Arduino tells the output pin to go LOW (ON) or HIGH (OFF). The corresponding relay acts like a switch, either allowing power through or turning it off. As you can see in this example, it flashes a light every second or so. This is the principle behind the 14 light channels described above.
Wiring Diagram
I modified Max's code a little bit. For example, I used different pin mappings. This is purely for convenience. I attached a ribbon cable to the Relay Board, and it was just easier to connect to other Arduino pins. My arrow has two phases: It turns ON (and stays ON) as it animates downward, and turns OFF iteratively as it animates downward in the second phase. This differs from the animation in "Beetlejuice", but I think that I like it a little better. I also substituted variables ON and OFF (instead of LOW and HIGH) to make things clearer.
//BeetleJuice_Sign.ino
//
//Here are the pin mappings
//
//B1 -> Relay 1 -> Arduino Pin 44
//B2 -> Relay 2 -> Arduino Pin 43
//B3 -> Relay 3 -> Arduino Pin 42
//A1 -> Relay 4 -> Arduino Pin 41
//A2 -> Relay 5 -> Arduino Pin 40
//A3 -> Relay 6 -> Arduino Pin 39
//A4 -> Relay 7 -> Arduino Pin 38
//A5 -> Relay 8 -> Arduino Pin 37
//A6 -> Relay 9 -> Arduino Pin 36
//A7 -> Relay 10 -> Arduino Pin 35
//A8 -> Relay 11 -> Arduino Pin 34
//A9 -> Relay 12 -> Arduino Pin 33
//A10 -> Relay 13 -> Arduino Pin 32
//A11 -> Relay 14 -> Arduino Pin 31
//LED -> Relay 15 -> Arduino Pin 30
int ON = LOW;
int OFF = HIGH;
int frameArray[] = {44, 43, 42};
int frameCount = 3;
int frameIndex = 0;
unsigned long frameMillis = 0;
int frameInterval = 500; //msecs
int arrowArray[] = {41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31};
int arrowCount = 11;
int arrowIndex = 0;
unsigned long arrowMillis = 0;
int arrowInterval = 250; //msecs
int arrowPhase = 0;
int ledSwitch = 30; //main sign count
int ledState = OFF;
unsigned long ledMillis = 0;
int ledOnTime = 1000; //msecs
int ledOffTime = 500; //msecs
void doArrow(unsigned long currentMillis)
{
if (currentMillis - arrowMillis >= arrowInterval)
{
arrowMillis += arrowInterval;
digitalWrite(arrowArray[arrowIndex], (arrowPhase == 0) ? ON : OFF);
arrowIndex = (arrowIndex + 1) % arrowCount;
arrowPhase = (arrowIndex == 0) ? !arrowPhase : arrowPhase;
}
}
void doFrame(unsigned long currentMillis)
{
if (currentMillis - frameMillis > frameInterval)
{
frameMillis = currentMillis;
digitalWrite(frameArray[frameIndex], OFF);
frameIndex = (frameIndex + 1) % frameCount;
digitalWrite(frameArray[frameIndex], ON);
}
}
void doLedSwitch(unsigned long currentMillis)
{
if (ledState == ON && currentMillis - ledMillis > ledOffTime)
{
ledMillis = currentMillis;
ledState = OFF;
digitalWrite(ledSwitch, ledState);
}
else
if (ledState == OFF && currentMillis - ledMillis > ledOnTime)
{
ledMillis = currentMillis;
ledState = ON;
digitalWrite(ledSwitch, ledState);;
}
}
void setup()
{
for (int count = 0; count < arrowCount; count++)
{
pinMode(arrowArray[count], OUTPUT);
digitalWrite(arrowArray[count], OFF);
}
for (int count = 0; count < frameCount; count++)
{
pinMode(frameArray[count], OUTPUT);
digitalWrite(frameArray[count], OFF);
}
pinMode(ledSwitch, OUTPUT);
digitalWrite(ledSwitch, OFF);
}
void loop()
{
unsigned long currentMillis = millis();
doArrow(currentMillis);
doFrame(currentMillis);
doLedSwitch(currentMillis);
}After compiling and uploading the code to the Arduino, here's it running... IT'S ALIIIIIIIIIIIIIIIIIIVE!!!
Next, it's time to integrate the electronics into the sign.