DIY toddler balance bike headlight

Light up your little one’s balance bike with this simple do-it-yourself headlight.

There’s not a lot to say here, glue something ferromagnetic (something magnets stick too) to the front of the balance bike and purchase a puck shaped utility light with a magnet on the back to stick to it. I used a washer and crazy glue, super simple, loads of fun. The light may slide off the washer in the event of a collision — but putting it back on is half the fun!

The balance bike my son has is the Kinderfeets TinyTot Wooden Balance Bike and Tricycle, which converts from a three-wheeled tricycle to a two-wheeled bike when they’re old enough.

Materials

Arduino Hot Wheels Drag Strip Race Track

For my son’s second birthday I decided to introduce him to die-cast cars and what better way than building a drag strip race track with an electronic start gate, timing and race results?

While Hot Wheels does offer a 6-Lane Raceway and a number of other drag strip style tracks, they didn’t have the timing and electronic start gate that I knew an Arduino and some other bits could provide, so I set to work. The basic idea is was have a servo motor open the start gate by pulling down a hinged plate with dowel stoppers to release the cars and a photocell (photoresistor/LDR) pointed at an infrared LED on each track to detect each car crossing the finish line.

Some quick searching revealed a number of projects from which I could draw insight and inspiration, most useful were apachexmd’s Hot Wheels Track Timer and Robby C’s Ultimate Guide to Building a Hot Wheels Race Track. This demystified a number of points, I hadn’t really had any fun with die-cast cars since I was kid myself, turns out there are some oddities.

Tracks

One of the oddities is that Hot Wheels doesn’t offer any long track for sale, all of their tracks are sold in segments a foot or two long that must be connected — the only exception being a vintage 50-foot Track Pak Raceway sold at some point in the 70′s or 80′s which can be found for upwards of $100 currently. Another track option is BluTrack which is sold in many lengths but only in a two-lane configuration for some reason. I decided to buy the readily available Hot Wheels segments in the form of 4 Hot Wheels Track Builder Straight Track kits.

I had some 1/2″ x 8″ pine left over from framing a door I thought I would use to mount the track on. There are a number of methods folks have employed to mount the Hot Wheels track on wood, I decided to use a method mentioned on Robby C’s page which involves using screws to secure a stack of two different sized washers to the wood at intervals.

A small washer below a larger one provides the elevation that the track needs to slide onto the larger washer. The exact washers and screws I used can be seen in the gallery below, be sure to drill pilot holes for the screws and try to keep them straight, the straighter the screws are, the better they will fit in the washer and, in turn, the smaller the bump in the track will be. This method (at least with the sizes I used) does leave ever so slight bumps in the track once it’s fitted, but I felt it was slight enough that it wouldn’t adversely affect the races. I used one of these washer guides for each section of track positioned to sit in the center of the track, except for the finish line track where I placed one at either end.

The track has 4 main pieces (though one I cut into two to make it more modular). These four pieces are a small section of track for the finish line which has the results display attached, the main straightaway, the start incline and a support for the start incline. Following some of the ideas on Robby C’s page again I decided to use hinges to connect the start incline track to its support piece as well as to the straightaway allowing for an adjustable incline. If you use hinges with removable pins it allows for easier disassembly.

I ended up cutting the straightaway into two sections, and I’ll probably do the same with the incline so that I can make the entire track shorter and thus more palatable in the living room.

For the joint between the incline and the straightaway I made sure that no track joints would run across the curve allowing for the longest pieces of track at this joint and thus a smooth transition for cars from the incline to the straightaway.

The flat joints I cut where the tracks connect, this makes disassembly a bit easier, but I’m not sure it was the right choice as some of the wood warped and having a track joint and a wood joint at the same spot may not result in the smoothest run. Experiment with the hinges and see which orientation works best for your setup.

Start Gate

The start gate on this track uses a high torque servo to actuate a hinged plate that has 4 wood dowels inserted into it. The dowels feed up through routed slots in the wood and tracks to hold the cars at the start gate.

The Hot Wheels tracks can be cut easily with a sharp exacto, though it’s difficult to get the corners of cuts perfectly smooth. The track can also be drilled, one method is to drill an appropriate diameter hole at either end of the route you wish to cut and then connect the two holes with a single exacto cut on either edge.

To start the race the servo pulls a stiff wire which is connected to the hinge plate with a small L-bracket, this pulls the dowels back down through the routed slots and releases the cars. The slots I routed in the wood were 1/2″, the track slots were a little smaller than that, somewhere between 1/4″ and 1/2″ as the dowels themselves were 1/4″ diameter and needed some clearance to move smoothly. The dowels are simply friction fit into drilled holes.

It may not be obvious from the video and photos, but I drilled a small hole in the L bracket which fit the wire much better than the large screw holes. This prevented any extra travel of the wire at the hinge plate connection when the servo actuates.

The wire I used to connect the servo to the hinge plate is a malleable steel of some sort, when my son decides to push or pull on the start gate hinge or dowels it will bend this wire rather than stress the servo, after which I inform him that is not how it’s suppose to function and bend the wire straight again. For my setup a run-of-the-mill servo wasn’t strong enough to push and pull the 1/4″ wooden hinged plate so I picked up a high torque servo. If you made a lighter, thinner hinge plate you may be alright with a weaker servo.

Robby C mentions something about this type of drop-out start gate being not as fair as a gate that lifts rather than drops, but I’m not sure why that would be — in any case, my goal was not to create a track fit for the world cup of die-cast racing. A lift gate would have required more fabrication, so I opted for the simpler drop-out.

Finish Line

The finish line employs 4 photocells, also know as photoresistors or LDR’s (Light Dependent Resistors) which sit in an enclosure above the track in holes drilled into a piece 1/2″ piece of wood. These photocells point down through the drilled holes, through larger drilled holes in the enclosure at 4 infrared LED’s embedded in the wood under the track and aligned with holes in the track above. Placing the photocells in holes in the 1/2″ piece of wood keeps them focused on their respective infrared LED underneath without picking up a lot of ambient light.

While the infrared LED’s don’t produce any light visible to the naked eye, they are detected by the photocells and when a car passes over the infrared LED, the reading on the respective photocell drops dramatically and thus the Arudino brain can determine when each car passes the finish line by waiting for the photocell reading to drop.

Embedding the photocells into a piece of wood also allowed me to align that wood with holes I drilled in the track wood for the infrared LED’s before placing the wood, along with the photocells in the enclosure. Once I’d aligned the wood, I drilled holes in it for the photocells, wired up the photocells and placed that entire piece of wood into the enclosure. The holes I drilled in the enclosure were much larger and thus I had room to align the wood with the photocells to the infrared LED’s without having to worry about aligning exactly with the holes in the enclosure.

I wrote a specific Arduino sketch in order to align the photocells which wrote the photocell values to the computer via a serial connection. Since then I have added a debug mode to the race track, pressing both the start race and track reset buttons simultaneously will engage the debug mode where the Arduino will write the photocell values out to the 7-segment race result displays so that I can check the photocell alignments.

One of the issues I ran into was that it seemed the power needed to actuate the start gate servo would draw too much from the rest of the circuit causing the infrared LED’s to dim and trigger the photocells. To get around this I added a 150ms delay to allow the circuit to recover after opening the start gate.

Circuit

None of the electronics used in the project are very complex. I collected various components mostly from RobotShop, SparkFun, Creatron and locally.

These components and their circuits are all connected to the Arduino which runs the sketch at the bottom of this post. If I get a chance to draw one up, I’ll post a circuit diagram.

Car Storage

After purchasing a good starting set of cars to go along with the drag track I needed some way to store the hoard. It seemed likely that a generic storage container would do the trick as long as the compartment sizing matched. I wasn’t all that pleased with the purpose-build die-cast storage containers. A little bit of searching revealed this Creative Options Thread Organizer which fits 48 cars almost perfectly. It’s only half-full in the photo below, with the same number of compartments on the reverse side still to be populated.

Next Steps

While it turned into a race to finish this project in time for my son’s birthday, I had initially intended to integrate a Raspberry Pi to record race statistics and another fun function, but I’ll leave that to everyone’s imagination until I get around to implementing it. The whole setup could also use some Hot Wheels stickers.

Update

I’ve since removed a section from the start incline and the straightaway to reduce the overall size of the track in order to move it to a more permanent location (rather than across our living room). Below is a short video of my son operating the shortened track, he doesn’t seem to mind the change and still enjoys the track quite a bit.

Arduino Sketch


/* Hot Wheels Drag Strip v1.2 */

#include <Servo.h>
#include <SPI.h> // Include the Arduino SPI library

// SPI SS pins
const int displayPinLane1 = 7;
const int displayPinLane2 = 4;
const int displayPinLane3 = 6;
const int displayPinLane4 = 5; 

// Photocell pins
const int photocellPinLane1 = 2;
const int photocellPinLane2 = 3;
const int photocellPinLane3 = 4;
const int photocellPinLane4 = 5;

int photocellReadingLane1;
int photocellReadingLane2;
int photocellReadingLane3;
int photocellReadingLane4;

const int photocellThreshold = 4;

// Button pins
const int startButtonPin = 2;
const int resetButtonPin = 3;

const int gateServoPin = 14;

Servo gateServo;

// Servo positions
const int openGateServoPosition = 10;
const int closeGateServoPosition = 30;

int startButtonState = 0;
int resetButtonState = 0;

int raceStatus = 0;

int lane1Status = 0;
int lane2Status = 0;
int lane3Status = 0;
int lane4Status = 0;

int currentPlace = 0;

unsigned int counterLane1 = 0;  // These variables will count up to 65k
unsigned int counterLane2 = 0;
unsigned int counterLane3 = 0;
unsigned int counterLane4 = 0;  

String displayString;
char tempString[10];  // Will be used with sprintf to create strings

int animationTimer = 0;
bool showPlace = true;

void setup()
{
  gateServo.attach(gateServoPin);
  gateServo.write(closeGateServoPosition);

  pinMode(startButtonPin, INPUT);
  pinMode(resetButtonPin, INPUT);

  // -------- SPI initialization
  pinMode(displayPinLane1, OUTPUT);
  digitalWrite(displayPinLane1, HIGH);
  pinMode(displayPinLane2, OUTPUT);
  digitalWrite(displayPinLane2, HIGH);
  pinMode(displayPinLane3, OUTPUT);
  digitalWrite(displayPinLane3, HIGH);
  pinMode(displayPinLane4, OUTPUT);
  digitalWrite(displayPinLane4, HIGH); 

  // Begin SPI hardware
  SPI.begin();
  // Slow down SPI clock
  SPI.setClockDivider(SPI_CLOCK_DIV64); 

  clearDisplays();

  s7sSendStringSPI(displayPinLane1, "Ln 1");
  s7sSendStringSPI(displayPinLane2, "Ln 2");
  s7sSendStringSPI(displayPinLane3, "Ln 3");
  s7sSendStringSPI(displayPinLane4, "Ln 4");

  // High brightness
  setBrightnessSPI(displayPinLane1, 255);
  setBrightnessSPI(displayPinLane2, 255);
  setBrightnessSPI(displayPinLane3, 255);
  setBrightnessSPI(displayPinLane4, 255);
}

void loop()
{
  animationTimer++;

  if(animationTimer > 200) {
    if(showPlace == true) {
      showPlace = false;
    } else {
      showPlace = true;
    }
    animationTimer = 0;
  }

  photocellReadingLane1 = analogRead(photocellPinLane1);
  photocellReadingLane2 = analogRead(photocellPinLane2);
  photocellReadingLane3 = analogRead(photocellPinLane3);
  photocellReadingLane4 = analogRead(photocellPinLane4);  

  resetButtonState = digitalRead(resetButtonPin);
  startButtonState = digitalRead(startButtonPin);

  if(resetButtonState == HIGH && startButtonState == HIGH) {
    // Debug mode
    clearDisplays();

    s7sSendStringSPI(displayPinLane1, String(photocellReadingLane1)+"   ");
    s7sSendStringSPI(displayPinLane2, String(photocellReadingLane2)+"   ");
    s7sSendStringSPI(displayPinLane3, String(photocellReadingLane3)+"   ");
    s7sSendStringSPI(displayPinLane4, String(photocellReadingLane4)+"   ");

    delay(1000);
  } else if(resetButtonState == HIGH && raceStatus > 0) {
    raceStatus = 0;

    clearDisplays();

    s7sSendStringSPI(displayPinLane1, "Ln 1");
    s7sSendStringSPI(displayPinLane2, "Ln 2");
    s7sSendStringSPI(displayPinLane3, "Ln 3");
    s7sSendStringSPI(displayPinLane4, "Ln 4");

    lane1Status = 0;
    lane2Status = 0;
    lane3Status = 0;
    lane4Status = 0;

    counterLane1 = 0;
    counterLane2 = 0;
    counterLane3 = 0;
    counterLane4 = 0;

    currentPlace = 0;

    gateServo.write(closeGateServoPosition);
  } else {
    if (raceStatus == 0 && startButtonState == HIGH) {

      // start the race

      gateServo.write(openGateServoPosition);

      // wait for servo to drop
      delay(150);
      raceStatus = 1;
    } else if (raceStatus == 1) {

      // race is running

      int carsAcross = 0;

      if (photocellReadingLane1 < photocellThreshold && lane1Status == 0) {
        showPlace = true;
        currentPlace++;
        carsAcross++;
        lane1Status = currentPlace;
        gateServo.write(closeGateServoPosition);
      } 

      if (photocellReadingLane2 < photocellThreshold && lane2Status == 0) {
        showPlace = true;
        if(carsAcross == 0) {
          currentPlace++;
        }
        carsAcross++;
        lane2Status = currentPlace;
        gateServo.write(closeGateServoPosition);
      } 

      if (photocellReadingLane3 < photocellThreshold && lane3Status == 0) {
        showPlace = true;
        if(carsAcross == 0) {
          currentPlace++;
        }
        carsAcross++;
        lane3Status = currentPlace;
        gateServo.write(closeGateServoPosition);
      } 

      if (photocellReadingLane4 < photocellThreshold && lane4Status == 0) {
        showPlace = true;
        if(carsAcross == 0) {
          currentPlace++;
        }
        carsAcross++;
        lane4Status = currentPlace;
        gateServo.write(closeGateServoPosition);
      } 

      updateDisplay(displayPinLane1, lane1Status, counterLane1);
      updateDisplay(displayPinLane2, lane2Status, counterLane2);
      updateDisplay(displayPinLane3, lane3Status, counterLane3);
      updateDisplay(displayPinLane4, lane4Status, counterLane4);

      if (lane1Status == 0) {
        counterLane1++;
      }

      if (lane2Status == 0) {
        counterLane2++;
      }

      if (lane3Status == 0) {
        counterLane3++;
      }

      if (lane4Status == 0) {
        counterLane4++;
      }
    }
  }

  delay(10);  // This will make the display update at 100Hz.*/
}

void clearDisplays()
{
  clearDisplaySPI(displayPinLane1);
  clearDisplaySPI(displayPinLane2);
  clearDisplaySPI(displayPinLane3);
  clearDisplaySPI(displayPinLane4);
}

void updateDisplay(int displayPin, int laneStatus, unsigned int laneCounter) {

    // Magical sprintf creates a string for us to send to the s7s.
    //  The %4d option creates a 4-digit integer.
    sprintf(tempString, "%4d", laneCounter);

    // This will output the tempString to the S7S
    if(laneStatus == 0 || showPlace == false) {
      s7sSendStringSPI(displayPin, tempString);

      // Print the decimal at the proper spot
      if (laneCounter < 10000) {
          setDecimalsSPI(displayPin, 0b00000010);  // Sets digit 3 decimal on
      } else {
          setDecimalsSPI(displayPin, 0b00000100);
      }
    } else {
      setDecimalsSPI(displayPin, 0b000000000);

      if(laneStatus == 1) {
        s7sSendStringSPI(displayPin, "1st ");
      } else if(laneStatus == 2) {
        s7sSendStringSPI(displayPin, "2nd ");
      } else if(laneStatus == 3) {
        s7sSendStringSPI(displayPin, "3rd ");
      } else {
        s7sSendStringSPI(displayPin, "4th ");
      }
    }
}

// This custom function works somewhat like a serial.print.
//  You can send it an array of chars (string) and it'll print
//  the first 4 characters in the array.
void s7sSendStringSPI(int ssPin, String toSend)
{
  digitalWrite(ssPin, LOW);
  for (int i=0; i < 4; i++)
  {
    SPI.transfer(toSend[i]);
  }
  digitalWrite(ssPin, HIGH);
}

// Send the clear display command (0x76)
//  This will clear the display and reset the cursor
void clearDisplaySPI(int ssPin)
{
  digitalWrite(ssPin, LOW);
  SPI.transfer(0x76);  // Clear display command
  digitalWrite(ssPin, HIGH);
}

// Set the displays brightness. Should receive byte with the value
//  to set the brightness to
//  dimmest------------->brightest
//     0--------127--------255
void setBrightnessSPI(int ssPin, byte value)
{
  digitalWrite(ssPin, LOW);
  SPI.transfer(0x7A);  // Set brightness command byte
  SPI.transfer(value);  // brightness data byte
  digitalWrite(ssPin, HIGH);
}

// Turn on any, none, or all of the decimals.
//  The six lowest bits in the decimals parameter sets a decimal
//  (or colon, or apostrophe) on or off. A 1 indicates on, 0 off.
//  [MSB] (X)(X)(Apos)(Colon)(Digit 4)(Digit 3)(Digit2)(Digit1)
void setDecimalsSPI(int ssPin, byte decimals)
{
  digitalWrite(ssPin, LOW);
  SPI.transfer(0x77);
  SPI.transfer(decimals);
  digitalWrite(ssPin, HIGH);
}

IKEA Hack: MIDI Enabled Highscore Chair


The best thing about IKEA’s ANTILOP Highchair is that it’s cheap, and I mean dirt cheap. With a price tag of $19.99 you don’t have to worry about destroying it, or even not liking it. Coming in as a close second best thing is the fact that you can purchase extra trays which you can modify into activity centers you can swap in and out, such as this pro-gamer training rig.

For the Highscore Chair I added some Joysticks and Buttons I had lying around, loosely intended for expanding my arcade cabinet. These parts have the added advantage of actually being functional, down the road I can hook them up to a Raspberry Pi, an Arduino, MIDI out (Update: I’ve since added MIDI out), or just to some lights and buzzers — if you’ve got any ideas I’d love to hear them. The sky’s the limit as to what you can add to these trays, just keep safety in mind, for example, I placed the joysticks out of the arc of the baby’s head if he were to fall forward.

The trickiest part of this whole process is swapping out the trays. There are four rather stiff tabs that snap in place when attaching the tray. I may make a tool of some sort to make removal easier but in the mean time four butter knives do the trick. It’s probably best to swap the trays without the baby in the highchair, just slip a butter knife under each tab and once all four are in you can remove the tray easily (the butter knives will fall), really, any flat object would work, popsicle sticks perhaps? Now having thought about it, I’ll probably cut off the inner two tabs, the tabs are surprisingly strong I don’t see any risk of the baby removing the tray even if I remove two of them, however removing two would probably allow removal of the tray by an adult pressing one tab with each hand and pushing up on the tray with a knee or the like.

The plastic is very easy to drill, a stepped bit works wonders. Cutting would be a little more difficult but nothing a dremel wouldn’t be able to handle.

Update: I did end up snipping off the inner two tabs on both trays (with some sheet metal shears) and it worked like a charm. The trays can now be removed without the need for tools. Just push on the two remaining tabs with your thumbs keeping your fingers behind the lip for leverage, then use your chest, shoulder or chin (whatever works) to push up on the tray, once the tabs clear the lip you can let go and just lift the tray off. Be sure not to leave any sharp edges and swapping is still best done while the chair is unoccupied due to the number of places little fingers could get pinched while putting the tray on.

Update: I’ve since added MIDI out, which amounts to 10 MIDI triggers, 8 for each joystick and one for each button. The Highscore Chair now triggers samples loaded onto an Akai MPC1000, but with MIDI out it could be used as any sort of control surface now. The MIDI out is accomplished through an Arduino UNO, by following a couple of simple tutorials, found here and here, you can get buttons triggering MIDI notes in no time. I’ll shoot a new video when the little fellow is up for it. While the underside of the tray is already quite isolated from the baby due to the structure of the chair for added safety I’ll be putting the Arduino, battery and MIDI Jack in an enclosure and covering the entire tray undercarriage.


 

Here’s the Arduino sketch, very bare-bones. I cranked it out after a long day so I didn’t want to risk using the wrong array syntax so it’s just long hand, maybe that helps readability for beginners? Anyhow it would be much shorter if it used arrays. Basically there’re variables for each button pin and variables for the state of each button, it will only send one MIDI note per button push and wait until the button’s been released and pressed again before re-sending that note. This sketch is hard-coded to send MIDI notes 36 through 45 on channel 1 at 69 velocity.


const int buttonPin0 = 2;
const int buttonPin1 = 3;
const int buttonPin2 = 4;
const int buttonPin3 = 5;
const int buttonPin4 = 6;
const int buttonPin5 = 7;
const int buttonPin6 = 9;
const int buttonPin7 = 10;
const int buttonPin8 = 11;
const int buttonPin9 = 12;

int buttonStatus0 = 0;
int buttonStatus1 = 0;
int buttonStatus2 = 0;
int buttonStatus3 = 0;
int buttonStatus4 = 0;
int buttonStatus5 = 0;
int buttonStatus6 = 0;
int buttonStatus7 = 0;
int buttonStatus8 = 0;
int buttonStatus9 = 0;

void setup() {
  pinMode(buttonPin0, INPUT);
  pinMode(buttonPin1, INPUT);
  pinMode(buttonPin2, INPUT);
  pinMode(buttonPin3, INPUT);
  pinMode(buttonPin4, INPUT);
  pinMode(buttonPin5, INPUT);
  pinMode(buttonPin6, INPUT);
  pinMode(buttonPin7, INPUT);
  pinMode(buttonPin8, INPUT);
  pinMode(buttonPin9, INPUT);   

  Serial.begin(31250);
}

void loop(){

  int button0State = digitalRead(buttonPin0);
  int button1State = digitalRead(buttonPin1);
  int button2State = digitalRead(buttonPin2);
  int button3State = digitalRead(buttonPin3);
  int button4State = digitalRead(buttonPin4);
  int button5State = digitalRead(buttonPin5);
  int button6State = digitalRead(buttonPin6);
  int button7State = digitalRead(buttonPin7);
  int button8State = digitalRead(buttonPin8);
  int button9State = digitalRead(buttonPin9);  

  if(button0State == 1 && buttonStatus0 == 0)
  {
    buttonStatus0 = 1;
    noteOn(0x90, 0x24, 0x45);
  }
  else if(button0State == 0)
  {
    buttonStatus0 = 0;
  }

  if(button1State == 1 && buttonStatus1 == 0)
  {
    buttonStatus1 = 1;
    noteOn(0x90, 0x25, 0x45);
  }
  else if(button1State == 0)
  {
    buttonStatus1 = 0;
  }

  if(button2State == 1 && buttonStatus2 == 0)
  {
    buttonStatus2 = 1;
    noteOn(0x90, 0x26, 0x45);
  }
  else if(button2State == 0)
  {
    buttonStatus2 = 0;
  }

  if(button3State == 1 && buttonStatus3 == 0)
  {
    buttonStatus3 = 1;
    noteOn(0x90, 0x27, 0x45);
  }
  else if(button3State == 0)
  {
    buttonStatus3 = 0;
  }

  if(button4State == 1 && buttonStatus4 == 0)
  {
    buttonStatus4 = 1;
    noteOn(0x90, 0x28, 0x45);
  }
  else if(button4State == 0)
  {
    buttonStatus4 = 0;
  }

  if(button5State == 1 && buttonStatus5 == 0)
  {
    buttonStatus5 = 1;
    noteOn(0x90, 0x29, 0x45);
  }
  else if(button5State == 0)
  {
    buttonStatus5 = 0;
  }

  if(button6State == 1 && buttonStatus6 == 0)
  {
    buttonStatus6 = 1;
    noteOn(0x90, 0x2A, 0x45);
  }
  else if(button6State == 0)
  {
    buttonStatus6 = 0;
  }

  if(button7State == 1 && buttonStatus7 == 0)
  {
    buttonStatus7 = 1;
    noteOn(0x90, 0x2B, 0x45);
  }
  else if(button7State == 0)
  {
    buttonStatus7 = 0;
  }

  if(button8State == 1 && buttonStatus8 == 0)
  {
    buttonStatus8 = 1;
    noteOn(0x90, 0x2C, 0x45);
  }
  else if(button8State == 0)
  {
    buttonStatus8 = 0;
  }

  if(button9State == 1 && buttonStatus9 == 0)
  {
    buttonStatus9 = 1;
    noteOn(0x90, 0x2D, 0x45);
  }
  else if(button9State == 0)
  {
    buttonStatus9 = 0;
  }
}

void noteOn(int cmd, int pitch, int velocity) {
  Serial.write(cmd);
  Serial.write(pitch);
  Serial.write(velocity);
}

DIY Copper pipe pedicel chandelier

As a soon-to-be parent with time to spare, uh, yeah, I thought I’d take it upon myself to create a chandelier to complement our nursery’s fiber optic starfield ceiling. I have already had some experience with iron pipe fixtures but wanted something a little more delicate for this one. I called the resulting chandelier a pedicel chandelier because the small frosted night light bulbs I used along with the pearl white painted copper pipe reminded me of the small fuzzy horns that a male fawn grows before antlers, also known as pedicels (they’re not actually antlers).

The basic how-to for this chandelier is to use 1/2″ copper pipe to create an organic pipe structure with candelabra lights on the end of each pipe. Since you can use any low watt candelabra bulb, also known as E12 bulbs, a variety of different looks can be achieved using the same process. This projects requires knowledge of electrical wiring and should only be undertaken by those who are familiar with light fixture wiring and the dangers involved.

Three different candelabra or E12 light bulbs.

The copper pipe is attached to a dome fixture cover with threaded adapters and electrical bushing nuts (any appropriately sized nut would work). I soldered the pipe together after it was completely cut and assembled however there are issues with soldering which I’ll get to later. Use of epoxy to join the copper hardware would probably be much easier and safer.

Metal dome fixture cover. These are also available in brass if you're planning on leaving the copper pipe unpainted.

Below you can see the basic collection of fittings for the chandelier’s horns. Once wired the candelabra socket connections are wrapped in electrical tape to insulate them from each other as well as from the pipe itself, make sure all wires are neatly trimmed and covered in tape. The electrical tape also enables the socket to fit snugly (is there an uglier word with a more desirable meaning?) in the pipes. Not snug enough? Add more tape. Too snug? Take some off. The only coupling I had left to photograph was one that I had done some test painting on, rest assured when you purchase them they are copper coloured.

Though I purchased a whole bunch of 90°/right angle fittings I did not end up using them as 45° fittings convey a much more organic feel. Even though the T junction fittings were at right angles I tried to use a 45° fitting right after to soften the look of the structure. Another tip to help the fixture look organic is to never have two lights extending at the same angle — all angles should be at least slightly different. If you want your fixture to have a more industrial or steampunk feel, more right angle fittings may work better.

I decided on 3 separate structures, or horns with 6 lights each. The total 18 7W bulbs ends up at a scant 126W, perfectly acceptable for most dimmers. This meant 5 T junctions per arm, a total of 15. I suggest mapping out your fixture before heading to the hardware store and try to purchase fittings which don’t have price tags on them, I made this mistake and spent a cozy evening with Goo Gone because of it.

Left to right, candelabra (E12) 7W night light bulb, candelabra (E12) socket, electrical tape, 3/4" to 1/2" copper coupling, 1/2" copper pipe and fittings, 1/2" to 3/4" threaded brass adapter, 1/2" electrical bushing nut

Here you can see the threaded brass adapters and electrical bushing nuts securing the fixture horns to the metal dome fixture plate. Be sure to get brass threaded adapters and not copper, copper threads are too soft to tighten properly and will bind.

Drilling the mounting holes is a breeze, as long as you have a power drill and a stepped bit (pictured below). Stepped bits can be expensive, but they’re well worth it as they make quick work of drilling holes in thin metals, holes which could otherwise prove tricky and end up messy. I highly recommend investing in one, or a set.

A few required tools, a stepped drill bit (for drilling the mounting holes in the fixture plate), a copper pipe cutting tool and a roll of electrical tape.

Candelabra (E12) replacement socket.

We don’t need all that extra jazz, just the socket. Some of these are riveted together, others have a screw. In the case of rivets, unscrew the extension, then just bend the remaining metal mounting arms until the rivet brakes — careful not to crack the bakelite socket (I don’t even know if it’s bakelite, but that’s what I like to think it is).

Candelabra socket disassembled. We only need the socket itself, shown on the right.

I started by drilling the fixture plate and mounting the threaded couplings, this gives you a good base to create your chandelier upon. I used a bolt through the center hole of the plate to attached the fixture securely to a camera tripod while I worked on it. Things can fall apart quite easily if you’re not paying attention or one structure is heavier than another, you can use some twine, elastics, or whatever works really to support various pieces while you create.

If it becomes a pain to keep it together while you work than you can affix joints that you are confident will not change. I ended up soldering the main support pipe line of each of the three horns and I kept any extending pipe structures separate to make threading the wiring easier. If you’re soldering you want to do as much soldering as possible before starting any wiring — soldering with wire inside can melt the insulation and short out the entire chandelier, this is one of the soldering issues I mentioned earlier.

Once everything is cut, perhaps some has been soldered or epoxied, it’s time to start running wire. I decided to run three main wiring lines, one for each horn, any pipes extending off the main horn would then be spliced into the main line. Based on the bulbs you want to use, and how many, you’ll have to determine the max amperage and thus the proper gauge of wire to use, if you’re soldering you’ll want to get wire with as much insulation as possible.

A bent nail (left) is great for fishing a wire line out of a T junction. By attaching a nut to the end of a wire (right) you can use a magnet to guide the wire through complex structures.

Chandelier in progress.

When running wire ensure that you leave at least 2-3 inches extending out of each pipe and when splicing be sure to maintain the proper polarity — striped or two different coloured wires helps with this. Once wired it’s time to epoxy or solder any final joints, if you’re soldering you run the risk of melting the wiring insulation, to avoid this remember that these joints do not have to be waterproof, just a small amount of solder will hold the joint. Be sure to use flux and have a spray bottle with water ready, quickly get the pipe up to heat, apply the solder and as soon as it’s solidified use the spray bottle to cool down the pipe to help prevent any damage to the internal wiring.

Once you’re done soldering you can test the wiring for faults with a multimeter, check for faults between the two polarity wires and from each wire to the chandelier structure. If there are any faults you’ll have to open things back up, you can re-flow solder to separate parts, not sure what you’d do if you used epoxy and then found a fault :O

To attach the sockets simply strip and screw the wire to each pole on the socket and then wrap them in electrical tape. While not essential, it’s good practice to maintain the same polarity across all sockets, to do this keep track of which wire you’re attaching to the brass pole and which to the silver pole on each socket. Once wrapped in electrical tape you can push them into the pipe ends.

Bulb socket and pipe fitting after white rustoleum and pearlescent acrylic.

Once you’ve got all the sockets affixed you should test for faults again with your multimeter. If no faults are found between the wires or to the structure you can test the fixture by attaching a 120 volt wall plug to the end and giving it a go. If all goes well you can move onto finishing.

I thought, while great looking and oozing steampunk, that the bare copper was a little too hardcore for my infant son’s nursery so I decided to paint the fixture white and use a pearlescent acrylic on the pipes. The sky’s the limit here, but copper is expensive so, if you can, show it off! If you do paint be sure to stuff some paper towel or toilet paper into each of the sockets so that the bulb leads don’t get paint on them.

Once it’s dried you can test it again with the multimeter (can’t be too careful) and then hang it. I ended up using a dimmer with a remote on this fixture so that my wife and I could adjust the lights while minding to the baby and it works like a charm. Good luck! I’m happy to answer any questions in the comments.

 

Fiber optic starry sky nursery

Getting a house ready for a new baby is no small task, there’s really no end to what one may consider essential, such as a fiber optic star-filled ceiling for the nursery. There’s nothing more comforting to an infant than the feeling that they’ve been left in the woods under a wondrous, awe inspiring, night sky — no?

Thankfully there are some great products available to convey just that feeling with the use of fiber optic cabling. Wiedamark offers a number of kits as well as the separate components, which are basically bunches of fiber optic cabling and a light source or illuminator. I opted for their 288 3 Star LED Fiber Optic Star Ceiling Kit With New Dimming Feature, it comes with everything you need for a drywall install (aside from tools) and includes 3 different diameters of fiber optic cables which translate to different sized stars or planets.

While waiting for the kit to arrive my wife and I decided on a night sky to represent. Our first child is due in December so we chose the night of the Winter Solstice this year, December 21st, 2014, or at least what the night sky should look like barring some unforeseen astronomical event. There’s some handy sites online you can use to generate a star map on which you can base the ceiling. We used Your Sky which generates images based on date, location and a number of useful options. The easiest way to get your latitude and longitude if you don’t already have it is to find your home on Google Maps and grab your lat/long from the address bar, it will look something like this 43.650033,-79.391594. Positive latitudes, the first number are North and negative are South. Positive longitudes, the second number, are East and negative are West. So when using the above coordinates in the Your Sky interface it would be 43.650033 North by 79.391594 West. You can also turn on and off constellation names and such as well as select what magnitude of objects to display. For printing purposes it’s useful to change the output to Black on white background, if you’re printing in colour this may not be the case. It’s also useful to increase the image size, something around 2400 x 2400 should do.

Once you have a sky that you’re happy with you can right click on the resulting image and select save image in your browser, you’ll end up with an image aptly entitled Yoursky.gif. I decided to divide the image into a grid in order to make it easier to transfer the star positions to the ceiling. This step is completely optional as you can just wing it if you like, create your own constellations and such, though you run the risk of creating an awkward cluster of stars that you’ll end up focused on for years to come.

I won’t go too far in-depth with the install instructions as I’ve recently found another fellow has here, in addition, Wiedamark has a variety of instructions available here. I will, however, outline some of the differences in my approach. You should note I placed the light in my attic, this requires an electrical outlet in the attic, you can also place the light source in a closet or the corner of a room. I also placed the light source in a large plastic storage bin with holes for the power and fiber optic cables to isolate it from the blown insulation in my attic. The light source does need ventilation so ensure any container is large enough for ample airflow and is not sealed.

Two things made my install quite a bit more difficult than a typical install, the first is that the target ceiling, and most of our house, is plaster lath and the second is that our attic has about 3 feet of blown insulation piled on top the 2nd floor ceilings. Step one should have been to clear away the insulation from the ceiling, I was impatient and only did this after I drilled many of the holes and promptly regretted it. Clear the insulation first, everything will go much faster. If you don’t have much space in your attic some good knee pads will go a long way to avoiding aches and pains, you’ll be up there for a while.

The typical method of install for these star fields is to drill through drywall from above and feed the fiber optics down through the drilled hole. Those of you familiar with plaster lath may see a problem with this method — plaster lath enjoys cracking off in large chunks, especially if you’re drilling through from the unfinished side. Because of this I decided to drill up through the ceiling, which reduces the plaster cracking, and insert a placeholder wire into each hole which I could then locate from the attic in order to replace with a fiber optic cable. For the kit I selected I needed three different colours of wire, one for each size of cable/star. I chopped this wire into lengths of 4 or 5 inches, one length of wire for each star. When transferring the star map to the ceiling be mindful of your cardinal directions and take some time to ensure that you’re orienting the map correctly, or not, it doesn’t matter all that much in the grand scheme of things — then again, maybe it is the grand scheme of things!

If you’re dealing with drywall you can skip this entire step, if you’re taking my approach you’ll end up with something like this after drilling and inserting placeholders.

Try to match both the drill bit size and the wire to the fiber optic cable diameter as closely as possible, this will contribute to a clean finished install. I found it difficult to find drill bits small enough, but they are out there.

The next step is to head up to the attic and feed fiber optic cable down through each hole, drilling down if you have drywall and replacing the placeholders if you have plaster lath and have already drilled from below. An LED headlamp helps quite a bit if you don’t have lighting in your attic. The hardest part (aside from back aches and sore knees) is keeping the fiber optic bundles organized, fiber optic cable will craze or crack if bent and that will impede or interrupt the light flow through that cable, so be gentle. It seems easy to pull cables off at first, but eventually everything will be a tangled mess if you don’t take your time to stay organized from the beginning. It helps to first separate the different sized cables into their own bundles. Be sure to push each cable at least a couple inches further than you need through the holes, you’ll clip them flush only after you’ve patched and painted any ceiling defects resulting from the install. Once you’ve placed a star and are sure it’s extended down through the ceiling by a couple of inches then put a dab of glue where it enters the ceiling from above to keep it in place. Use a glue thick enough so that it doesn’t drip through any extra space or along the cable.

This is the most time consuming, frustrating and potentially painful part of the process and is best done in stages. On the upside I bet you never thought you’d find yourself grappling for hours on end with a nightmarish deep sea monster.

Once you’re done running the fiber optic cabling you’ll end up with some trippy, glowing, alien grass growing out of your ceiling, don’t trim it just yet.

Now it’s time to patch and paint over any holes you didn’t use and any other ceiling damage that occurred during the install. It’s important to do this before you trim the cables so that you don’t paint or patch over any illuminated ends. Once you’re done patching and painting you can use flush cut pliers, or even nail clippers, to trim the fiber optic cable flush with the ceiling. After a couple of days and you’re confident there’s nothing left to do in the attic as far as corrections or the like, you can replace any insulation and pat yourself on the back.