High-speed photography with high-power LEDs

Inspired by this Video, I was experimenting with high-speed-macro photography last week. After some research I found this informative series of articles on high-speed photography and a little but powerful helper called Arduino.


One important thing to understand here, is the technique I used to capture those very short moments. It´s better explained in one of the previous mentioned articles, but in short: The exposure time here is not defined by the shutter-speed of the camera (in fact the shutter is open for about 2 seconds), but by the amount of time the flash is illuminating. This is because a light-emitter can be controlled much more precisely than a mechanical device like a camera-shutter.

While fiddling with an Arduino and an old Revue-Flash I got from my fathers old photo equipment, I sadly broke the flash by accidently feeding a +5 voltage to its input pins. Everytime I brake a thing while experimenting, I demand myself to make the best of the situation. This could be to take a valuable part out of the broken device for  something different, I wouldn’t think off otherwise, for example. In this case since I had no flash anymore, I was looking for an alternative light emitter and found a high-power LED, I used in another project. It showed, that loosing my fathers old flash was worth the experiences I problably wouldn’t have made else.

Why LEDs?

There are many discussions on the web on whether building a flash with high-power LEDs is a good idea or not. Here is an interesting Video about the problems building a high-speed (1 µs) LED flash.

LEDs definitely have some very interesting features worth playing with:

-If a conventional flash is triggered, it illuminates for about 1/5000 – 1/20000 second,    depending on the power it was loaded with. So compared to LEDs, you can´t control the light duration and density independantly.

-LEDs can of course also light constantly. A normal flash flashes for about a 1/5000 second, whatever your camera exposure setting is. A LED based flash can light for the whole exposure time.

-A LED needs no loading time, so you can do as many short intervalled flashes you  like in straight succession.

-LEDs can do extreme short flashes (less than 1µs), making them atractive for people who want to experiment with (very)high-speed photography, without buying an air-gab flash for 20 000 bugs.

-According to this paper,  a high-power LED can easily take 20 times more current than its specified continous forward current, if it is driven by very short pulses (more current, more brightness).  

Here is what I did

Things I used:

– Arduino uno

– breadboard, wires and other prototyping tools

– two 12v pb batteries

– a high-power LED

– an airsoft electric gun

– a small servo

– a distance sensor (like this one: QTR-1A)

– an ir-diode

Like the guy in the first video, I wanted to have the whole process of taking pictures to be automatically processed on trigger. I used three actors in this process:

The Camera

I have a Sony Nex-6 which doesn´t have an electric remote connector, but has an ir-sensor for remote triggering. Using an Arduino for ir-triggering is easy, all you need is an ir-diode, a resistor and this Arduino library: http://sebastian.setz.name/arduino/my-libraries/multi-camera-ir-control/          Setting the camera to bulb mode allowed me to send one trigger to open the shutter and a second one to close it.


In principle it is easy to switch a LED very fast on and off. For a high-power LED the arduino pins of course can´t provide enough current, but a simple transistor would do the trick. To protect the LED from burning out, the max current has somehow to be limited. The simpliest way to do so is using a resistor. What makes the thing complicated, is that we want to overdrive the current consciously for a very short time. So I´ll have a closer look into the mentioned paper and build the driver circuit described there. For my experiments, I worked with 5 volts and a 1ohm resistor, switched by a normal npn-transistor. I was very excited to see how short the arduino-LED combination would be able to expose.

The Airsoftgun

I knew some day I would do something productive with this interesting piece of technology. Since I wanted to find out what would be possible in terms of exposure time and light output, I needed some very fast and reproducable process I could photograph. So my old electric airgun came to my mind. With a little servo mounted with hotglue on the trigger it was easy to make it remote-triggerable. The second problem was the bullet sensor I decided to need, because the timing derived from the moment the servo was triggered would not be accurate enough. Luckily I had a distance sensor flying around. I mounted it as near as possible to the opening of the barrel. Prior attempts with an ir-diode and a photoresistor brought no luck. Maybe the inertia of those photoresistors are too high?

The Software

I put the Arduino sketch I wrote to manage the process to the end of this post. After pressing the trigger button, the arduino starts the following sequence:

1. open the camera shutter

2. pull the trigger of the airgun

3. after sensing the bullet, wait a certain time.

4. light x times for y time with z time in between.

5. close the shutter

6. release the airgun trigger

The Results

ImageThis is one of the first trials. The horizontal white stripe is the bullet of the airgun. The expose time is 1/1000, I think. Unfortunately, the camera can´t save the real expose time to the exif-files. As you can see this is way too long.

ImageThis is better! The expose time is about 5µs (1/200 000sec). You can see the distance sensor I mounted on the barrel. The LED was programmed to flash instantly when the sensor reacts.

ImageHere I timed the delay between the sensor reaction and the flash to capture this moment of destruction. The delaytime is 1500µs, the exposure time 10µs. I was pretty happy with this result, although the light is not enough to have  low iso and a wide aperture settings you would need to get everything clean and sharp.

ImageThe accuracy of the timing is good enough for reproduceable results. With 20µs, the expose time is a little longer than in the picture before.

ImageHere is another example of what you can’t do with  a regular flash (because of loading and expose times).

ImageIt was fun to play with the timings! On the right you see the provisional back stop I had to build to save the little amount of bullets I had.


So I’m very happy with what I’ve achieved in the two days of experimenting. I’m also optimistic to achieve much better results in the future. I have learned that it’s possible to switch an LED on and off in an increadibly short amount of time. Even nanoseconds should be possible if you program the ports of the Atmega processor of the arduino directly. It was really thrilling to dig into this micro-time-world.

To get better results, there are two main options: More LEDs and/or more current. First option is rather simple but not cheap. I ordered 15 Cree XM-L T6 for 7€ each. They were the brightest LEDs I found. With a heat sink they can take 3A at 3.3V continously, which leads to my second option, the current. Since I´m not very firm with designing circuits, this is the bigger hurdle for me. I want to make three groups a 5 LEDs, so that I can arrange them in three different positions. If I make good progress I will write another post. For now thanks for reading!

Arduino sketch

#include <multiCameraIrControl.h>
#include <Servo.h>

Servo myservo;
int flashpin = 6;
int triggerpin = A0;
int sensorpin = A1;
int pos0 = 30;
int pos1 = 95;
int counter = 0;
int onoff = 0;

int ontime = 10;
int burstofftime = 80;
int flashdelay = 1700;
int shots = 1;

Sony A900(9);

void setup(){
pinMode(flashpin, OUTPUT);
digitalWrite(flashpin, LOW);


void loop(){

int triggerValue = analogRead(triggerpin);
if (triggerValue > 300) {
onoff = 1;
if (onoff == 1){

while (onoff == 1) {
triggerValue = analogRead(triggerpin);
softair ();
digitalWrite(flashpin, LOW);

counter = 0;

onoff = 0;


void shortflash2 ()
while (counter < shots){
// delay(154); the time the ir shutter needs
digitalWrite(flashpin, HIGH);
digitalWrite(flashpin, LOW);
counter = counter + 1;



void softair ()

int sensorValue = analogRead(sensorpin);


if (sensorValue < 900) {
shortflash2 ();
// Serial.println(“hit”);
onoff = 0;


2 thoughts on “High-speed photography with high-power LEDs

  1. Hola! I’ve been reading your web site for a while now and finally
    got the courage to go ahead and give you a shout out from Huffman Texas!
    Just wanted to tell you keep up the excellent work!

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s