The intervaluino is now on GitHub. If you would like to contribute or participate, this is the place to go!


If you liked the Intervaluino, check out the  Intervaluino Plus project by Enekochan!


This post was featured on the MAKE blog! [link]!

If you want to see a time-lapse video made with the Intervaluino, check out my time-lapse videos.

Furthermore, there is a good technical discussion going on at the Arduino forum.

If you liked the intervaluino, then 


I’m very much into electronics right now. As a child, I received this awesome collection of circuit diagrams with instructions on how to build blinking light machines or light sensor alarm systems – and I’ve built them all (although I didn’t understand most of the theory behind it).

Now, I’m back onto electronics – thanks to my video projects. Over the last two months, I made four time-lapse videos; clouds, cities, pizza and strawberries. The problem I encountered was that while my camera can record videos up to 27 hours (internal HD + strong compression), compressing more than 4 days of video is a resource-hogging process.

So I decided to use my photo camera for time-lapse shots; to do that, I needed a so-called intervalometer – a device that times the shots to regular intervals. But those are expensive, and even the cheapest consumer device I found costs $140 – not counting cables, AC adapters or S&H.

So I decided to build my own.

The friendly neighbourhood hive mind pointed me towards getting a microcontroller. I decided upon the wonderfully open source gadget Arduino, which I had read so much about in MAKE magazine. After some basic Arduino training I started working on the hard- and software for my own intervalometer.

And here it is:

Full view of the (packaged) Intervaluino Intervaluino\'s insides

I call it Intervaluino, and it does exactly what I want him to do: Tell my Canon EOS 400D to take pictures at regular intervals. Wanna build one yourself? Please follow me.


  • Programmable intervalometer, based on the Arduino microcontroller
  • Works for Canon cameras that use a 2.5mm stereo jack-controlled remote shutter release (EOS 300D, 350D, 400D, DigitalRebel)
  • Powered by USB, AC adapter or 9V battery
  • Timing programmable via the Arduino programming interface
  • Start/stop push button
  • Focuses before shooting
  • Maximum interval between shots: 24 days 20 hours
  • Published under a Creative Commons -by -nc -sa 3.0 license: Use it, share it, change it, as long as you tell it’s based on my work, don’t use it commercially, and use the same license for derivatives.

What could be better:

  • Should have multiple pre-programmable interval settings, for photo trips
  • Interval tuning via potentiometer
  • Stop button doesn’t work too well at long intervals (you need to press the button until at least one interval passes)

It’s not perfect, neither its hardware nor its code. But it fulfills my initial requirements.

Required Parts

  • 1 Arduino (I used the Diecimila model) –
  • 3x 100 ohm resistors
  • 1x 10k ohm resistor
  • 2 x 5V reed relays (NO = normally open)
  • 1 x push button of your choosing
  • 1 x 2.5mm male stereo jack
  • 1 x 80 x 50 mm strip board
    (alternatively: bread board or Arduino protoshield)
  • Assorted wires
  • Arduino USB cable
  • Arduino AC adapter OR Arduino 9V battery pack
  • Basic electronic tools to cut and de-isolate wires and to solder components (if you use a strip board), maybe a multimeter to test connections
  • A nice box
  • 20 cm of thin steel cable (used as a loop to attach the Intervaluino to the tripod)

Circuit Diagram (click to enlarge)


// Intervaluino
// this code programs the Arduino as an intervalometer for a Canon EOS camera, using two relays and a push button
// this enables you to create time-lapse movies with your camera.
// change the variables "full_time" and "short_time"  to automatically calculate the right time interval (based on 25 frames per second)
// upload the code via USB, fire up the Arduino, plug it into your camera's remote shutter release, and press the Intervaluino push button.
// press the button another time to stop the sequence (doesn't work that well if your interval is long)
// make sure to turn on single shoot
// (c) Lord Yo 2008 (intervaluino a_t sporez do:t com)
// Licensed under a Creative Commons (Attribution Non-Commercial Share-Alike) license

/////////// Change these variables according to your needs

long full_time = 14400;  //full length time to cover (in seconds)
long short_time = 120;        //length of time-lapse movie (in seconds)

int shutter_on = 200;       //time to press shutter, set between 100 and 300
int shutter_wait = 5000;   //initial time to wait to begin sequence
int wakeup = 300;          //time to activate wakeup (focus)
int wakewait =200;         //time between wake and shutter

/////////// Further Variables ////////////

long shutter_off = (40 * full_time / short_time) - shutter_on - wakeup - wakewait;    //time to wait between shutter releases;

int outpin = 11;            //output for shutter relay from pin 11
int wakepin = 8;            //output for focus relay from pin 8
int switchpin = 2;          //input from button from pin 2

int val;                    //value of button press
int buttonState;            //check variable for change of button press
int on_off = 0;             //state of sequence (turned on, turned off)

/////////// Setup ////////////

void setup() {
pinMode(outpin, OUTPUT);        //outpin gives output
pinMode(switchpin, INPUT);      //switchpin receives input
pinMode(wakepin, OUTPUT);      //wakepin gives output

buttonState = digitalRead(switchpin);    //read value of the button

/////////// Loop ////////////

void loop(){

val = digitalRead(switchpin);      // read button value and store it in val

if (val != buttonState) {          // if the button state has changed...
if (val == LOW) {                // check if the button is pressed...
if (on_off == 0) {             // if the sequence is currently off...
on_off = 1;                    // turn the sequence on
delay(shutter_wait);           // wait the initial period
} else {
on_off = 0;                  // turn the sequence off

buttonState = val;               //switch the button state

if (on_off == 1) {                //while the sequence is turned on...

digitalWrite(wakepin, HIGH);   //turn wakeup/focus on
delay(wakeup);                 //keep focus
digitalWrite(wakepin, LOW);    //turn wakeup off
delay(wakewait);               //wait
digitalWrite(outpin, HIGH);    //press the shutter
delay(shutter_on);             //wait the shutter release time
digitalWrite(outpin, LOW);     //release shutter
delay(shutter_off);            //wait for next round


Photos and Wire Colors

(btw, the only reason why I used two stripboards was that I added another relay later and didn’t want to start from scratch; you can just use one slightly larger strip board)

Full view of the (packaged) Intervaluino Plugs of the intervaluino Intervaluino\'s insides

I used the following color coding:

  • black for ground
  • red for 5V (on the board) and for the connection to F (focus)
  • 2x green for the output channels on pins 8 and 11
  • yellow for the input channel on pin 2 (on the board), and for the connection to SH (shutter)
  • grey for the connection to CG (camera ground)

How to Build It

This is only a short instruction, which assumes that you can read simple circuits, understand components, and solder them.

  1. According to the circuit diagram, lay out the parts and wires on the strip board to find the right spacing configuration (as opposed to the pictures above, you can use just one strip board for all the parts – no need to use two separate ones)
  2. Solder the parts as per circuit diagram (make sure you test the relays – it took me a while to figure out what triggers what!) – don’t connect it to the Arduino yet
  3. Solder the stereo jack to the wires (red, yellow, grey) according to the wiring diagram
  4. Compile and upload the Intervaluino code via USB
  5. Detach the Arduino from USB
  6. Connect the strip board to the Ardunino (pins 2, 8, 11, 5V, 3x GND)
  7. Connect the Arduino to USB again
  8. Wait a couple of second for initialization
  9. Press the button
  10. Test the device with a multimeter on the stereo jack: Every couple of seconds, the circuit between F and CG should be closed, shortly followed by the circuit between SH and CG.
  11. If it works, congratulations! (if it doesn’t, test your circuits thoroughly.)
  12. Plug the stereo jack into your camera’s remote shutter release
  13. Turn on your camera, focus it on something brightly lit, and set it to single shot
  14. Repeat steps 7-9. Your camera should now shoot a picture every couple of seconds
  15. Put it into a nice box, cut holes for the cable and the plugs
  16. To set your own intervals, follow the instructions in the code (change the values for variables full_time and short_time)

Some tips

  • Use a tripod
  • Set your camera to single shot
  • Consider turning off autofocus – if you follow a static object, you will only have to focus once.
  • For photo series above 1500 shots (or those with flash), get an AC adapter for both your camera and Intervaluino

I hope this is of use for you! If you have questions, want to let me know what you think, or want to share an Intervaluino time-lapse movie, please comment this post, or contact me!

5 Comments Add Yours

Leave a comment