The Selleck Striker ready for action.

Lisa about to show it who’s boss.

Beer pong!

That’s a lot of facial hair.

I used the nailgun with some trim nails to tack two layers onto the striker. It can probably use some trimming on the corners, but it will do the trick.

First I cut the copper tubes to length, drilled each end cap and JB-Welded 1/4″ phono plugs into each one. Then I soldered model rocket ignitors to the phono plugs’ contacts inside the caps. The gray boxes are aluminum project boxes with phono jacks installed in one side. These will be mounted to the back of the Selleck head, but for now they were a good way to hold each cap as I was soldering. I then assembled the tubes to the caps and used a little electrical tape to hold them together.

I cut each 8″ x 9″ sheet of flash paper into strips (across the short length),

folded all the strips in half together and twisted them loosely,

then stuffed the whole thing into the end of the tube.

Done!

The photo is deceiving… that thing is almost four feet high.

reset button – Before a new contestant hits the striker, the reset button clears the LEDs, then checks the difficulty setting and applies any changes. It’s a SPST, switching 5V from the Arduino to one of its analog input pins. High on the pin = reset.

play/demo switch – Demo Mode plays a scrolling LED effect, Play Mode waits for a change in the pressure (like a hammer strike!). This is a SPDT (though I could have just used a SPST) switching 5V from Arduino to one of its analog input pins. High on the pin = Demo Mode, low on the pin = Play Mode.

difficulty knob – Just a 100K potentiometer that sends 0 to 5V to one of the analog input pins. This will allow us to adjust how much force is needed to get to the top.

score display – This 3-digit numeric LED display will show the “score” of the strike. I’m still not sure how I’ll calibrate it, but the idea is that you get a finer resolution score than the 0-50 LEDs in front. I’m thinking of having this also display the “difficulty” setting when you twist the knob.

striker connector – This is an RJ-45 connection for the striker portion, so that the two halves aren’t permanently tethered to each other. I’m only using three of the eight conductors.

audio out - This 1/4″ mono jack will send sound effects and other audio to the sound system.

Also note the the three Arduinos in the bottom of the photo. The Mega on the right will handle the LEDs and input elements, the NG in the middle drives the 3-digit LED display, and the Duemilanove with the wave shield on the left plays the sound effects. They’ll be communicating via their serial ports.

It’s a loose interpretation…

The fire itself is created by igniting “flash paper”, which is a nitrocellulose paper used by magicians to create relatively safe indoor fire effects in their act. Basically the stuff flares up and it’s gone… no burning embers, hardly any ash at all. It is fire, but you can basically hold it in your hand, it’s there and gone that fast.

The flash paper is ignited by a model rocket engine ignitor, which is essentially a tiny incandescent filament with some flammable paste packed around it. You apply 6-12 volts with enough current and it flares up breifly, but plenty long enough to light the flash paper. The Arduino can’t supply nearly enough current to light it, so I’ll end up using a transistor to switch a higher-current (and slightly higher voltage) power supply to the ignitor.

For now I’m just concerned with the hardware. I’d like to have a replaceable “charge” that can be unplugged once it goes off, and replaced with a fresh one. So the sketch below shows a small metal tube with a 1/4″ phono plug on one end that plugs into a matching jack behind the Tom Selleck head.

The tube is copper and the end fitting just slips on snugly, but everything else turned out just like the sketch:

For now I’m using a 9V battery touched across the plug’s contacts. The trick, it turns out, is packing the right amount of flash paper in the right way. It took  a few tries, but I think the third attempt got it right:

So I figured an ascending object will decelerate in the same way a falling object will accelerate, since they’re both subjected to the same force (gravity). I found some formulas for acceleration due to gravity, particularly :

where d = distance, g = the gravitational constant, and t = time. I would calculate the trip from top to bottom as if the ringer was falling, then use that data in reverse.

The LEDs turn on in sequence, with a delay value in between to determine how long each one stays on (and how fast the “ringer” appears to move). So in order to determine that value I need to solve for t in the equation above. So:

I know that on Earth the gravitational constant — or g — is 9.8 m/s² (meters per second per second). I know the distance d between each LED is 1.37″, or .035m. So the time t_x to get from the very top LED to the next one is:

So the first .035m step down from the top will take 59ms. In order to find t_z for the second step, I need to find t_y for the total distance from the top to the second step (.035m x 2 = .07m), then subtract t_x for the first step:

So:

I need to do this for each of the 51 steps (50 LEDs plus the very top, the winner!). Actually, I’m not calculating this at all. I’ll let the Arduino do all the calculations, and save the delay value for each step in an array that it can quickly access when it needs to. Here’s how I did it in the Arduino script:

  float gravity_constant = 9.8;                         // the constant of gravity, or G
                                                        // we can adjust this to tweak the effect

  int gravity[50] = {};                                  // set up the gravity array

  for (int i = 1; i <= 51; i++) {                        // this will loop 51 times
    float distance_x = i * .035;                         // calculate the total distance from the top to the LED in question
    float distance_y = (i - 1) * .035;                   // same distance, minus one step 
    float time_x = sqrt(distance_x / gravity_constant);  // the time it takes for an object to fall distance_x meters
    float time_y = sqrt(distance_y / gravity_constant);  // the time it takes for an object to fall distance_y meters
    float time = time_x - time_y;                        // the time it takes for an object to fall to our LED from the one before it, in seconds
    int time_ms = time * 1000;                           // convert to milliseconds
    gravity[i] = time_ms;                                // add this value to the gravity array
  }

The gravity array will look something like [59, 26, 16, 14, 13, 12, 11, 10, 9, etc.......], dropping rapidly at first and then slower until it levels off at 4ms or so. If we then light the LEDs in sequence, applying these delay values to each step:

  int level = 48;             // this is the level the person hit to
                              // * entered manually for testing purposes,
                              // in the final product this will be determined by 
                              // the force of the hammer strike  

  for (int i = level; i > 0; i--) {
    digitalWrite(ledPins[level - i], HIGH);
    delay (gravity[i]);
    digitalWrite(ledPins[level - i], LOW);
  }

then we get something like this:

Note: the blinking at the beginning is the Arduino booting up, and the blinking at the end was added later to highlight the level of the hit.