LightRails – Dynamic External Exposure Control for Time-lapse

I’ve been sitting on this a little while, and I feel a bit remiss in not sharing it sooner.  I had intended to make it “perfect” before sharing, but feel I’ve reached a point where I’m not ready to spend all of my effort on this project, and instead wish to work more on OpenMoco (but we’ll talk more about that soon!).  So, I’ll share this as a more “rough” project.

Some time ago, I started out with the TSL230R chip from Taos with the intent of producing a (a) my own digital light meter and (b) a dynamic external control system for time-lapse photography.  Certainly, the act of creating my own digital light meter was a smashing success, also having it control my dSLR via a remote cable in bulb mode was also a great success.  Enough so that it should prove an invaluable tool to the DIY pinhole photographer.  (Man, how do you time that 2:35:20 exposure manually? =)

The problem I wanted to solve was a difficult, but common one: how do you effectively manage exposure changes across sunrise and sunset time-lapses with a dSLR?  It sounds very easy, just go into Av or Tv mode!  Of course, life isn’t that easy.  The standard dSLRs generally only meter and adjust exposure in the very rough terms of 1/6, 1/4, 1/3, or even 1/2 EV steps!  This means it has a sledge hammer where the problem calls for a gentle tapping of a finger.  I set out to create a system that would control the camera externally, metering and adjusting exposure in 1/100 EV steps…

Some more information about how this all got started, and some color commentary along the way can be found in these two forum postings over at timescapes.org:

Testing Dynamic External Exposure Control

Huge Dynamic Range Change

Sunset Time-lapses

Unfortunately, the system is still a bit rough for time-lapse photography in controlling exposure in all conditions, but it can be made to succeed in certain conditions, given practice and patience.  I’m not going to go into great detail on instructions, as it should be largely evident based on the information below, but you will need the following parts at a minimum to use this code:

• (1x) Arduino board with Atmega168P chip (will probably work with 328p)
• (1x) Taos TSL230R light sensor IC
• (1x) 16×2 Parallel LCD screen
• (1x) 4N28 opto-isolator (isolating camera trigger circuitry)
• (5x) SPST mometary switches
• (1x) 0.1uF Ceramic Capacitor

Effectively, the sensor should be placed remote from the control unit (but within specs of the TSL230R), and the control unit uses an LCD display to display information, and five momentary switches to control operation and input data.  The best configuration I’ve found for using this for time-lapse is to create a reflector, placing the sensor and the capacitor in a separate enclosure from the control, and place the sensor inside of the reflector.  For a reflector, I simply used three pieces of wood connected like a ‘C’, painted the inside flat white, and mounted the sensor housing inside of the ‘C’, facing downwards.  The reflector could then either be placed in complete shade, or pointed towards the scene.  Either way, the unit should be protected from over-head light changes – it should either meter the scene on average, or the amount of light read in shade.  Which is better depends on the scene in question — shooting sunny sky-scenes with dim foregrounds generally require scene metering, whereas equally-lit sky and foregrounds prefer shade-readings.  It is also capable of metering through your eye-piece, but resolution suffers greatly (set TTL F/stop in the UI to enable this mode).

The system is configured with ISO, f/stop, minimum and maximum exposure times, number of EV divisions per step (best left at 100), and shot interval.  The light reading is calculated once per second, and exposure time calculated from the settings and light reading.  EV adjust is set to achieve the proper exposure vs. the metered exposure, and the system is left to run.

Random fluctuations and massive jumps from physical interference (say a dog sniffing at your meter while you’re napping =) are prevented through the simple application of a ‘ev change ceiling’ setting, which prevents any change in calculated EV greater than the ceiling (in x/y EV steps — e.g.: no change greater than 3/100’s EV.) — this method has proven its self as both the most simple and effective means through empirical testing, beating out averaging, weighting, and all other sorts of complicated methods.

If you find this useful, come up with a novel application, or have any questions – please don’t hesitate to drop me a comment here.  I’d love to know what you do with it, or help you if you need it.

The following videos should give you some idea how to assemble and use it:

note: both videos show older versions of the UI and the device, where the sensor was integrated into the controller. This is not recommended.

And, here’s an example of its performance:

And, without further ado, here’s the code.  Each section should be pasted into a seperate tab in the Arduino UI, with the first section of code in the main tab.

lightrails.pde:

/*

 LightRails 1.0
   A dynamic external exposure control system with
   integrated intervalometer for time-lapse
   photography

 Copyright (c) 2008-2009 C. A. Church drone< a_t >dronecolony.com

 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. 

*/

#include <LiquidCrystal.h>
#include <avr/pgmspace.h>
#include <MsTimer2.h>

#define TSL_FREQ_PIN 2
#define TSL_S0         6
#define TSL_S1         5
#define TSL_S2         3
#define TSL_S3       4

#define CAMERA_PIN   13

 // buttons

#define B_LT   9
#define B_RT   10
#define B_UP   7
#define B_DN   8
#define B_CT   11

  // max number of setup steps available

#define MAX_SETUP_STEPS   12

  // read frequency for how many milliseconds
  // note: this code only works for 1000 any other value
  // and you need to adjust your frequency calculation

#define READ_TM      1000

  // low and high thresholds for adjusting sensitivity
  // of the TSL230R.  If freq is below LO thresh, it will
  // automatically increase sensitivity.  If it increases
  // beyond the HI thresh, it will decrease sensitivity

#define SENS_THRESH_LO 101
#define SENS_THRESH_HI 7999

  // LCD print buffer
  // set to LCD width + 1

#define SIZE_OF_LCD_BUF 17

 // threshold to accept a frequency change
 // the frequency read off the chip must change by
 // at least this many Hz to accept the change
 // this prevents fluttering.  However, it can cause
 // problems with low-light level changes.  You may need
 // to adjust according to types of shooting you
 // typically do (higher for more day shooting
 // and lower for more night shooting)

#define FREQ_CHG_THRESH  20

 // the minimum exposure gap is the minimum time
 // between triggering exposures (for the cases where
 // exposure_time exceeds interval_time).  At a bare
 // minimum, it should be the minimum amount of time
 // required by your camera to consistently register
 // the completion of one exposure and execution of
 // another.  this time is in milliseconds

#define MIN_EXP_GAP 1000

 // some info about exposure data
 // need iso and f/stop to calculate
 // exposure time.  These are just
 // defaults - they are adjusted via the UI

int   iso_rating = 100;
float f_stop     = 8.0;

 // Maximum Diff % in EV Value calculated from reading to reading
byte ev_diff_ceiling  = 0; 

 // for through-a-lens metering - f-stop of the lens
 // (light read must be calculated)

float ttl_stop = 0.0;

 // default times
unsigned int camera_delay       = 5;
unsigned int min_exp_tm         = 10;
byte         max_exp_tm         = 20;

 // actual delay time in mS

unsigned long real_camera_delay = camera_delay * 1000;

  // running variables

float         uwcm2          = 0; // uw/cm2 calculated 
float         lux            = 0; // Lux caclulated
float         ev             = 0; // EV value calculated
float         exp_tm         = 0; // camera exposure time calculated in 1/x value
float         pre_exp_tm     = 0; // for latching, need previous reading
unsigned long frequency      = 0; // frequency read
unsigned long cur_exp_tm     = 0; // current exposure time in mS
unsigned int  shots_fired    = 0; // how many exposures taken since interval started

bool camera_engaged          = false; // camera currently exposing?
bool light_type              = false; // which spd graph to use - d65 [0] or ilA [1]

 // this is used by the pulse counter.

volatile unsigned long pulse_cnt = 0;

 // for calculating time differences

unsigned long pre_tm         = millis();

unsigned int  freq_tm_diff   = 0; // how much time has passed since last frequency reading
                                  // -- note the int size limit
unsigned long camera_tm_diff = 0; // how much time has passed since last exposure

 // this is used by the sensitivity adjustment
 // to record the amount to divide the freq by
 // to get the uW/cm2 value at 420nm

unsigned int  calc_sensitivity   = 10;

 // this is the frequency calculation multiplier
 // based on what scaling factor is chosen. 
 // set_scaling() will adjust it for you.

byte freq_mult = 1;

 // our previous frequency count
 // -- we set it to fifty so it doesn't swing
 // auto-sensitivity adjustment either way on the first
 // reading

unsigned long last_cnt  = 50;

  // some EV tracking variables

float prev_ev = 0;
float set_ev  = 0;

  // our wavelengths (nm) we're willing to calculate illuminance for (lambda)
int wavelengths[18] = { 380, 400, 420, 440, 460, 480, 500, 520, 540, 560, 580, 600, 620, 640, 660, 680, 700, 720 };
  // the CIE V(l) for photopic vision - CIE Vm(l) 1978 - mapping to the same (l) above
float v_lambda[18]  = { 0.0002, 0.0028, 0.0175, 0.0379, 0.06, 0.13902, 0.323, 0.71, 0.954, 0.995, 0.87, 0.631, 0.381, 0.175, 0.061, 0.017, 0.004102, 0.001047 };

  // CIE SPD graphs for D65 and Illuminant A light sources, again mapping to same lambda as included in wavelengths
float spd_graphs[2][18] = {
  { 49.975500, 82.754900, 93.431800, 104.865000, 117.812000, 115.923000, 109.354000, 104.790000, 104.405000, 100.000000, 95.788000, 90.006200, 87.698700, 83.699200, 80.214600, 78.284200, 71.609100, 61.604000 },
  { 9.795100, 14.708000, 20.995000, 28.702700, 37.812100, 48.242300, 59.861100, 72.495900, 85.947000, 100.000000, 114.436000, 129.043000, 143.618000, 157.979000, 171.963000, 185.429000, 198.261000, 210.365000 }
};

/*

  Let's setup all of our display strings for the LCD

  These are stored as PROGMEM so they don't take up valuable
  SRAM

*/
  // main display strings

// setup strings

const prog_char setup_str1[] PROGMEM  = "ISO";
const prog_char setup_str2[] PROGMEM  = "Target F/Stop";
const prog_char setup_str3[] PROGMEM  = "EV Adjust";
const prog_char setup_str4[] PROGMEM  = "EV Steps";
const prog_char setup_str5[] PROGMEM  = "Max Exp. - Sec";
const prog_char setup_str6[] PROGMEM  = "Exposure Cycle";
const prog_char setup_str7[] PROGMEM  = "Latch";
const prog_char setup_str8[] PROGMEM  = "Min Exp. - mSec";
const prog_char setup_str9[] PROGMEM  = "Scale Read";
const prog_char setup_str10[] PROGMEM = "TTL F/Stop";
const prog_char setup_str11[] PROGMEM = "Light Source";
const prog_char setup_str12[] PROGMEM = "EV Change Max";

PGM_P setup_strings[MAX_SETUP_STEPS] PROGMEM =
 {
   setup_str1,
   setup_str2, 
   setup_str3,
   setup_str4, 
   setup_str6,
   setup_str7,
   setup_str8,
   setup_str5,
   setup_str9,
   setup_str10,
   setup_str11,
   setup_str12
 };

 // buffer for above setup strings
char lcd_print_buffer[SIZE_OF_LCD_BUF];

 // ev adjust can be negative
 //
 // how many EV steps to add or subtract
 // to each EV calculation - UI moves in 1/4EV
 // increments.

float ev_adjust     = 0.0;

 // how many steps per EV to deal with -
 // calculations round to the nearest step
 // and adjustments happen in these steps,
 // e.g.: 10 steps = .1 EV per step,
 // 1 step = 1 EV per step

byte ev_steps     = 100;

 // status flags:
 // B0 = intervalometer enable
 // B1 = latch up
 // B2 = latch down
 // B3 = in setup
 // B4 = latched (exp tm not moved due to latch)
 // B5 = latched to min/max exp tm setting
 // B6 = ev adjust enabled
 // B7 = update setup display

byte status = B00000000;

 // current setup step

byte setup_step  = 0;

 // display type flags
 // 0 = 1/x shutter speed/time (calculated)
 // 1 = ms shutter speed (calculated)
 // 2 = frequency
 // 3 = EV (calculated)
 // 4 = W/m2 (calculated)
 // 5 = sensitivity (10, 100, 1000)
 // 6 = lux (calculated)
 // 7 = scale

byte disp_enable = B10000000;

 // button hit flags (plus a few others)
 // B0 = up
 // B1 = dn
 // B2 = lt
 // B3 = rt
 // B4 = ct
 // B5
 // B6 =
 // B7 = camera exposing (use this to save a var elsewhere)

byte buttons = B00000000;

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

 // init lcd display

LiquidCrystal lcd(14, 14, 15, 16, 17, 18, 19);

void setup() {

 lcd.clear();
 lcd.print("LightRails/1.0"); 

  // attach interrupt to pin8, send output pin of TSL230R to arduino 8
  // call handler on each rising pulse

 attachInterrupt(0, add_pulse, RISING);

 pinMode(TSL_FREQ_PIN, INPUT);

 pinMode(TSL_S0, OUTPUT);
 pinMode(TSL_S1, OUTPUT);
 pinMode(TSL_S2, OUTPUT);
 pinMode(TSL_S3, OUTPUT);

 pinMode(CAMERA_PIN, OUTPUT);

   // set input button pins

 pinMode(B_LT, INPUT);
 pinMode(B_RT, INPUT);
 pinMode(B_UP, INPUT);
 pinMode(B_DN, INPUT);
 pinMode(B_CT, INPUT);

   // enable pullup resistors
 digitalWrite(B_LT, HIGH);
 digitalWrite(B_RT, HIGH);
 digitalWrite(B_UP, HIGH);
 digitalWrite(B_DN, HIGH);
 digitalWrite(B_CT, HIGH);

  // write TSL sensitivity 1x

 digitalWrite(TSL_S0, HIGH);
 digitalWrite(TSL_S1, LOW);

  // set frequency scaling

 tsl_set_scaling(2); 

}

void loop() {

  // operate camera
  // handle user input
  // update light sensor data

    // calculate how much time has passed
    // both for camera firing and light reading

    // this code requires arduino 012 or any version with
    // compatible millis() overflow and behavior

 freq_tm_diff   += millis() - pre_tm;
 camera_tm_diff += millis() - pre_tm;

 pre_tm          = millis();

  // if intervalometer enabled, enough time has passed,
  // and the camera isn't already engaged
  // - fire camera (camera delay is in seconds)

 if( status & B10000000 && camera_tm_diff >= real_camera_delay &&  camera_engaged == false ) {

       // re-set camera difference timer
     camera_tm_diff = 0;

       // trigger camera remote
     fire_camera();

      // convert sec to msec for next exposure check
      // always try and use the configured value first
      // (see next operation)

     real_camera_delay = camera_delay * 1000;

       // assure MIN_EXP_GAP threshold is enforced
       // between exposure triggers
       //
       // if the exposure time leaves less than the
       // minimum gap between exposures (MIN_EXP_GAP
       // must be <= real_camera_delay), add the minimum gap
       // to the current exposure time, and make that the
       // interval time before the next shot

     if( cur_exp_tm >= ( real_camera_delay - MIN_EXP_GAP ) )
       real_camera_delay = cur_exp_tm + MIN_EXP_GAP;

       // update count of shots fired
     shots_fired++;

 } // end if( status...   

   // see if the user has pressed any buttons, and handle
   // them if need be

 check_input();

   // if a second has passed, we need to
   // update our calculations

 if( freq_tm_diff >= READ_TM ) {

     // reset time counter

   freq_tm_diff = 0;

    // get current frequency

   frequency = tsl_get_freq(); 

    // ignore changes in frequency below FREQ_CHG_THRESH

   if( last_cnt > 0 && abs( (long) ( frequency - last_cnt ) ) < FREQ_CHG_THRESH )
     frequency = last_cnt;

     // set other needed values

   if ( frequency > 0 ) {  

       // chip has given us a positive reading

       // calculate power   
     uwcm2     = tsl_calc_uwatt_cm2(frequency);   

     if( uwcm2 <= 0 ) {
         // handle no actual power reading available
       uwcm2 = 0;
       lux   = 0;
     }
      else {

        // there was a positive power reading...

        // calculate lx value using gaussian formula

       lux = calc_lux_gauss(uwcm2);
      }
   }
   else {
       // 0 frequency read from chip - set all values to zero
     uwcm2 = 0;
     lux   = 0;
   }

   if ( lux <= 0 ) {
       // don't try calculating nonsense - we cant calculate
       // an EV with no light.
     lux = 0;
     ev = -6.0;
   }
   else {
       // we have positive lux reading
       // calculate EV from lux reading
     ev = calc_ev(lux);
   }

      // calculate exposure time value

   exp_tm     = calc_exp_tm( ev, f_stop );

      // determine if we need to latch on to a particular exposure
      // as lowest or highest allowed

   if( status & B10000000 && status & B01100000) {
     // latch high or low enabled - and intervalometer on     

     if( status & B01000000 ) {
         // latch low is enabled (don't increase exposure time)
         // remember that exp_tm is a divisor - so a higher number == faster exposure
       if( exp_tm > pre_exp_tm) {
         exp_tm = pre_exp_tm;
           // indicate that exposure is latched
         status |= B00001000;
       }
       else {
           // reset latch indicator
         status &= B11110111;
           // set new exposure value to keep exp from
           // getting longer than current exp. (new
           // ceiling)
         pre_exp_tm = exp_tm;
       }
     }
     else if( status & B00100000 ) {
         // latch high enabled (don't decrease exposure time)
       if( exp_tm < pre_exp_tm ) {
          exp_tm = pre_exp_tm;
          status |= B00001000;
       }
       else {
         status &= B11110111;
           // new floor
         pre_exp_tm = exp_tm;
       }
     }
   } // end if latch high or low enabled

     // calculate exposure ms
     // we can only go as short as 1ms, so don't
     // try and calculate below that.  Check for
     // 1/1000 ceiling

   if( exp_tm >= 1000 ) {
    cur_exp_tm = 1;
   }
   else {
     cur_exp_tm = calc_exp_ms( exp_tm );
   }

    // check for minimum/max exposure time

   if( cur_exp_tm < min_exp_tm ) {
       // bring time up to min. exposure time
     cur_exp_tm = min_exp_tm;
       // set exposure time ceiling/floor engaged
     status |= B00000100;
   }
     // max exposure time is in seconds
   else if( max_exp_tm > 0 && cur_exp_tm > ( max_exp_tm * 1000 ) ) {
     cur_exp_tm = max_exp_tm * 1000;
       // set exposure time ceiling/floor engaged
     status |= B00000100;
   }
   else {
       // at neither min nor max exp. time
       // reset exposure time ceiling/floor flag
     status &= B11111011;
   }

         // determine if we need to change sensitivity --
         // two readings in a row must pass our thresholds

   if( frequency < SENS_THRESH_LO && last_cnt < SENS_THRESH_LO && calc_sensitivity < 1000 ) {
      tsl_sensitivity( HIGH );
   }
   else if( frequency > SENS_THRESH_HI && last_cnt > SENS_THRESH_HI && calc_sensitivity > 10) {
      tsl_sensitivity( LOW );
   }

     // save off current reading so we can see if we need to adjust sensitivity
     // on the next pass

   last_cnt = frequency;

     // set display to update

   status |= B00000001;   

 } // end if(freq_tm_diff > READ_TM)

    //
    // update user interface as the last step in the main
    // loop...
    // 

 if(  status & B00010000 && status & B00000001 ) {
     // in setup and screen needs updating

       // clear update flag
     status &= B11111110;

       // display setup info

     print_setup_display();
 }
  else if( status & B00000001 ) {
    // on main screen and need to update display

       // clear update flag
     status &= B11111110;

     print_info();

  }

} // end main loop

 // interrupt handler to function as a pulse-counter

void add_pulse() {

  // increase pulse count
 pulse_cnt++;
 return;
}

float float_abs_diff( float f1, float f2 ) {

  float diff = f1 > f2 ? f1 - f2 : f2 - f1;

  if( diff < 0 )
    diff *= 1;

  return(diff);
}

&#91;/sourcecode&#93;

<em>tsl230r_functions.pde:</em>



/*

 LightRails - TSL230R Control and Conversion Functions

   Copyright (c) 2008-2009 C. A. Church drone< a_t >dronecolony.com

 unsigned long tsl_get_freq()
 float tsl_calc_uwatt_cm2(unsigned long freq)
 void tsl_sensitivity( bool dir )
 void tsl_set_scaling( int what )

 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. 

*/

unsigned long tsl_get_freq() {

    // we have to scale out the frequency - the only
    // 1:1 frequency pulse we get is 100x scale.  Smaller
    // scaling on the TSL230R requires us to multiply by a factor
    // to get actual frequency

  unsigned long freq = pulse_cnt * freq_mult;
  pulse_cnt = 0;
  return(freq);
}

float tsl_calc_uwatt_cm2(unsigned long freq) {

  // get uW observed - assume 640nm wavelength
  // calc_sensitivity is our divide-by to map to a given signal strength
  // for a given sensitivity (each level of greater sensitivity reduces the signal
  // (uW) by a factor of 10)
  //
  // note: this function does not take sensor size into account
  //       other functions handle this

  float uw_cm2 = (float) freq / (float) calc_sensitivity;

  return(uw_cm2);

}

void tsl_sensitivity( bool dir ) {

  // adjust sensitivity of TSL230R in 3 steps of 10x either direction

  int pin_0 = false;
  int pin_1 = false;

  if( dir == true ) {

      // increasing sensitivity

      // -- already as high as we can get
    if( calc_sensitivity == 1000 )
      return;

    if( calc_sensitivity == 100 ) {
        // move up to max sensitivity
      pin_0 = true;
      pin_1 = true;
    }
    else {
        // move up to med. sesitivity
      pin_1 = true;
    }

      // increase sensitivity divider
    calc_sensitivity *= 10;
  }
  else {
      // reducing sensitivity

      // already at lowest setting

    if( calc_sensitivity == 10 )
      return;

    if( calc_sensitivity == 100 ) {
        // move to lowest setting
      pin_0 = true;
    }
    else {
        // move to medium sensitivity
      pin_1 = true;
    }

      // reduce sensitivity divider
    calc_sensitivity = calc_sensitivity / 10;
  }

    // make any necessary changes to pin states

 digitalWrite(TSL_S0, pin_0);
 digitalWrite(TSL_S1, pin_1);

 return;
}

void tsl_set_scaling ( int what ) {

  // set output frequency scaling for TSL230R
  // when increasing the scaling for divide-by-output, you reduce the
  // freq multiplier by a factor of ten. 
  // e.g.:
  // scale = 2 == freq_mult = 100
  // scale = 10 == freq_mult = 10
  // scale = 100 == freq_mult = 1

  byte pin_2 = HIGH;
  byte pin_3 = HIGH;

  switch( what ) {
    case 2:
      pin_3     = LOW;
      freq_mult = 2;
      break;
    case 10:
      pin_2     = LOW;
      freq_mult = 10;
      break;
    case 100:
      freq_mult = 100;
      break;
    default:
      return;
  }

  digitalWrite(TSL_S2, pin_2);
  digitalWrite(TSL_S3, pin_3);

  return;
}

camera_controls.pde:

/*

   -- Camera Control Functions

 LightRails 1.0
   A dynamic external exposure control system with
   integrated intervalometer for time-lapse
   photography

 Copyright (c) 2008-2009 C. A. Church drone< a_t >dronecolony.com

 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. 

*/

void fire_camera() {

  digitalWrite(CAMERA_PIN, HIGH);
    // start timer to stop camera exposure
  MsTimer2::set(cur_exp_tm, stop_camera);
  MsTimer2::start();

    // update camera currently enaged
  camera_engaged = true;

  return;
}

void stop_camera() {

  digitalWrite(CAMERA_PIN, LOW);
    // turn off timer
  MsTimer2::stop();

    // update camera currently enaged
  camera_engaged = false;
}

lcd_display.pde:

/*

  -- LCD Display Functions

 LightRails 1.0
   A dynamic external exposure control system with
   integrated intervalometer for time-lapse
   photography

 Copyright (c) 2008-2009 C. A. Church drone< a_t >dronecolony.com

 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. 

*/

void print_setup_display() {

   // clear out lcd print buffer

 memset(lcd_print_buffer, 0, SIZE_OF_LCD_BUF);

   // get setup string from hash

 strcpy_P(lcd_print_buffer, (char*)pgm_read_word( &(setup_strings[setup_step])) );

 lcd.clear();
 lcd.setCursor(0, 0);

 lcd.print(lcd_print_buffer);

   // go to second line
 lcd.setCursor(0, 1);

   // determine which setup step to display

 switch(setup_step) {
     case 0:
       lcd.print(iso_rating, DEC);
       break;

     case 1:
             // handle rounding for higher f-stops

       if( f_stop > 7.1 ) {
         print_float((float) int(f_stop));
       }
       else {
         print_float(f_stop);
       }

       break;

     case 2:
       print_float(ev_adjust);
       break;

     case 3:
       lcd.print(ev_steps, DEC);
       break;

     case 4:
       lcd.print(camera_delay, DEC);
       break;

     case 5:
       if( status & B01000000 ) {
         lcd.print('-');
       }
       else if( status & B00100000 ) {
         lcd.print('+');
       }
       else {
         lcd.print('X');
       }
       break;

     case 6:

      lcd.print(min_exp_tm, DEC);
      break;

     case 7:

      lcd.print(max_exp_tm, DEC);
      break;

     case 8:

      lcd.print(freq_mult, DEC);
      break;

     case 9:

      print_float(ttl_stop);
      break;

     case 10:

      lcd.print(light_type, DEC);
      break;

     case 11:

      lcd.print(ev_diff_ceiling, DEC);
      break;

     default:
       break;
   }

return;
}

void print_info() {

   lcd.clear();

   lcd.setCursor(0, 0);

    // display set iso and f-stop  
   lcd.print(iso_rating);
   lcd.print(' ');

   lcd.print('f');

             // handle rounding for higher f-stops
   if( f_stop > 7.1 ) {
     print_float((float) int(f_stop));
   }
   else {
     print_float(f_stop);
   }

     // if intervalometer on, show 'I' indicator
     // and count of shots fired

   if( status & B10000000 ) {
     lcd.setCursor(15,0);
     lcd.print('I');

     if( shots_fired > 999 ) {
       lcd.setCursor(11, 0);
     }
     else if( shots_fired > 99 ) {
       lcd.setCursor(12,0);
     }
     else if( shots_fired > 9 ) {
       lcd.setCursor(13,0);
     }
     else {
       lcd.setCursor(14,0);
     }

     lcd.print(shots_fired, DEC);

   }

    // move to second line 
   lcd.setCursor(0,1);   

   if( disp_enable & B10000000 ) {

         // show exposure time in 1/x notation

        if( exp_tm >= 2 ) {
         float disp_v = 0;

         if( exp_tm >= (float) int(exp_tm) + (float) 0.5 ) {
           disp_v = int(exp_tm) + 1;
         }
         else {
           disp_v = int(exp_tm);
         }

         lcd.print("1/");
         lcd.print(exp_tm, DEC);
        }
        else if( exp_tm >= 1 ) {
           // deal with times larger than 1/2 second

         float disp_v = 1 / exp_tm;
           // get first significant digit
         disp_v       = int( disp_v * 10 );     

         lcd.print('.');
         lcd.print(disp_v, DEC);
         lcd.print('"');    
        }
        else {
         int disp_v = int( (float) 1 / exp_tm);

         lcd.print(disp_v, DEC);
         lcd.print('"');

      }
    }

   else if( disp_enable & B01000000 ) {
         // display actual exposure mS
       print_ul(cur_exp_tm);
       lcd.print("mS");
   }

   else if( disp_enable & B00100000 ) {
         // display frequency reading
     lcd.print("Fq ");
     lcd.print(frequency, DEC);

   }

   else if( disp_enable & B00010000 ) {

         // display EV
       lcd.print("EV ");
       print_float(ev);

       if( ev_adjust > 0 || ev_adjust < 0 ) {
           // show any adjustment made
         lcd.print('&#91;');
         print_float(ev_adjust);
         lcd.print('&#93;');
       }

   } 

   else if( disp_enable & B00001000 ) {
       // uW/m2
     print_float(uwcm2);
     lcd.print("uW");

   }
   else if( disp_enable & B00000100 ) {
       // sensitivity level
     lcd.print('S');
     lcd.print(calc_sensitivity, DEC);     

   }

   else if( disp_enable & B00000010 ) {
         // display lux
       lcd.print("Lx ");
       print_float(lux);

   }

   else if( disp_enable & B00000001 ) {
       // divide-by-factor display
     lcd.print('R');
     lcd.print(freq_mult, DEC);
   }

  lcd.setCursor(14,1);

          // minimum/maximum exposure time enabled?
  if( status & B00000100 )
       lcd.print('M');

           // exposure was latched?        
 if( status & B00001000 )
        lcd.print('L');

}

void print_float( float val ){

  if ( val < 0 ) {
    lcd.print('-');
    val *= -1;
  }    

  print_ul( (unsigned long int) int(val) ); 
  lcd.print('.');

    // add 1 digit for hundreths precision
  if( (val * 100) - (int(val) * 100)  < 10 )
    lcd.print('0');

  print_ul( (val * 100) - (int(val) * 100) );

}   

void print_ul( unsigned long val ) {

    // print unsigned long to lcd

   // clear out lcd print buffer

 memset(lcd_print_buffer, 0, SIZE_OF_LCD_BUF);

 ultoa(val, lcd_print_buffer, 10); 
 lcd.print(lcd_print_buffer);

 return;
}
&#91;/sourcecode&#93;

<em>photo_calculations.pde:</em>



/*

 LightRails 1.0
   A dynamic external exposure control system with
   integrated intervalometer for time-lapse
   photography

 Copyright (c) 2008-2009 C. A. Church drone< a_t >dronecolony.com

 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. 

*/

/* 

 Functions to calculate photographic values
 from light readings, the following functions are
 found here:

 calc_lux_single*
 calc_lux_gauss
 calc_ev
 calc_exp_tm
 calc_exp_ms

 Last Modified: 2/29/2009, c.a. church
 Original:      10/15/2008, c.a. church
*/ 

/* 

  We always use multiple wavelengths.  This function is
  if you happen to be erm, you know, filming something illuminated
  by a single wavelength light source.  Given the rarity of this
  situation, you'll have to provide the luminous efficiency function
  value yourself.

float calc_lux_single(float uw_cm2, float efficiency) {

    // calculate lux (lm/m^2) for single wavelength, using standard formula:
    // Xv = Xl * V(l) * Km
    // Xl is W/m^2 (calculate actual receied uW/cm^2, extrapolate from sensor size (0.0136cm^2)
    // to whole cm size, then convert uW to W)
    // V(l) = efficiency function (provided via argument)
    // Km = constant, L/W @ 555nm = 683 (555nm has efficiency function of nearly 1.0)
    //
    // Only a single wavelength is calculated - you'd better make sure that your
    // source is of a single wavelength...  Otherwise, you should be using
    // calc_lux_gauss() for multiple wavelengths

  return( ( ( uw_cm2 * ( (float) 1 / (float) 0.0136) ) / (float) 1000000 ) * (float) 100   * efficiency * (float) 683 );
}

*/

float calc_lux_gauss( float uw_cm2 ) {

    // # of wavelengths mapped to V(l) values - better have
    // enough V(l) values!

  int nm_cnt = sizeof(wavelengths) / sizeof(int);

    // watts/m2

  float w_m2 =  ( uw_cm2 * ( (float) 1 / (float) 0.0136 ) / (float) 1000000 ) * (float) 100;

  float result = 0;

    // integrate XlV(l) dl
    // Xl = uW-m2-nm caclulation weighted by the CIE lookup for the given light
    //   temp
    // V(l) = standard luminous efficiency function

  for( int i = 0; i < nm_cnt; i++) {

    if( i > 0) {
      result +=  ( spd_graphs[light_type][i] / (float) 1000000)  * (wavelengths[i] - wavelengths[i - 1]) * w_m2  * v_lambda[i];
    }
    else {
      result += ( spd_graphs[light_type][i] / (float) 1000000) * wavelengths[i] * w_m2 * v_lambda[i];
    }

  }

    // multiply by constant Km and return

  return(result * (float) 683);
}

float calc_ev( float lux ) {

    // calculate EV using APEX method:
    // Ev = Av + Tv = Bv + Sv
    // Bv = log2( B/NK )
    // Sv = log2( NSx )
    // K  = Meter Calibration Constant
    //      14 = Pentax standard
    // N  = constant relationship between Sx and Sv

  float ev = ( log( (float)  0.3 * (float) iso_rating ) / log(2) ) + ( log( lux / ( (float) 0.3 * (float) 14.0 ) ) / log(2) );

   // round down if EV step
   // value is set to whole steps

  if( ev_steps == 1 )
    ev = (float) int(ev);

    // convert to positive value temporarily, if needed
  bool neg_ev = false;

  if( ev < 0 ) {
     neg_ev = true;
     ev *= -1;
   }

   if( ev > int(ev) ) {

      // if ev has a decimal value, determine nearest
      // fraction of EV to round to, based on ev step
      // setting

         // handle rounding to nearest step

       int rem = ( ( ev - int(ev) ) * 100 );    
       int step = 100 / ev_steps;

       for (int i = ev_steps; i > 0; i-- ) {

         if( rem >= step * i) {
           rem = step * i;
           break;
         }
       }

       ev = (float) int(ev) + ((float) rem / 100);

   }

    // reset back to negative EV value
  if( neg_ev == true )
    ev *= -1.0;

    // is there a ceiling set for maximum EV change?
    // if so, handle only moving a maximum amount of <ceiling>
    // steps between readings

  if( ev_diff_ceiling > 0 ) {

    float diff = float_abs_diff( ev, prev_ev );
    float ceiling = (float) ev_diff_ceiling / (float) ev_steps;

    if( diff > ceiling ) {

      if( ev < prev_ev ) {
        ev = prev_ev - ceiling;
      }
      else {
        ev = prev_ev + ceiling;
      }

    }

  }

  prev_ev = ev; 

    // if ev adjust enabled - apply it now 

   ev += ev_adjust;

    // deal with TTL compensation
    // each full aperture step results in one less
    // EV read in, so adjust output
    // up by one EV per stop    

  if( ttl_stop > 0 )
    ev += log( ttl_stop ) / log(sqrt(2));

  return(ev);

}

float calc_exp_tm ( float ev, float aperture  ) {

    // Ev = Av + Tv = Bv + Sv
    // need to determine Tv value, so Ev - Av = Tv
    // Av = log2(Aperture^2)
    // Tv = log2( 1/T ) = log2(T) = 2 ^^ (Ev - Av)

  float exp_tm = ev - ( log( pow(aperture, 2) ) / log(2) );

  float exp_log = pow(2, exp_tm); 

  return( exp_log  );
}

unsigned long calc_exp_ms( float exp_tm ) {

  return( (unsigned long) ( 1000 / exp_tm ) );

    // if you wish to round actual mS for exposure to nearest
    // exposure step (the actual exposure step displayed in 1/x
    // format), un-comment the following code and comment the
    // line above out.
    //
    // Mind you, that doing so will make the device
    // no more accurate than your standard camera's meter.

/*   
      // deal with times less than or equal to half a second
   if( exp_tm >= 2 ) {

     if( exp_tm >= (float) int(exp_tm) + (float) 0.5 ) {
       exp_tm = int(exp_tm) + 1;
     }
     else {
       exp_tm = int(exp_tm);
     }

     return(1000 / exp_tm);

   }
   else if( exp_tm >= 1 ) {
     // deal with times larger than 1/2 second

     float disp_v = 1 / exp_tm;
       // get first significant digit
     disp_v       = int( disp_v * 10 );    
     return( ( 1000 * disp_v ) / 10 );

   }
    else {
      // times larger
     int disp_v = int( (float) 1 / exp_tm);
     return((unsigned long) 1000 * (unsigned long) disp_v);

    }
*/

}

user_input.pde:

/*

 -- user input functions

 LightRails 1.0
   A dynamic external exposure control system with
   integrated intervalometer for time-lapse
   photography

 Copyright (c) 2008-2009 C. A. Church drone< a_t >dronecolony.com

 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. 

*/

void check_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)

 if( digitalRead(B_UP) == LOW && millis() - button_hit > 300) {

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

 if( digitalRead(B_DN) == LOW && millis() - button_hit > 300 ) {
      //pre_dn = true;
      take_button_action(1);
      button_hit = millis();
      return;
 }

 if( digitalRead(B_LT) == LOW) {
  if(buttons & B00100000 && millis() - button_hit > 300) {  
      buttons &= B11011111;

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

   buttons &= B11011111;

 }
  else {
    buttons  |= B00100000;
  }

 if( digitalRead(B_RT) == LOW ) {
   if( buttons & B00010000 && millis() - button_hit > 300) {
      buttons &= B11101111;
      take_button_action(3);
      button_hit = millis();
      return;
   }
  buttons &= B11101111;
 }
 else {
   buttons |= B00010000;
 }

 if( digitalRead(B_CT) == LOW ) {
   if( buttons & B00001000 && millis() - button_hit > 300) {
      buttons &= B11110111;
      take_button_action(4);
      button_hit = millis();
      return;
   }
   buttons &= B11110111;
 }
 else {
   buttons |= B00001000;
 }

}

void take_button_action( byte button ) {

  // this function operates whatever action is desired when
  // a button is pressed.  called by check_input()

  switch(button) {
    case 0:
      // up hit

      if( status & B00010000 ) {

            // we're in a setup screen...

            // increasing value at current cursor position

          change_setup_value(setup_step, 1);

            // update flag to show change in display value
          status |= B00000001;

          return;
      }
      else {      
        // on main screen - up turns intervalometer on

            // if intervalometer on already, do nothing

          if( status & B10000000 )
            return;

            // turn on intervalometer
          status |= B10000000;
            // save current exposure reading for latch
          pre_exp_tm = exp_tm; 

        }

      break;

    case 1:
      // down hit

      if( status & B00010000 ) {
            // we're in a setup screen     
            // decreasing value at current cursor position

          change_setup_value(setup_step, -1);
          status |= B00000001;

          return;
      }
      else {

           // main menu - turn off intervalometer
           // re-set latch matched (if set)
         status &= B01110111;
         shots_fired = 0;
       }

      break;

   case 2:
     // left button was hit

      // do nothing if in setup menu          
     if( status & B00010000 )
       return;

           // main display, cycle through display values

     if( disp_enable & B10000000 ) {
           // we were already left, move to the furthest right
           // value
         disp_enable = B00000001;
           // set screen to update
         status |= B00000001;
     }
     else {
             // shift current display value left
           disp_enable = disp_enable << 1;
           status |= B00000001;
     }  

     break;

   case 3:
     // right button was hit

      // do nothing if in setup menu    
     if( status & B00010000 )
         return;       

           // main display, cycle through display values

       if( disp_enable & B00000001 ) {
           // we were already at furthest right value,
           // need to move to furthest left value
         disp_enable = B10000000;

           // set screen to update
         status |= B00000001;
       }
       else {
             // shift current display right
           disp_enable = disp_enable >> 1;
             // set screen to update
           status |= B00000001;
       }

     break;

   case 4:

      // center button hit

      if( status & B00010000 ) {
          // in setup mode - we're going to change which
          // setup value we're displaying

          // set display to update   
        status |= B00000001;

        if( setup_step == MAX_SETUP_STEPS - 1 ) {
            // no more steps to go, exit menu 
          setup_step = 0;
            // set that we're no longer in setup
          status &= B11101111;
          return;
        }

        setup_step++;
        return;

      }
      else {
          // not in setup or input -
          // go into setup mode, tell display
          // to refresh
        status |= B00010001;
        return;
      }

      break;
  }

}

void change_setup_value( byte which, int what ) {

  switch( which ) {
    case 0:

      {

        // change iso value, convert to logarithmic
        // scale first, then add or subtract one step
        // and convert back to arithmetic scale 

       float foo = log(iso_rating) / log(10);

       int din = ( 10 * foo ) + 1;

       din += what;

       if( din < 1 )
          din = 1; 

       float bar = pow(10, (float) ( (float) din - 1) / (float) 10 );

       if( bar > int(bar) ) {
          iso_rating = int(bar) + 1;
       }
        else {
          iso_rating = int(bar);
        }

      }

      break;

    case 1:
      {
          // move f_stop value - move one third step
          // either direction

        float steps = log( f_stop ) / log( sqrt(2) );

        if( what > 0 ) {
          steps += 0.3333;
        }
        else {
          steps -= 0.3333;
        }

        if( steps < 0 )
          steps = 0;

        f_stop = pow( sqrt(2), steps );

      }
      break; 

    case 2:
        // ev adjust moes in 1/4 EV increments

      ev_adjust += (float) what * 0.25;
      break;

    case 3:
        // ev steps determines how many divisions of an EV
        // there are when calculating automatic exposure
        // values.  more steps = better granularity in exposure
        // timing.

      ev_steps += what;
      if( ev_steps < 0 )
        ev_steps = 0;

      break;

    case 4:

      camera_delay += what;

      if( camera_delay < 1 )
        camera_delay = 1;

        // ms delay time
      real_camera_delay = camera_delay * 1000;

      break;    

    case 5: 

        // cycle between latch settings

      if( status & B01000000 ) {
        status &= B10111111;
        status |= B00100000;
      }
      else if( status & B00100000 ) {
        status &= B10011111;
      }
      else {
        status |= B01000000;
      }

      break;

    case 6:

      min_exp_tm += what;

        // don't allow min time to be less than 0
      if( min_exp_tm <= 0 )
        min_exp_tm = 0;

      break;

    case 7:

      max_exp_tm += what;

        // don't allow max time to be less than 0
      if( max_exp_tm <= 0 )
        max_exp_tm = 0;

      break;

    case 8:

        // change scaling:
        // scaling value can be 2, 10, or 100
        // allow wrap around from highest to lowest
        // and vice-versa
      freq_mult += what;

        // we only get to 11 by going up from 10 and
        // we only 1 by going down from 2 - next step
        // either way is 100
      if( freq_mult == 11 || freq_mult == 1 ) {
        tsl_set_scaling(100);
      }
      else if( freq_mult == 9 || freq_mult == 101 ) {
          // if we're moving down from 10, or up from 100
          // move to lowest setting
        tsl_set_scaling(2);
      }
      else {
          // if neither of the above cases is true, then our only
          // destination is 10
        tsl_set_scaling(10);
      }

      break;

    case 9:
      {
          // move ttl_stop value - move one third step
          // either direction

        float steps = log( ttl_stop ) / log(sqrt(2));

        if( steps < 0 )
          steps = 0;

        if( what > 0 ) {
          steps += 0.3333;
        }
        else {
          steps -= 0.3333;
        }

          // for ttl stop, we want to get to zero, if possible
          // for non-ttl readings.  We go ahead and skip every stop below
          // 1.0 for the heck of it. (Very few lenses go below 1.0)

        if( steps < 0 ) {
          ttl_stop = 0.0;
        }
         else {
           ttl_stop = pow( sqrt(2), steps );

            // handle rounding for higher f-stops
           if( ttl_stop > 7.1 )
             ttl_stop = int(ttl_stop);
        }

      }
      break; 

    case 10:

      light_type = light_type == 1 ? 0 : 1;
      break;

    case 11:

      ev_diff_ceiling += what;
      break;

    default:
      break;
  }

 return;
} 

~ by c.a. church on March 25, 2009.