Pentax K7 – 590nM IR – FA 50/1.4

So, without further ado, the code is behind the cut:

Note: I wrote this code as part of the Graffik application.  The latest version of this code can always be found on Github, here: skinneddial.h, skinneddial.cpp

skinneddial.h:

/*

Copyright (c) 2012 Dynamic Perception

  This software 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 software 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.

  You should have received a copy of the GNU General Public License
  along with this software.  If not, see <http://www.gnu.org/licenses/>.

  */

#ifndef SKINNEDDIAL_H
#define SKINNEDDIAL_H

#include <QDial>
#include <QPixmap>
#include <QPainter>
#include <QPaintEvent>
#include <QTransform>

/** Custom-Skinned QDial

  This class allows one to create a custom-skinned QDial by supplying your own image
  for the background and needle, both through Qt Style Sheets and through normal C++
  usage.

  Example Usage:
  @code
  #include "skinneddial.h"

  ...

  SkinnedDial* myDial = new SkinnedDial();
  @endcode

  All look and feel is provided through images, you cannot have hash marks drawn programmatically, if you
  want them, put them in your image.

  @section dialvalues Acceptable QDial Limits

  The SkinnedDial class makes an assumption that the center of the dial is at the value of 0, and
  that negative values are on the left side of the dial, and the positive values are on the right
  side.  SkinnedDial requires that the minimum be < 0 and the maximum be > 0 and that there be
  an equivalent distance on both side of the dial. For example:

  @code
  myDial->setMaximum(100);
  myDial->setMinimum(-100);
  @endcode

  You must also specify where the maximum travel of the dial is, in degrees.
  See the \ref qsscustom "Customing the look and feel via QSS" section for more information.

  @section qsscustom Customizing the look and feel via QSS

  You can control the look and feel of the SkinnedDial via Qt Stylesheets by setting values for the custom
  properties associated with the skinned dial.

  It is expected that the backgroundImage and needleImage are of the exact same dimensions, and the needleImage
  is transparent everywhere the needle isn't.

  The maxAngle property determines the extent that the needle may travel on either side of the circle.  140' would
  imply that the needle may not move more than 140' either clockwise or counter-clockwise.

  @code
  SkinnedDial {
    qproperty-backgroundImage: url(:dial-back.png);
    qproperty-needleImage: url(:dial-needle.png);
    qproperty-maxAngle: 140;
   }
   @endcode

   @section scaling Scaling of Images

   Your images are automatically scaled relative to the container, up and to the full size of the input
   image.  The input image will not be scaled larger than its original size.

   @author
   C. A. Church

   Copyright &copy; 2012 Dynamic Perception LLC
   */

class SkinnedDial : public QDial
{
    Q_OBJECT
        /** Background Image Property

          Sets the background image for the dial (the dial its self, and any surrounding decoration).
          */
    Q_PROPERTY(QPixmap backgroundImage READ backgroundImage WRITE setBackgroundImage DESIGNABLE true)
        /** Needle Image Property

          Sets the needle (pointer) image, to be drawn over the dial. Must be the same width and height
          as the background image, and transparent everywhere the needle isn't.
          */
    Q_PROPERTY(QPixmap needleImage READ needleImage WRITE setNeedleImage DESIGNABLE true)
        /** Maximum Rotation Angle Property

          Sets the maximum angle at which the needle may be rotated on either side of the dial
          */
    Q_PROPERTY(float maxAngle READ maxAngle WRITE setMaxAngle DESIGNABLE true)

public:
    explicit SkinnedDial(QWidget *parent = 0);
    SkinnedDial(QPixmap* c_back, QPixmap* c_needle, float c_angle, QWidget *parent = 0);

    ~SkinnedDial();

    QPixmap backgroundImage();
    void setBackgroundImage(QPixmap p_img);

    QPixmap needleImage();
    void setNeedleImage(QPixmap p_img);

    float maxAngle();
    void setMaxAngle(float p_angle);

protected:

    void paintEvent(QPaintEvent *pe);

signals:

public slots:

private:

    QPixmap* m_background;
    QPixmap* m_needle;
    QPainter::RenderHint m_paintFlags;
    float m_maxDeg;

    QPixmap* m_cacheBackground;
    QPixmap* m_cacheNeedle;

    int m_cacheVal;
    int m_cacheWidth;
    int m_cacheHeight;

    QPixmap _rotatePix(QPixmap* p_pix, float p_deg, bool p_dir);

};

#endif // SKINNEDDIAL_H

skinneddial.cpp:

#include "skinneddial.h"

 /** Constructor

   Create a new instance of SkinnedDial, with no images pre-defined.

   You must set the images and values required for display via the property setters before use.

   @param parent
   The parent widget
   */
SkinnedDial::SkinnedDial(QWidget *parent) : QDial(parent) {

    m_background      = new QPixmap;
    m_needle          = new QPixmap;
    m_maxDeg          = 180.0;
    m_paintFlags      = QPainter::RenderHint(QPainter::Antialiasing | QPainter::SmoothPixmapTransform || QPainter::HighQualityAntialiasing);
    m_cacheBackground = new QPixmap;
    m_cacheNeedle     = new QPixmap;
    m_cacheVal        = 0;
    m_cacheWidth      = 0;
    m_cacheHeight     = 0;

}

 /** Constructor

   Create a new instance of SkinnedDial, specifying all images and maximum angle.

   @param c_back
   The backgroundImage for the dial

   @param c_needle
   The needleImage for the dial

   @param c_angle
   The maxAngle for the dial

   @param parent
   The parent widget
   */
SkinnedDial::SkinnedDial(QPixmap* c_back, QPixmap* c_needle, float c_angle, QWidget *parent) : QDial(parent) {

    *m_background      = *c_back;
    *m_needle          = *c_needle;
    m_maxDeg           = c_angle;
    m_paintFlags       = QPainter::RenderHint(QPainter::Antialiasing | QPainter::SmoothPixmapTransform || QPainter::HighQualityAntialiasing);
    *m_cacheBackground = *m_background;
    *m_cacheNeedle     = *m_needle;
    m_cacheVal         = 0;
    m_cacheWidth       = 0;
    m_cacheHeight      = 0;
}

SkinnedDial::~SkinnedDial() {
    delete m_background;
    delete m_needle;
    delete m_cacheBackground;
    delete m_cacheNeedle;
}

void SkinnedDial::setBackgroundImage(QPixmap p_img) {
    *m_background = p_img;
}

QPixmap SkinnedDial::backgroundImage() {
    return *m_background;
}

void SkinnedDial::setNeedleImage(QPixmap p_img) {
    *m_needle = p_img;
}

QPixmap SkinnedDial::needleImage() {
    return *m_needle;
}

float SkinnedDial::maxAngle() {
    return m_maxDeg;
}

void SkinnedDial::setMaxAngle(float p_angle) {
    m_maxDeg = p_angle;
}

/** Overloaded paintEvent
  */

void SkinnedDial::paintEvent(QPaintEvent *pe) {

    QPainter painter(this);
    QRect eventRect = pe->rect();

    bool cacheHit = true;

        // scale pixmap so that it fits within the
        // boundaries of the event

    int height = eventRect.height();
    int  width = eventRect.width();

        // only perform scaling again if our event rectangle has changed
    if( height != m_cacheHeight || width != m_cacheWidth ) {
        if( width >= height ) {
            if( height <= m_background->height() ) {
                *m_cacheBackground = m_background->scaledToHeight(height, Qt::SmoothTransformation);
                *m_cacheNeedle     = m_needle->scaledToHeight(height, Qt::SmoothTransformation);
            }
        }
        else {
            if( width <= m_background->width() ) {
                *m_cacheBackground = m_background->scaledToWidth(width, Qt::SmoothTransformation);
                *m_cacheNeedle     = m_needle->scaledToWidth(width, Qt::SmoothTransformation);
            }
        }
        m_cacheHeight = height;
        m_cacheWidth  = width;
        cacheHit      = false;
    }

     // find top-left corner to start placing the pixmap for the background,
     // centering it in the total event area

    int leftPoint = (width - m_cacheBackground->width()) / 2;
    int topPoint  = (height - m_cacheBackground->height()) / 2;

    QPoint startPix(leftPoint, topPoint);

    painter.setRenderHints(m_paintFlags);
    painter.drawPixmap(startPix, *m_cacheBackground);

        // rotate the needle image and display it

    int curVal = this->value();
    QPixmap rotNeedle = *m_cacheNeedle;

        // only re-process the needle image if the position
        // changes, or we had a size cache miss

    if( curVal != m_cacheVal || cacheHit == false ) {

       if( curVal < 0 ) {
            float pct = (float) abs(curVal) / (float) abs(this->minimum());
            rotNeedle = _rotatePix(&rotNeedle, m_maxDeg * pct, false);
        }
       else if( curVal > 0 ) {
            float pct =(float)  abs(curVal) / (float) abs(this->maximum());
            rotNeedle = _rotatePix(&rotNeedle, m_maxDeg * pct, true);
        }

        m_cacheVal = curVal;
    }

    painter.drawPixmap(startPix, rotNeedle);

}

QPixmap SkinnedDial::_rotatePix(QPixmap *p_pix, float p_deg, bool p_dir) {

        // all rotation is CCW, so calculate for the "right" side of the knob
    if( p_dir == false )
        p_deg = 360.0 - p_deg;

        // perform rotation, transforming around the center of the
        // image

    QTransform trans;
    trans.translate(p_pix->width()/2.0 , p_pix->height()/2.0);
    trans.rotate(p_deg);
    trans.translate(-p_pix->width()/2.0 , -p_pix->height()/2.0);
    QPixmap outPix = p_pix->transformed(trans, Qt::SmoothTransformation);

        // re-crop to original size
    int xOffset = (outPix.width() - p_pix->width()) / 2;
    int yOffset = (outPix.height() - p_pix->height()) / 2;
    outPix = outPix.copy(xOffset, yOffset, p_pix->width(), p_pix->height());

    return outPix;

}

Additional Features:

• Battery Voltage Monitoring
• Self-Regulating Temperature with DC fan control
• Optical isolation between relays and CPU
• Fail-safe aux control with mechanical switches
• All relays in off-state during power-up

Example docs.pri

# Documentation

OTHER_FILES += \
    docs/docs.html \
    docs/docs1.png \
    docs/docs2.png \
    docs/docs.qhp \
    docs/docs.qhcp

HEADERS += \
    docs/helpwindow.h \
    docs/helpbrowser.h

SOURCES += \
    docs/helpwindow.cpp \
    docs/helpbrowser.cpp

FORMS += \
    docs/helpwindow.ui

defineTest(helpCopyCommands) {
    files = $$1
    for(FILE, files) {

              # get rid of trailing 'docs/'

        FILE ~= s,docs/,,

        FILE = $$PWD/$$FILE

              # Replace slashes in paths with backslashes for Windows
        win32:FILE ~= s,/,\\,g

        MYFILECOPY += @echo "Copying $$FILE" $$escape_expand(\\n\\t)
        MYFILECOPY += $$QMAKE_COPY $$quote($$FILE) $$quote($$DDIR) $$escape_expand(\\n\\t)
    }
    export(MYFILECOPY)
}

help_copy.target = dox
help_copy.commands = @echo "Building Help Files in $$DDIR"  $$escape_expand(\\n\\t)
QMAKE_EXTRA_TARGETS += help_copy
POST_TARGETDEPS += dox

win32 {

  CONFIG += help
  CONFIG(debug, debug|release) {
        DDIR = $$OUT_PWD/debug/docs
  }
  CONFIG(release, debug|release) {
        DDIR = $$OUT_PWD/release/docs
  }

!exists($$DDIR) {
    help_copy.commands += @echo "Creating Docs Directory: $$DDIR ($$EDIR)" $$escape_expand(\\n\\t)
    help_copy.commands += md $$DDIR $$escape_expand(\\n\\t)
  }
# replace forward-slashes

  DDIR ~= s,/,\\,g

  helpCopyCommands($$OTHER_FILES)

  help_copy.commands += $$MYFILECOPY
  help_copy.commands += @echo "Running qhelpgenerator" $$escape_expand(\\n\\t)
  help_copy.commands += $$[QT_INSTALL_BINS]\\qhelpgenerator $$DDIR\\docs.qhp -o $$DDIR\\docs.qch $$escape_expand(\\n\\t)
  help_copy.commands += @echo "Running qcollectiongenerator" $$escape_expand(\\n\\t)
  help_copy.commands += $$[QT_INSTALL_BINS]\\qcollectiongenerator $$DDIR\\docs.qhcp -o $$DDIR\\docs.qhc $$escape_expand(\\n\\t)
}

# OSX Instructions
macx {

 LIBS += -framework QtHelp

 DDIR = $$OUT_PWD/$$TARGET.app/Contents/MacOS/docs

 !exists($$DDIR) {
    help_copy.commands += @echo "Creating Docs Directory: $$DDIR" $$escape_expand(\\n\\t)
    help_copy.commands += mkdir -p $$DDIR $$escape_expand(\\n\\t)
  }

 helpCopyCommands($$OTHER_FILES)
 help_copy.commands += $$MYFILECOPY
 help_copy.commands += @echo "Running qhelpgenerator" $$escape_expand(\\n\\t)
 help_copy.commands += $$[QT_INSTALL_BINS]/qhelpgenerator $$DDIR/docs.qhp -o $$DDIR/docs.qch $$escape_expand(\\n\\t)
 help_copy.commands += @echo "Running qcollectiongenerator" $$escape_expand(\\n\\t)
 help_copy.commands += $$[QT_INSTALL_BINS]/qcollectiongenerator $$DDIR/docs.qhcp -o $$DDIR/docs.qhc $$escape_expand(\\n\\t)
}

The first step in the process has been to create two raised bed areas, one along the fenceline as a primary garden, and another along the house with a trellis for berries and climbing vines.  Both boxes have been completed and the main garden box is getting well-established after only a few weeks.  The vines box still needs its trellis made and to have vines planted.  When completed the backyard will also have a water garden, one potted fruit tree, a paved seating area and a center firebox for entertaining.

All boxes were designed with both looks and simplicity in mind.  Whitewood 2x4s are utilized, and the only cuts required are for the end-pieces to cut them to shape.  For the main garden box, the height chosen was 5 2x4s and the width approximately 2 3/4 feet.  Resulting in approximately 25 cubic feet of useful contained soil.  No fastening hardware is used, instead the panels are assembled using expanding glue and pipe clamps.  Having irregular jointing from the standard edges on the 2×4 studs, and a rough application of custom-mixed stain with a single coat gives the boxes a bit of a rustic edge, while still having a clearly decorative intent.  Three heavy coats of spar urethane inside and out provide a lot of protection for facing the weather.  Due to the gaps in the rough joints, an interior liner of weed fabric is used to keep the soil from spilling out of the larger gaps.

The main box follows a basic square-foot style gardening tactic, with 14 divided sections – 12 at 12″x16″, and two at 18″x16″.  This high-density method takes a little more work, but can produce a lot more, and a larger variety of, crop in the same amount of area.  The two larger sections are currently used for the biggest plants: our heirloom tomatoes and purple pole beans.  Other plants include: jalapeno peppers, three kinds of basil, sage, rosemary, carrots, beets, arugula, soybeans, lavender, thyme, chives, bell peppers, and micro greens.   Three areas are reserved for micro greens and as this is a thing we love to constantly eat, they are planted to ensure a nearly-constant harvest once they take off.  At 25 days to harvest, each plot is planted one week after the next, and re-planted when harvested.  Our first batch of seeds didn’t perform well, so we just re-planted with a new batch of seeds this weekend.  We’re hoping the timing on this will keep us in fresh bits of salad well into the winter. The pole beans have been our most aggressive grower, in just two and a half weeks since planting seeds, they have grown up to several feet above their 3′ poles.

Of course, urban gardening is not without its pests: our basil and thyme have been hit the hardest.  The basil by large caterpillars and small grasshoppers, and the thyme by snails.  We have a large rue plant to attract the black swallowtail caterpillars, but as of late there haven’t been any.  We can’t identify this caterpillar eating our basil, so we’re presuming it to be a large moth. Lids of beer set out are starting to do their job with the snails, but I doubt we’ll make much of a dent.

We love mint too, but it has no place in a container garden with other plants – it tends to grow wild and out of control.  So, our peppermint is happily getting along in a large pot.

As we get more done in the backyard, we’ll post photos and how we did it. In the mean-time, here are a few garden photos:

Pentax K7+CPol+ND8

Pentax K7, Sigma 17-70 + CPol

While I understand that most of the DIY builders reading this post are long past the point of building just a simple intervalometer, for those just getting started, this should be highly informative. Unlike many other tutorials, I’m not just giving you some schematics and a block of code. Instead, my goal is to explain why things are done a certain way, and teaching foundations for better system design.

This tutorial covers building a simple test circuit that will allow you to validate your software and hardware without putting wear on your camera, the importance of protecting your equipment from mistakes, three different timing options: blocking, non-blocking, and non-blocking using simple interrupts, and finally controlling a Canon or Pentax camera. (Nikon, etc. I don’t have much info on – perhaps one of the Nikon-having contributors can expand in a later tutorial.)

The tutorial can be accessed here: http://openmoco.org/node/88

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.  (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);
}

tsl230r_functions.pde:

/*

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('[');
print_float(ev_adjust);
lcd.print(']');
}

}

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;
}

photo_calculations.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.

*/

/*

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;
}