I’m quite happy with the result; there are some slight light-dark flickers which I don’t like, but those are probably caused by glare from the sun shining onto the side of the lens. By now I’m convinced that a prerequisite to getting good results using an SLR is to turn off autofocus and set your exposure values and f-stops manually – you can’t trust your camera to keep the values smooth.

You can find info about stitching jpgs into a movie on Metafilter.

[Something Awful: Unnecessary Advertisments]

+++

Ah, a new day, a new Wordpress version… you don’t see it, but I finally updgraded.

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:

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.

Features

• 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)

Code

// 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)

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 at (intervaluino a_t sporez do_t com)!

[Link - YouTube video, 18min]

[Article: Designers Reenvision Blimps]

see also my old post: Whales of the Sky

“Kidnappers have negotiation power: They have something you want, namely the life of a loved one. However, they are dealing with a market of one – so they can only sell to you.”

- from Burn Notice

From: Virgil Adair <fielddoc03@hotmail.com>
Date: Jan 9, 2008 7:27 AM
Subject: God

Vacuum Triangle Horse Family

Doesn’t this have a dadaist quality to it? Especially since it doesn’t contain any links!

“I get shit done.”

How can you not vote for a candidate like this? If you agree on the shit, of course.

•  16. Microsoft’s PR firm gets an address wrong
• 22. Co-op Funaral Care recycles its clients
  
• 29. Swiss Newspaper Sonntagszeitung will publish anything
• 33. Oral B’s bad vibes
  
• 38. Google’s malware protection
  
• 46. J&J’s brand protection
• 49. German screw(ed) factory
• 51. Apple’s customer focus
• 70. Circuit City’s war on talent
• 78. Virginia Tourism’s gangbanger ads
• 85. Singapore Airlines’ Mile High Club

Link (via the Fake Steve Job blog)

We talk a lot about simplification: “How can we make things easier, i.e. less complex?”. If that’s not possible, the question shifts towards integration: “How can we oversee and understand complex matters?”. Out of this question rises the need for process maps and flowcharts, information and reporting systems, KPIs and scorecards.

The constant, yet often overseen dilemma in all of those integration approaches is the fact that every integration of complexity has to lose some of its information. There’s no way around it: You can’t make a PowerPoint slide simpler by just reducing the font size. And the more unimportant information you delete (=integrate), the likelier the chance that you will lose real important information. On the other side, however, is that keeping ALL of the information is not only hard to digest (=complex), but also costly to maintain.

In other words: The devil is really in the details. The ones you keep, and the ones you delete.

So next time you want to create a system to integrate your data, map your processes, summarize your information, and feel it just doesn’t contain the level of detail you want – ask yourself: Wouldn’t it be easier to put away the map, and take a look at reality itself?

[this entry was cross-posted from my work blog]