Note: If you don’t see a change, the second image is here. Also, please let me know- I’d like to hear if this isn’t a good solution for rollover images.

Rollover code from 700i Webmaster Tips.

It counts as a thing-a-day because I helped organize it and brought the snacks .

To make a stop motion video from a set of images: (Make a backup of them first!)

mogrify -resize 640x480 *.JPG
mencoder -ovc lavc -mf w=640:h=480:fps=20:type=jpg 'mf://*.JPG' -o time_lapse-test.flv

Note: If the frames also need to be rotated, run them through mogrify with the -rotate option first. I had to do this twice before it had an effect, presumably because the rotate flag was set in the jpeg headers.

I started off with a 555 timer VCO circuit that I found at ecelab.com. Next, I hooked up a Sharp GP2D120 infrared distance sensor that I had laying around from another project, and added a cheap level shifter to allow the sensor to control the oscillation frequency of the 555 timer. Once that was basically working, I played around with the potentiometers until I had a range of sounds that seemed reasonable.

The schematic ended up looking like this:

Once I had the prototype working on a breadboard, the next step was to transfer the design to a perfboard that would be suitable for mounting in the hat. The top picture here might look somewhat neat, but believe me when I say that it is a complete hack job underneath. Hey, though, it seems to work ok.

Finally, I put the module together with a battery, speaker and (momentary) on switch, and Velcroed each piece to the (except the switch) inside of my hat. I cut a small slit in the side of that, ran the wires for the switch through that, and then stuck the switch under one of the side curls on the outside. This way, you can start playing music by picking up the hat as you normally would, but also catching the switch in the same motion.

Why is this useful? The flash is a very small light, so it comes off as a hard light source when mounted to the top of a camera. By bouncing the light off of a larger diffuser, it effectively becomes a bigger and less directional light source, which softens shadows and evens out the lighting from the flash. At least, that is how I understand it. Tutorial after the break.


Step 1: Gather parts

You will need:
* Two pieces of craft foam, approx 9×12 (mine were twice this size)
* Large needle (24?)
* Black thread (25?)
* Some sticky back Velcro
Not pictured:
* an old folder or other 8×11 inch piece of thick paper
* strip of velcro or rubber band (to attach it to the flash)

Step 2: Cut the foam

Using the template from Chuck Gardner’s tutorial, measure and cut out the black and white pieces of foam. To accomplish this, I used a sharpie and ruler to draw out and mark the cuts that needed to be made on the white piece of foam. Once the pieces were cut, I flipped them both over in order to hide any remaining markings.

Insiders Tip: The measuring can be made easier if you get a friend to assist you:

Step 3: Cut the cardboard stiffener

The cardboard stiffener is placed in between the two pieces of foam to help the reflector maintain its shape. I found an old folder to be a good size and strength for this. There isn’t a template for this step, but you want to bring the edges of this pattern in 1/2″ from that of the foam. The idea is to have the cardboard cover most of the inside of the diffuser, but to leave room along the edges so that it can be sewed together. When you have it cut out, compare it to the foam cutout. It should look like this:

Step 4: Sew it all together
The sewing part isn’t too complicated, but there is one crucial step that must be taken first: Photograph yourself looking manly. This is important to use as a rebuttal in case you are teased about sewing. Here is mine:

Insider’s Tip: The mustache is the manliest kind of facial hair you can grow.

Once you have it sewn together, it should look like this:

Step 5: Add velcro and done!

The final step is to add some velcro to the foam in order to hold the section down. If you are using the self-adhesive kind, just peel off some squares and stick them on. Also, you can use a velcro strap around the bottom to hold the diffuser to the flash unit. I forgot to pick one up at the store, so I am just using a rubberband and it seems to work ok.

Step 6: Enjoy!

The most straightforward approach to this would be to take apart an existing remote and fire its button with a microcontroller. However, that didn’t sound like much of a challenge, so instead the goal became to train the micro to output the signals itself. A quick search fished out a well-documented solution by one San Bergmans. The routine is written in assembly to generate an accurate signal. I chose the Arduino as my platform, and figured out that it is pretty straightforward to include assembly inside of a C++ file. So, I ported San’s code to the Atmega168 that my Arduino is based on, and it appears to work quite swimmingly. The routine is wrapped up in a library, so using it is as simple as adding the library to your project and calling the Snap() function. There are a couple of caveats to this code,though: it (currently) only works on pin 12, and will only support the default clock frequency (16MHz?). Code after the break.

To use these, place them in a folder named NikonRemote, which should be located in the hardware/libraries/ section of your Arduino installation. Then, restart (or just start) the Arduino program, add the library to the project, and create the object in your sketch:

NikonRemote remote(12);

Whenever you want to trigger the camera, just do this:

remote.Snap();

Oh, and don’t forget to attach an IR LED to pin 12, with some sort of current-limiting resistor. Tip: You can test if the IR LED is in the correct orientation by powering it up and looking at it with a digital that has a live preview.

NikonRemote.h:

#ifndef NikonRemote_h
#define NikonRemote_h
 
#include "WConstants.h"
 
class NikonRemote {
  public:
    NikonRemote(unsigned int port);
 
    void Snap();
 
  private:
    unsigned int _port;
};
#endif

NikonRemote.cpp:

//
// NikonRemote
//
// This is an evil Arduino library that uses inline assembly to generate an IR
// signal capable of triggering a Nikon SLR camera.
//
// By Matt Mets, October, 2008.
//
// Adapted from San Bergman's 'ML-L1 / ML-L3 IR remote control replacement'
// http://www.sbprojects.com/projects/nikon/index.htm
//
// Note: At time of writing, it isn't clear what license it can be used under.
//       I will contact the author about this.
// Note: This is an incomplete implementation.  It requires the output LED to
//       be on pin 12.
 
 
#include "NikonRemote.h"
 
NikonRemote::NikonRemote(unsigned int port)
{
  pinMode(port, OUTPUT);
  _port = port;
}
 
 
void NikonRemote::Snap()
{
// Definitions:
// r16: port ON value
// r17: port OFF value
// r18: burst delay counter
// r19: burst counter
// r20: end delay counter
// r21: port mask
 
// 0x03: Port B input register
// 0x05: Port B output register
 
  asm volatile (
 
"\n\t cli"              // Disable interrupts
 
"\n\t push r16"         // Save context
"\n\t push r17"
"\n\t push r18"
"\n\t push r19"
"\n\t push r20"
"\n\t push r21"
 
"\n\t in   r16, 0x03"   // Calculate on and off port values
"\n\t ori  r16, 0x10"
"\n\t in   r17, 0x03"
 
"\n\t rjmp COMMAND"     // Jump to the command routine
 
"\nNEXTPULSE:"
"\n\t ldi r18, 68"      // Count to 9 for one low pulse
"\nSENDBURST:"          // Low period delay loop
"\n\t dec r18"
"\n\t brne SENDBURST"
"\n\t nop"
"\n\t out 0x05, r21"    // Set the output to mask
"\n\t ldi r18, 68"      // Count to 9 for one high pulse
"\nBURSTLOOP:"
 
 
"\n\t dec r18"
"\n\t brne BURSTLOOP"
"\n\t out 0x05, r17"    // Set the output low
"\n\t dec r19"          // Determine if another burst should be performed.
"\n\t brne NEXTPULSE"
"\n\t ret"
 
"\nCOMMAND:"
 
// 2000us on
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 76"      // count = 76
"\n\t mov r21, r16"     // Mask on
"\n\t rcall SENDBURST"
 
// 28ms off
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 250"     // count = 250
"\n\t mov r21, r17"     // Mask off
"\n\t rcall SENDBURST"
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 250"     // count = 250
"\n\t mov r21, r17"     // Mask off
"\n\t rcall SENDBURST"
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 250"     // count = 250
"\n\t mov r21, r17"     // Mask off
"\n\t rcall SENDBURST"
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 250"     // count = 250
"\n\t mov r21, r17"     // Mask off
"\n\t rcall SENDBURST"
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 64"      // count = 64
"\n\t mov r21, r17"     // Mask off
"\n\t rcall SENDBURST"
 
// 400us on
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 15"      // count = 15
"\n\t mov r21, r16"     // Mask on
"\n\t rcall SENDBURST"
 
// 1580us off
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 60"      // count = 60
"\n\t mov r21, r17"     // Mask off
"\n\t rcall SENDBURST"
 
// 400us on
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 15"      // count = 15
"\n\t mov r21, r16"     // Mask on
"\n\t rcall SENDBURST"
 
// 3580us off
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 136"     // count = 136
"\n\t mov r21, r17"     // Mask off
"\n\t rcall SENDBURST"
 
// 400us on
"\n\t ldi r18, 65"      // initial pulse = 65
"\n\t ldi r19, 15"      // count = 15
"\n\t mov r21, r16"     // Mask on
"\n\t rcall SENDBURST"
 
"\n\t pop  r21"         // Restore Context
"\n\t pop  r20"
"\n\t pop  r19"
"\n\t pop  r18"
"\n\t pop  r17"
"\n\t pop  r16"
 
"\n\t sei"              // Enable interrupts
"\n\t"
  );
}