The timelapse will be posted later on.

The top 3 audio traces are for the Canon 7D and show:

• a full cycle through mirror up/shutter open/shutter close/mirror down (manual exposure of 1/5 second (200ms))
• mirror up
• shutter down/mirror down

the lower three traces are for the Canon 40D camera.

If you right click on the image you can open the full size file in another window so you can see the timing down to a millisecond.

The audio recordings were taken using a Zoom H4n digitial recording system.

There is an excellent ‘timelapse’ of a Nikon D3 mirror/shutter operating here

Graduation Day 14th July 2010 from Kevin Lewis on Vimeo.

To achieve this the system precisely controls the timing of the bulb exposure when the camera is in bulb mode and can automatically ramp the exposure duration, up or down, to correct for the change in light at dusk and dawn.

The Birth of a Little Bramper from Kevin Lewis on Vimeo.

More information on the Little Bramper can be found here

Assembly Instructions and Cheatsheet

First timelapse attempt with the Little Bramper system using a Canon 7D and 10-22mm lens with the exposure being ramped from 50ms upto 3500ms including a iso step change from 100 to 200iso. Not perfect but the errors are down to me rather than the Little Bramper.

Cemaes Sunset Timelapse with Little Bramper from Kevin Lewis on Vimeo.

The Lockside Cafe at Grindley Brook is a very pleasant place to stop off for lunch or just a cup of coffee. Just off the A41 near Whitchurch the flight of locks provides a very scenic place for photography and with the cafe right on the side of the flight it doesn’t get much better.

A regular procession of narrow boats travels up and down the flight of locks and the dog, called Bee, from the cafe will soon have you trained to throw his ball for him to fetch.

The Lockside Cafe – Grindley Brook from Kevin Lewis on Vimeo.

The backing track “Llangollen Dreams” was written and produced by Ian H Bruce who kindly gave permission for it to be used on this video

View Larger Map

For more information on the village and the history of the locks click here

Cemaes Bay Sunset Timelapse from Kevin Lewis on Vimeo.

A quick time lapse of the sunset over Cemaes Bay on Anglesey in North Wales.

Canon 7D and twisted 10-22mm lens controlled by an arduino intervalometer.

The location of the Penmon Point Lighthouse is on the North East tip of Anglesey near the beautiful town of Beau Maris and it’s very attractive castle and location on the Menai Strait.

The system contains the Arduino Mega micro processor, a 20 x 4 LCD display, a TSL230R light to frequency convertor, the DT1307 real time clock and a SHT10 temperature and humidity sensor. Please note that the SHT10 sensor is not fully compliant with the I2C protocol, it will be replaced by the SHT21 sensor which is compliant.

The following arduino software code has been developed to control most digital cameras. It allows you to define the interval between photographs and the the length of the pulse to trigger the camera. If the camera is in Auto or Manual modes then the pulse length should be around 50-60ms; in Bulb mode the pulse length can be increased to accurately control the bulb exposure time or used for bulb ramping in a time lapse sequence.

The code has been developed to avoid the use of delay() functions, except in the setup loop, this means that the buttons and LCD display remain fully functional and exposure times can be changed between photographs.

Mechanical and electrical details of the project can be seen here

History
v1.5 – first release
v1.6 – added routine that saves Interval and Exposure values to EEPROM and reloads them next time the system is used. Press Red button on startup to load default values.
v1.7 – minor bug fixes relating to the LCD display, zip file updated.

The Arduino code can be downloaded from here as a zip file. Updated to v1.7 13/06/10

Please be aware that the code blocks shown below may not be the latest version but the zip file will always be the latest version.

/*
 Canon Camera Controller (nickname C-Cubed)
 version 1.6 - 03/06/10
 Author      - K Lewis www.photosbykev.com

 The system uses the normal camera pulses to trigger the camera in auto/manual modes.
 The pulse length can be adjusted so that it can also control the bulb exposures.
 All timing loops are non blocking so the buttons and lcd remain functional.

 Tested on Canon 7D and 40D cameras but will work on most systems with minor changes

 History
 v1.5 - first release
 v1.6 - added routine that saves Interval and Exposure values and reloads them next time the system is used. Press Red button on startup to load default values

 Things to do:
 1. programme up a decent clock setting routine
 2. interface the system to control DSLR Remote Pro to control ISO ramping

 This program is free software: you can redistribute it
 and/or modify it under the terms of the GNU General
 Public License as published by the Free Software
 Foundation, either version 3 of the License, or (at
 your option) any later version.

 This program is distributed in the hope that it will be
 useful, but WITHOUT ANY WARRANTY; without even the
 implied warranty of MERCHANTABILITY or FITNESS FOR A
 PARTICULAR PURPOSE. See the GNU General Public License
 for more details.

 The core of the non blocking software is based on code
 supplied by Shutterdrone on the OpenMoco website under
 the terms of the GNU General Public License.
 */

// Libraries used
#include <LiquidCrystal.h> // library from LCD display
#include <MsTimer2.h>      // library for interrupt control
#include "Wire.h"          // used with DS1307
#include <stdlib.h>        // string manipulation etc
#include <EEPROM.h>        // used to save variables to eeprom

// Camera pin definitions
#define SHUTTER_PIN 22     // digital output for shutter
#define FOCUS_PIN   23     // digital output for focus tap
#define PCSYNC_PIN  24     // digital input for pcsync confirmation - not implimented yet
#define CAMLED_PIN  25     // digital output for "shutter fired" LED

// Button definitions
#define B_LT 49                      // Left button
#define B_RT 50                      // Right button
#define B_UP 51                      // Up button
#define B_DN 52                      // Down button
#define B_CT 53                      // Centre button

unsigned long button_hit = 0;        // time last button was hit

// define battery status variables
int       batteryPin = 0;            // analogue pin 0 hard wired to battery status line
float     batteryValue;              // true battery voltage
int       batteryPercent;            // % full against max reference voltage
float     batteryMaxVolts = 4.15;    // max reference voltage (full charge)
float     batteryMinVolts = 3.35;    // min battery voltage (low alarm at batteryMinVolts + 0.1v)
float     batteryAverage = 0;        // the average voltage

// variables used to smooth the voltage reading
const int numReadings = 20;          // no. of samples for voltage smoothing
int       readings[numReadings];     // the readings from the analog input
int       index = 0;                 // the index of the current reading
int       total = 0;                 // the running total

// assign other variables
char* clearline = "                    "; // empty line string

// buffer for string conversion
char  buffer_Msg[] = "123456578901234567890";

// main display strings
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(31, 33, 35, 37, 39, 41);

#define   lcd_LIGHT 29            // digital pin controlling LCD backlight
boolean   lcd_SW;                 // flag for controlling backlight status
int       lcd_TIMEOUT = 30000;    // timeout delay before screen turns off
float     lcd_TIMER;              // Backlight timer used with millis()
int       lcd_LAST_UPDATE = 200;  // Only update display every 200 ms
float     lcd_UPDATE_TM = 0;      // variable to check against millis

// arrays used to build custom characters
byte UP[8] = // array to make an arrow pointing UP
{
  B00000,
  B00100,
  B01110,
  B11111,
  B00100,
  B00100,
  B00100,
  B00000
};
byte DOWN[8] = // array to make an arrow pointing DOWN
{
  B00000,
  B00100,
  B00100,
  B00100,
  B11111,
  B01110,
  B00100,
  B00000
};
byte LEFT[8] = // array to make an arrow pointing LEFT
{
  B00000,
  B00000,
  B00100,
  B01100,
  B11111,
  B01100,
  B00100,
  B00000
};
byte RIGHT[8] = // array to make an arrow pointing RIGHT
{
  B00000,
  B00000,
  B00100,
  B00110,
  B11111,
  B00110,
  B00100,
  B00000
};

/*
LiquidCrystal KEYWORDS
 #######################################
 # Methods and Functions
 #######################################

 begin
 clear
 home
 print
 setCursor
 cursor
 noCursor
 blink
 noBlink
 display
 noDisplay
 autoscroll
 noAutoscroll
 leftToRight
 rightToLeft
 scrollDisplayLeft
 scrollDisplayRight
 createChar
 */

// setup RTC
#define DS1307_I2C_ADDRESS 0x68

// Convert normal decimal numbers to binary coded decimal
byte decToBcd(byte val)
{
  return ( (val/10*16) + (val%10) );
}

// Convert binary coded decimal to normal decimal numbers
byte bcdToDec(byte val)
{
  return ( (val/16*10) + (val%16) );
}

// 1) Sets the date and time on the ds1307
// 2) Starts the clock
// 3) Sets hour mode to 24 hour clock
// Assumes you're passing in valid numbers

void setDateDs1307 (
byte second,        // 0-59
byte minute,        // 0-59
byte hour,          // 1-23
byte dayOfWeek,     // 1-7
byte dayOfMonth,    // 1-28/29/30/31
byte month,         // 1-12
byte year)          // 0-99

{
  Wire.beginTransmission(DS1307_I2C_ADDRESS);
  Wire.send(0);
  Wire.send(decToBcd(second));    // 0 to bit 7 starts the clock
  Wire.send(decToBcd(minute));
  Wire.send(decToBcd(hour));      // If you want 12 hour am/pm you need to set
  // bit 6 (also need to change readDateDs1307)
  Wire.send(decToBcd(dayOfWeek));
  Wire.send(decToBcd(dayOfMonth));
  Wire.send(decToBcd(month));
  Wire.send(decToBcd(year));
  Wire.endTransmission();
}

// Gets the date and time from the ds1307
void getDateDs1307(byte *second,
byte *minute,
byte *hour,
byte *dayOfWeek,
byte *dayOfMonth,
byte *month,
byte *year)

{
  // Reset the register pointer
  Wire.beginTransmission(DS1307_I2C_ADDRESS);
  Wire.send(0);
  Wire.endTransmission();

  Wire.requestFrom(DS1307_I2C_ADDRESS, 7);

  // A few of these need masks because certain bits are control bits
  *second     = bcdToDec(Wire.receive() & 0x7f);
  *minute     = bcdToDec(Wire.receive());
  *hour       = bcdToDec(Wire.receive() & 0x3f);  // Need to change this if 12 hour am/pm
  *dayOfWeek  = bcdToDec(Wire.receive());
  *dayOfMonth = bcdToDec(Wire.receive());
  *month      = bcdToDec(Wire.receive());
  *year       = bcdToDec(Wire.receive());
}

// functions for EEPROM memory read/write
template <class T> int EEPROM_writeAnything(int ee, const T& value)
{
  const byte* p = (const byte*)(const void*)&value;
  int mem;
  for (mem = 0; mem < sizeof(value); mem++)
    EEPROM.write(ee++, *p++);
  return mem;
}

template <class T> int EEPROM_readAnything(int ee, T& value)
{
  byte* p = (byte*)(void*)&value;
  int mem;
  for (mem= 0; mem < sizeof(value); mem++)
    *p++ = EEPROM.read(ee++);
  return mem;
}

// Camera function variables
long          INTERVAL_TM = 1200;              // default interval delay between exposures
int           MIN_INTERVAL_TM = 100;           // minimum interval delay

long          EXPOSURE_TM = 60;                // default exposure length (how long to fire camera)
int           MIN_EXPOSURE_TM = 60;            // minimum exposure (pulse length)

float         EXPOSURE_INC = 1.05;             // percentage to increase or decrease exposure
float         EXPOSURE_DEC = 0.95;

unsigned long LAST_TM = 0;                     // last time camera fired
long          SHOT_COUNT = 0;                  // running total of photographs taken
boolean       SEQ_RUNNING = false;             // is the camera running a sequence
boolean       EXPOSING = false;                // whether or not we're currently exposing

// values to read/write to Eeprom, rememeber they are "configuration.INTERVAL_TM" etc.
// they are not the same as INTERVAL_TM etc
struct config_t
{
  long INTERVAL_TM;
  long EXPOSURE_TM;
}
configuration;

void setup() {

  // initialise all battery array readings to 0
  for (int thisReading = 0; thisReading < numReadings; thisReading++)
    readings[thisReading] = 0;

  // preload battery arrays with a cycle through the analogue readings
  // to avoid silly numbers appearing on the initial display
  int temp;
  for (temp =0; temp <= numReadings; temp++){
    get_Battery();
  }

  // setup pins for input/output
  pinMode(SHUTTER_PIN, OUTPUT);
  pinMode(FOCUS_PIN, OUTPUT);
  pinMode(PCSYNC_PIN, INPUT);
  pinMode(CAMLED_PIN, OUTPUT);

  // set input button pins
  pinMode(B_LT, INPUT);  // Left
  pinMode(B_RT, INPUT);  // Right
  pinMode(B_UP, INPUT);  // Up
  pinMode(B_DN, INPUT);  // Down
  pinMode(B_CT, INPUT);  // Centre

  // setup display
  pinMode (lcd_LIGHT, OUTPUT);
  digitalWrite(lcd_LIGHT, HIGH);
  lcd_SW = HIGH;        // turn on LCD backlight
  lcd_TIMER = millis(); // set timer start

  // set up the LCD's number of rows and columns:
  // Note 4 rows from 0 to 3
  lcd.begin(20, 4);

  // creates custom characters from the arrays storing them to
  // one of 8 (0-7) available custom character slots.
  lcd.createChar(0, UP);
  lcd.createChar(1, DOWN);
  lcd.createChar(2, LEFT);
  lcd.createChar(3, RIGHT);

  /* use lcd.write() for custom Arrow characters
   lcd.write(0);     UP
   lcd.write(1);     DOWN
   lcd.write(2);     LEFT
   lcd.write(3);     RIGHT
   */

  // display intro screen
  lcd.clear();
  lcd.setCursor(4, 0);
  lcd.print("Canon Camera");
  lcd.setCursor(5, 1);
  lcd.print("Controller");
  lcd.setCursor(8, 2);
  lcd.print("C^3");
  lcd.setCursor(4, 3);
  lcd.print("version  1.6");
  delay(2000);
  lcd.clear();

  // check if Centre button is pressed on startup.
  // If LOW load values from memory (default is to load memory values)
  // if HIGH load default values
  if( digitalRead(B_CT) == LOW)
  {
    EEPROM_readAnything(0, configuration);
    INTERVAL_TM = configuration.INTERVAL_TM;
    EXPOSURE_TM = configuration.EXPOSURE_TM;

    lcd.setCursor(0, 1);
    lcd.print(" Saved data loaded");
    lcd.setCursor(0, 2);
    lcd.print("Press FIRE to reset");
    delay(1000);
    lcd.clear();
  }
  else
  {
    lcd.setCursor(0, 1);
    lcd.print("Default data loaded");
    delay(1000);
    lcd.clear();
  }

  // display main screen
  lcd.setCursor(0, 0);
  lcd.print("Interval = ");
  lcd.setCursor(18, 0);
  lcd.write(0);                // UP arrow
  lcd.write(1);                // DOWN arrow

  lcd.setCursor(0, 1);
  lcd.print("Exposure = ");
  lcd.setCursor(18, 1);
  lcd.write(2);                // LEFT arrow
  lcd.write(3);                // RIGHT arrow

  lcd.setCursor(0,2);
  lcd.print("Shot     = ");

  // setup DS1307 (need to convert this into a proper clocking setting routine)
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
  Wire.begin();
  // Change these values to what you want to set your clock to.
  // You probably only want to set your clock once and then remove
  // the setDateDs1307 call.
  // unrem next lines to set clock
  /*
   second = 0;
   minute = 25;
   hour = 12;
   dayOfWeek = 4;
   dayOfMonth = 20;
   month = 5;
   year = 10;
   setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year);
   */
}

void loop() {

  if (SEQ_RUNNING == true) {
    shutter_control();
  }
  user_input();
}

/*
check battery status and work out percentage life left in the lithium battery
*/

// Battery Status
void get_Battery()  {
  // read the value from the battery sensor analogue pin (full charge voltage = batteryMaxVolts)
  // create a rolling average over 20 samples

  // subtract the last reading:
  total = total - readings[index];

  // read from the sensor:
  readings[index] = analogRead(batteryPin);

  // add the reading to the total:
  total = total + readings[index];
  // advance to the next position in the array:
  index = index + 1;

  // if we're at the end of the array...
  if (index >= numReadings)
    // ...wrap around to the beginning:
    index = 0;

  // calculate the average:
  batteryAverage = total / numReadings;

  // convert to volts
  batteryValue = (batteryAverage/1024)*5; // 1024 = 5 volts
  batteryPercent = ((batteryValue-batteryMinVolts)/(batteryMaxVolts-batteryMinVolts))*100;
}

/*
Update display every lcd_UPDATE_TM ms
*/

void update_LCD() {

  // only update every lcd_UPDATE_TM ms
  if (millis() - lcd_UPDATE_TM > lcd_LAST_UPDATE) {

    // update display
    lcd.setCursor(11, 0);
    lcd.print("     ");
    lcd.setCursor(11, 0);
    lcd.print(INTERVAL_TM);

    lcd.setCursor(11, 1);
    lcd.print("     ");
    lcd.setCursor(11, 1);
    lcd.print(EXPOSURE_TM);

    lcd.setCursor(11, 2);
    lcd.print("     ");
    lcd.setCursor(11, 2);
    lcd.print(SHOT_COUNT);

    // update status line with time and battery
    // Update clock on status line
    get_Clock();

    // update Battery on status line
    get_Battery();
    lcd.setCursor(11, 3);
    lcd.print("B     ");
    lcd.setCursor(12, 3);
    lcd.print(batteryPercent);
    lcd.print("%");

    // check battery status and display label
    if (batteryPercent <= 5){
      lcd.setCursor(17,3);
      lcd.print("LOW");
    }
    else
    {
      lcd.setCursor(17,3);
      lcd.print(" OK");
    }
    // update update timer
    lcd_UPDATE_TM = millis();
  }
}

/*
get update from RTC and display it
*/

void get_Clock()
{
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;

  getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);

  lcd.setCursor(0,3);
  if (hour < 10){
    lcd.print("0");
  }
  lcd.print(hour, DEC);
  lcd.print(":");
  if (minute < 10){
    lcd.print("0");
  }
  lcd.print(minute, DEC);
  lcd.print(":");
  if (second < 10){
    lcd.print("0");
  }
  lcd.print(second, DEC);
}

/*
control the camera and the interrupt
*/

void shutter_control() {

  // if the camera is not currently exposing, and our
  // timer has elapsed, fire camera...

  if( EXPOSING == false && millis() - LAST_TM > INTERVAL_TM ) {

    // set timer interrupt to call our
    // function to disengage the camera
    MsTimer2::set( EXPOSURE_TM, shutter_off );

    // enable timer
    MsTimer2::start();

    // set flag to indicate that we're currently
    // exposing

    EXPOSING = true;

    // enable optocoupler and LED
    digitalWrite(SHUTTER_PIN, HIGH);
    digitalWrite(CAMLED_PIN, HIGH);

    SHOT_COUNT++;

  } // end if not exposing and timer has elapsed
}

void shutter_off() {

  // disable optocoupler and LED
  digitalWrite(SHUTTER_PIN, LOW);
  digitalWrite(CAMLED_PIN, LOW);

  // disable timer
  MsTimer2::stop();

  // we set this now to ensure that our
  // interval time is measured from the
  // time an image is completed until the
  // time the next one is triggered
  //
  // if you want the interval time to be
  // measured between the time the image
  // is triggered and the next image is
  // triggered, move this to before
  // bringing the camera pin high

  LAST_TM = millis();

  // reset exposing flag
  EXPOSING = false;
}

/*
 user input functions
 */

void user_input() {
  // this function determines if any button has been hit,
  // and what to do about it
  // up and down do not require a HIGH (unpressed) reading
  // so that you can hold them down and quickly cycle through
  // values (about 3 changes per second)

  update_LCD();

  // check to turn off backlight
  if (lcd_SW == HIGH){

    if (lcd_TIMER + lcd_TIMEOUT < millis()) {
      lcd_SW = LOW;
      digitalWrite(lcd_LIGHT, LOW);
    }
  }

  // check for button press
  if( digitalRead(B_UP) == HIGH && millis() - button_hit > 300) {

    if (lcd_SW == LOW && millis() - button_hit > 300) {
      lcd_ON();
      button_hit = millis();
      return;
    }
    else
    {
      take_button_action(0);
      button_hit = millis();
      return;
    }
  }

  if( digitalRead(B_DN) == HIGH && millis() - button_hit > 300 ) {
    //pre_dn = true;

    lcd_ON();
    take_button_action(1);
    button_hit = millis();
    return;
  }

  if( digitalRead(B_LT) == HIGH && millis() - button_hit > 300 ) {

    if (lcd_SW == LOW && millis() - button_hit > 300) {
      lcd_ON();
      button_hit = millis();
      return;
    }
    else
    {

      take_button_action(2);
      button_hit = millis();
      return;
    }
  }

  if( digitalRead(B_RT) == HIGH && millis() - button_hit > 300) {

    if (lcd_SW == LOW && millis() - button_hit > 300) {
      lcd_ON();
      button_hit = millis();
      return;
    }
    else
    {
      take_button_action(3);
      button_hit = millis();
      return;
    }
  }

  if( digitalRead(B_CT) == HIGH && millis() - button_hit > 300) {

    if (lcd_SW == LOW && millis() - button_hit > 300) {
      lcd_ON();
      button_hit = millis();
      return;
    }
    else
    {
      take_button_action(4);
      button_hit = millis();
      return;
    }
  }
}

void take_button_action( byte button ) {

  switch(button) {
  case 0:
    // up hit
    INTERVAL_TM = INTERVAL_TM + 100;
    // update memory
    configuration.INTERVAL_TM = INTERVAL_TM;
    EEPROM_writeAnything(0, configuration);
    update_LCD();
    return;
    break;

  case 1:
    // down hit
    INTERVAL_TM = INTERVAL_TM - 100;
    if (INTERVAL_TM <= MIN_INTERVAL_TM) {
      INTERVAL_TM = MIN_INTERVAL_TM;
    }
    update_LCD();
    // update memory
    configuration.INTERVAL_TM = INTERVAL_TM;
    EEPROM_writeAnything(0, configuration);
    return;
    break;

  case 2:
    // left hit - reduce exposure
    EXPOSURE_TM = int(EXPOSURE_TM * EXPOSURE_DEC);
    if (EXPOSURE_TM <= MIN_EXPOSURE_TM) {
      EXPOSURE_TM = MIN_EXPOSURE_TM;
    }
    update_LCD();
    // update memory
    configuration.EXPOSURE_TM = EXPOSURE_TM;
    EEPROM_writeAnything(0, configuration);
    return;
    break;

  case 3:
    // right hit - increase exposure
    EXPOSURE_TM = int(EXPOSURE_TM * EXPOSURE_INC);
    // update memory
    configuration.EXPOSURE_TM = EXPOSURE_TM;
    EEPROM_writeAnything(0, configuration);
    update_LCD();
    return;
    break;

  case 4:
    // centre hit

    if (SEQ_RUNNING == true) {
      SEQ_RUNNING = false;
      update_LCD();
    }
    else {
      SEQ_RUNNING = true;
      update_LCD();
    }
    return;
    break;
  }
}

// function to turn on lcd_LIGHT and reset timer
void lcd_ON(){
  lcd_TIMER = millis(); // reset lcd timer
  digitalWrite(lcd_LIGHT, HIGH);
  lcd_SW = HIGH;
}

I produced a Raw test image on the Canon 7D by removing the lens and putting the body cap back on, I then shot a Raw image at iso 1600 for 30 seconds with all High Iso and Long Expsoure noise reduction functions turned off.

The raw file was then processed in turn by Adobe Camera Raw, Digital Photo Professional and DxO Optics Pro 6 to produce 16-bit Tiff files with no sharpening or noise reduction. The Tiff files were processed through Photoshop CS5 in an identical same manner shown next.

An Exposure adjustment layer was applied and the exposure increased by 2 stops to increase the visibility of the noise. A 1000 x 667 pixel rectangle was then cropped from the centre of each image and saved as a jpeg file. If you click on each photograph you will be able to see the 100% versions of the images.

Adobe Camera Raw conversion - 30 sec x 1600 iso

Digital Photo Professional conversion - 30 sec x 1600 iso

DxO Optics Pro 6 - 30 sec x 1600 iso

To produce the image above processed by DxO I had to turn off all the default auto settings as the resulting image was absolutely appalling!

I know what I’ll be using in future.

If you wish to carry out your own tests the 20Mb Raw CR2 file from the Canon 7D is available here. Right click to save the image to your hard drive.

The Box

As the system is based on the Arduino mega microprocessor I decided to expand the options available to me by including the Toas TSL230R IC for exposure control using bulb and iso ramping and the DS1307 RTC for pre-programming a shooting sequence. The automated bulb ramping and iso ramping functions are being developed to cater for the lighting changes that occur during dawn and dusk without manual intervention so that the shutter speed and iso settings can be adjusted together without changing the exposure.

The in’s and out’s

Reprogramming the Arduino allows me to do pretty much anything I want with my cameras so I’ve no doubt it will be used for a lot of projects. A simple ramping intervalometer programme can be found here

The code is written to avoid any delay() type functions so it is non-blocking and the keybuttons remain fully functional even when the camera is being controlled.

Currently the box is programmed to control the Camera shutter and focus functions, it has a feedback circuit triggered by the flash socket on the camera which confirms the camera fired. It can manually or automatically vary the shutter speed in bulb mode from as little as 60 milliseconds to days.

I won’t even begin to describe how the dynamic exposure metering works but would highly recommend Chris’s website for a wealth of information.

Inside the aluminium project box:

• An Aduino Mega microprocessor.
• A 2200 mAH rechargable lithium battery for standalone use.
• A DS1307 RTC (real time clock).
• A Taos TSL230R frequency to light convertor IC
  that handles the exposure control.
• A 20 x 4 backlit LCD display.
• 5 momentary push buttons
• A green ‘shutter open’ led
• A lot of wire and stuff.

The Taos TSL230R IC

The basic interface to the camera shutter and focus using 4N35 opto isolators to remove any possibility of unwelcome voltages getting into the camera.

Typical interface using the 4N35 opto isolator

Things to do:

• Improve the user interface and the GUI.
• Develop the bulb ramping and iso ramping process to allow the system to adjust the exposures during sunsets and sunrises.
• Interface the Arduino to a netbook so the DSLR Remote Pro library can be used to adjust camera parameters, again without touching the camera.
• Add HDR functionality for bracketing photographs across the boundary of 30 seconds. i.e avoiding the need to touch the camera to switch from manual to bulb modes.
• Add the schedule programmming for non-attended shooting.
• Sort out a method to retain the last user settings in the EEPROM memory

This is the first post on the project and a lot more will follow

Time lapse – Arduino ramping Test from Kevin Lewis on Vimeo.

A time lapse test with the Arduino control system taken from 30 minutes before sunset at 2130 until 2.5 hours after it finishing at midnight. The session was used to tune up an automated control system aimed at minimising flicker. If the clouds hadn’t come along then I would of carried on shooting.

The initial exposure was 1/80 second @ f5.6 iso 100 and at the end it was 22 seconds @ f5.6 iso 1000

The Canon 7D and 10-22mm lens were connected to an arduino which was running a program to control the bulb exposure length based on the readings from an external light meter. The arduino also controlled the iso ramping during the sequence

Until the exposure was longer than about 1/20second it was necessary to use manual adjustment of the shutter speed and iso using DSLR Remote Pro running on a netbook. From about 45 seconds the system did everything, I do need to work on controlling the progression of the exposure sequence to stop the slight bouncing that is visible and I’ve also found some hot pixels BUT I think I’ve resolved that after doing a quick test here

No attempt has been made to remove birds, flicker or process the images before compiling the video.

Early days but getting there