Here a SimpleViewer Flash gallery should be displayed. Click here to open the post in your browser to see the gallery.

When I first became interested in high speed photography I discovered the site Hiviz.com. This extremely useful site is where I learned about using flash strobes to capture fast-moving objects. Using the circuit diagrams provided here I built a 555 timer-based delay and trigger circuit for my camera flashes.

The idea in a delayed trigger is to sense the droplet outside of the view of the camera then take the picture when the droplet falls inside of the frame. When I take these pictures I hold a dropper about a foot and a half above a bowl. I place an infrared emitter/receiver below my hand to sense the droplet when it first leaves the dropper. Then, after a specified amount of time (depending on the sensor’s height above the bowl) the flashes fire. By calibrating this time correctly I make the flashes fire directly after the drop hits the water.

Using the same delay yields almost identical images. These are six consecutive pictures taken using my controller.

The shutter is usually left open for this entire process. These pictures are taken in a darkened room so that the ambient light had little or no effect on the exposure. When the flashes fire they are much brighter than the ambient light and they freeze that moment onto the film/sensor. This makes the flash duration the effective “shutter speed” for the picture.

The 555-based circuit from hiviz.com worked well and I got some great pictures. I am very grateful for all the detailed information about high speed photography they provide. But after I used their circuit a few times I started to get frustrated. Using a potentiometer to control the timing was imprecise and cumbersome. It was easy to bump a knob and lose my work “calibrating” the system. I also found myself swapping out components when I needed to drastically alter the delay time.

As a solution to these problems I designed my own “High Speed Controller” using a microcontroller. This controller is programmed on a 18F series PIC microcontroller. You can adjust the input characteristics, flash timings (down to the millisecond), and shutter duration using a rotary encoder and an LCD screen. It supports up to four flashes and two cameras — although more can easily be added. Each flash can be individually timed. And since you can adjust the characteristics of the sensor you can use a variety of trigger devices (I have tested it using both a photogate and a computer microphone)

The following menu items are used to adjust the behavior of the controller. You use the rotary encoder to scroll through the menu items, then use the button to select a particular item.

Sensor Threshold – Each sensor plugs into an analog/digital converter on the PIC. The sensor threshold is the value at which the sensor is triggered. For convenience, the current value of the sensor is displayed as you adjust the threshold. The above picture was taken as I was adjusting the sensor threshold.

Sensor High/Low – This tells the controller if it should trigger when the sensor is higher or lower than the threshold value.

Shutter Delay – If enabled, this delay waits a specified amount of time after the trigger event before opening the shutter.

Shutter Duration - This is pretty self-explanatory. The nice thing about having the controller open/close the shutter is that you can take pictures in a moderately light room. With shutter durations in the 100-200ms range the ambient light of the room becomes less impactful on the final image.

Flash Delay 1, 2, 3, 4 – Each flash can be individually timed. I usually have them go off simultaneously but I like having the option of having them go off in sequence.

Execute – This causes the PIC to enter a delay loop waiting for the sensor conditions to be met.

Shutter Control -  This menu items was necessary due to some limitations in my camera. The Canon 20D I use to take these pictures has a delay of ~70ms from the moment it recieves a signal to the moment the shutter opens. This often isn’t an issue since the delay for water droplets is often greater than 200ms. However, in case I need to capture less than 70ms from the time the sensor is triggered I needed an alternate way to control the shutter. This menu option has two options:

Normal: The shutter opens after the sensor is trigger.

Fast Object: The shutter opens as soon as you hit “execute”. It still turns off based on the “shutter duration” value after the sensor is triggered.

If you are interested in building a controller for yourself I have created a board and released the source code.

Unfortunately, neither are well documented for now — so you may have to work a little to understand how to use them. After I catchup with my website I will update these files with well documented code. For now, please feel free to email me if you have any specific questions.

The source is available here. I compiled it using the C18 compiler provided by microchip. I controlled LCD using a library I found on piclist. It was written for the Hitech compiler and had quite a few errors in C18 so I had to rewrite some sections of it.

The board/circuit diagram can be downloaded here. I included inputs/outputs for a few more buttons and a few LEDs in case you want to implement some extra controls. Use eagle to open the files. If you want to etch the board you can do so using my etching howto.

You’ll need the following parts:

(1) PIC18F4685 (available as a free sample for students)

(4) EC103D SCRs

(4) 2N2222 transistors (or any small npn transistors)

(1) 4mhz crystal (optional– the current source actually uses the internal oscillator)

(1) LM7805 (optional — depending on your power source)

The technical details are important to capture water droplets, but your captures won’t look like art unless you spend some time controlling the light. You can experiment with using gels over the flash, hard vs soft light, and different backgrounds or floor coverings to achieve different effects.

Although my setup may seem complicated, most of these components can be found for pretty cheap.

Cameras – I used a Canon 20D and my friend used his Canon 40D to take the pictures. Any camera that you can externally trigger with a “bulb” setting should work for droplet photography.

Flashes – Old, manual, strobes are perfect for this kind of photography. I use two Nikon strobes from the 90’s that I found locally for cheap.

Umbrellas – You can get these for $10-15 a piece. But if you don’t want to buy umbrellas and stands you can use sheets of white paper to soften the light.

Dropper – I used a dropper meant to dispense chemicals in a fish bowl. Straws work.. but only as a last resort.

Paper/Backgrounds – I bought paper at Craft Warehouse.

Here are some pictures of the setup I used for most of the images on this page:

We decided to put our Christmas tree outside on the front porch this year. My mom had the idea of setting up the train under the tree and having it automatically move around the track whenever someone came up to the front door. She setup the tree and the train, my task was to make it move.

Normally I’d use a relay for this kind of project. Unfortunately this train is battery power and since its been in our family for over twenty years I didn’t want to modify it. Instead, I decided to use the built-in infrared communication to control the train. I opted to record the output from the infrared remote and emulate it using a microprocessor whenever someone comes to the door.

The first thing I did was record the infrared waveforms. To do this I soldered an infrared photo transistor to a 1/8″ phono plug (headphone jack) and plugged the sensor into my laptop’s microphone input. For each of the functions on the remote (Forward, Back, Whistle, Stop) I held the remote up to the the sensor and “recorded” the waveform of the infrared command. I essentially used the sound card on my laptop as a storage oscilloscope.

Here are some images of the waveforms:

Using Audacity, my audio editing software, I amplified each of the waveforms until they clipped. Then I lowered the threshold enough that I had good square waves to deal with. This make it easier to accurately measure the width of each signal component. The final signal I used to measure the pulse widths looked something like this:

Luckily, the encoding for these signals is easy to understand/duplicate. I found there were three durations I needed to record. Each high pulse was 1.5ms wide. In between each pulse is a delay. The longer delays are 4.5ms and the shorter delays are 1.75ms.

In order to stay organized, I decided to define some of the “building blocks” of the waveform. It seemed to me that the information being carried was stored in the delay between pulses, so I called the longer delays 0 and the shorter delays 1. If this seems a little convoluted, the following image summarizes the information structure by showing an example of 1-0-1:

Using this scheme, each of the commands is easily translated into a binary representation:

Forward: 001111101010
Back: 001111001011
Whistle: 001111111001
Stop: 001101001100

Incidentally, these correspond to 1002, 971, 1017 and 844 in decimal — there does not seem to be any significance to these values.

The next step was to write the software to mimic this behavior. I chose to use a PIC18F4685. While this pic is WAY overkill for this project, I used it because I already had the breadboard ready to go from a previous project. I can use the same code with any smaller 18f series PIC or if I ever want to make this a permanent fixture I can write the code in assembly and program a very small 12F series PIC to handle this basic task.

I wrote the code in C because I did not want to spend very much time on this project and I knew with delays in the order of milliseconds the timing wasn’t critical. Using C, the code took me about five minutes. First I wrote two functions to handle delays. The first, called “pulse” sets the enable pin, waits 1.5ms and brings it low again. The second called “gap” accepts a variable called “value” and delays accordingly. So the waveform in my example above (1-0-1) could be represented with the code:

pulse();
gap(1);
pulse();
gap(0);
pulse();
gap(1);
pulse();

It isn’t the most elegant approach but its functional and quick — perfect for this project. I also attached a button to the pic to trigger the infrared LED sequence. Debouncing the button wasn’t necessary because the series of delay loops after the button was pressed lasted for many seconds.

Having finished the code, I attached the signal pin from the PIC to the base of a PN2222 transistor to act as a buffer. Then I attached two infrared LED’s to the transistor in series with a 100ohm resistor to supply them with about 50mA of current. Early on I noticed the train wasn’t very sensitive even to it’s built-in remote, so I knew I’d need at least two emitters with a decent amount of current.

I held the LED’s up to the train and pushed the button– the train wheels began to spin, the whistle started, and ten seconds later the wheels stopped. Success! Now all I needed was a way to trigger the train when someone walked up to my front door.

I considered a few ways to trigger the the train. Initially I wanted to use a motion sensor to trigger the train whenever someone approached our front porch. Unfortunately, time and budget constraints prevented that option. If I improve this project in the future I think I will try to incorporate a motion sensor into my design.

The solution I decided to use instead was very.. home made — but it ended up working surprisingly well. I decided to create a sensor that detected when someone stepped on my front doormat. I used two pieces of aluminum foil, some tapes, and a few drinking straws.

First I lay down a long strip of aluminum foil with some straws placed evenly across the surface:

These straws will be used as “springs” to prevent a short circuit between two pieces of foil.

After laying the top piece of foil over the straws I fastened it down with some electrical tape and trimmed off as much unnecessary foil as possible. This was necessary to prevent any unintended shorts.

Next, I taped wire to each piece of foil and attached the foot sensor to my breadboard.

Finally, I placed the sensor under my front doormat. Now whenever someone steps on the sensor the two pieces of foil make contact and the PIC starts the train. When the person releases their foot the combined strength of the straws keeps the foil apart again.

The circuit has been in place two days at the time of this writing and so far it is working very well. The only thing keeping it from working perfectly is the train itself — occasionally it steers itself off the track. I’m going to add some more track segments to make the turns a little wider which should remedy that problem.

This project was a lot of fun for me. It gave me a chance to reverse engineer a product and provided me with insight about infrared communication. I am intrigued by the encoding method and would like to learn more. For instance, why did the product designers use the values they did for the infrared commands? Does this encoding have a name?

If anyone reading this has some insight I’d love to hear it.

Anyway, thanks for reading, I’ll leave you with some more pictures and a video.

The tree lit up at night.

The breadboard.

“Hiding” near my front door.

This is the original remote.

The train comes to a halt with the emitter pointed at the infrared receiver.

I’m sorry the video came out SO dark – it gets a little better after the first fifteen seconds. I will try to post another video when I get a chance.