IR intervalometer for camera

The basic idea was to create IR intervalometer for my Nikon DSLR. I have found in network information about captured raw signal from existing Nikon ML-L3 remote control. So, I have decided to use this information and Arduino Uno to create IR time-lapse intervalometer device for Nikon DSLR. Original RAW IR signal is modulated with 38kHz frequency and have following timings:

- 2.0 ms - on

- 28.0  ms - off

- 0.5 ms - on

- 1.5 ms - off

- 0.5 ms - on

- 3.5 ms - off

- 0.5 ms - on

- 63.5 ms - off

First step was to create a shield for arduino with support for IR LED and one button. IR diode is driven by NPN transistor to achieve 35 mA of current and larger distance for control. Button it pulled-up to 5 volt. Here is schematic:

Second step was to create program. Value of current interval for time-lapse is stored in EEPROM and it is possible to update it by USB serial by sending command:

- setInterval:12345 (five digit value of interval in seconds). I have used two libraries:

- first for button debouncing. Here is library source: https://github.com/thomasfredericks/Bounce2

- second for driving IR LED. Here is library source: https://github.com/z3t0/Arduino-IRremote

Here is flow diagram for program:

Source code is also available in attachment.

/*
   Basic IR intervalometer for Nikon DSLC cameras
   by kk99
   2018
*/

#include 
#include 
#include 

IRsend irSend;
Bounce debouncer = Bounce();

const int BUTTON_PIN = 2;
const unsigned long DEFAULT_TIMELAPSE_INTERVAL_SEC = 5;
const int EEPROM_ADDRESS = 0;
bool isWorkingMode = false;
bool requestNextPhoto = false;
bool isUpdateTimelapseInterval = false;
unsigned int timelapseIntervalValueToUpdate = 0;
unsigned long timelapseIntervalMs = 0;
unsigned long lastPhotoTime = 0;

unsigned long getTimelapseInterval(void)
{
  unsigned long timelapseIntervalVal = 0;
  EEPROM.get(EEPROM_ADDRESS, timelapseIntervalVal);
  return timelapseIntervalVal;
}

void setTimelapseInterval(unsigned long timelapseIntervalVal)
{
  EEPROM.put(EEPROM_ADDRESS, timelapseIntervalVal);
}

void takePhoto(void)
{
  // modulation frequency in kilohertz
  int frequency = 38;
  // signal for take a photo by Nikon DSLR
  unsigned int irSignal[] = {2000, 28000, 500, 1500, 500, 3500, 500, 63500};
  irSend.sendRaw(irSignal, sizeof(irSignal) / sizeof(irSignal[0]), frequency);
}

void workingModeLED(bool on)
{
  if (on) {
    digitalWrite(LED_BUILTIN, HIGH);
  } else {
    digitalWrite(LED_BUILTIN, LOW);
  }
}

void setup() {
  // initialize serial communication
  Serial.begin(9600);
  // initialize digital pin for builtin status LED as an output
  pinMode(LED_BUILTIN, OUTPUT);
  workingModeLED(false);

  // initialize digital pin for button as an input
  pinMode(BUTTON_PIN, INPUT);
  // setup button debouncer
  debouncer.attach(BUTTON_PIN);
  debouncer.interval(50);

  // read timelapse interval in seconds
  unsigned long tempTimelapseIntervalVal = getTimelapseInterval();
  if (tempTimelapseIntervalVal == 0) {
    Serial.println("Restored default value of time-lapse interval");
    tempTimelapseIntervalVal = DEFAULT_TIMELAPSE_INTERVAL_SEC;
    setTimelapseInterval(tempTimelapseIntervalVal);
  }
  timelapseIntervalMs = tempTimelapseIntervalVal * 1000;
  Serial.println("Intervalometer initialized");
}

void loop() {
  // update time
  unsigned long timestamp = millis();

  // check button state
  debouncer.update();
  bool buttonState = debouncer.fell();
  if (buttonState) {
    isWorkingMode = !isWorkingMode;
  }

  // update status LED
  workingModeLED(isWorkingMode);

  if (isWorkingMode) {
    // check timelapse interval
    if (requestNextPhoto) {
      unsigned long diffMs = timestamp - lastPhotoTime;
      if (diffMs > timelapseIntervalMs) {
        requestNextPhoto = false;
      }
    }

    // take a photo
    if (!requestNextPhoto) {
      Serial.println("Captured picture");
      takePhoto();
      requestNextPhoto = true;
      lastPhotoTime = timestamp;
    }
  } else {
    requestNextPhoto = false;
    lastPhotoTime = 0;
    if (isUpdateTimelapseInterval) {
      unsigned long currentTimelapseInterval = timelapseIntervalMs / 1000;
      if (currentTimelapseInterval != timelapseIntervalValueToUpdate) {
        setTimelapseInterval(timelapseIntervalValueToUpdate);
        timelapseIntervalMs = timelapseIntervalValueToUpdate * 1000;
        Serial.println("Updated value of time-lapse interval");
      }
      isUpdateTimelapseInterval = false;
    }
  }
}

void serialEvent() {
  if (isUpdateTimelapseInterval) {
    return;
  }

  const int dataLength = 18;
  if (Serial.available() < dataLength - 1) {
    return;
  }

  int i = 0;
  char receivedData[dataLength] = { 0 };
  while (Serial.available() > 0) {
    char character = Serial.read();
    if (i < dataLength - 1) {
      receivedData[i] = character;
    }
    i++;
  }

  char *data = strstr(receivedData, "setInterval:");
  if (data) {
    data += 12;
    int timelapseIntervalVal = atoi(data);
    if (timelapseIntervalVal > 0) {
      Serial.println("Got new value of time-lapse interval in seconds:");
      Serial.println(timelapseIntervalVal);
      isUpdateTimelapseInterval = true;
      timelapseIntervalValueToUpdate = timelapseIntervalVal;
    }
  }
}

Here is example video of remote controlling of Nikon DSLR:

Edit media

Dimensions x Small Medium Large Custom

Subject (required) Brief Description Tags (separated by comma) Video visibility in search results Visible Hidden

Parent content

Project14 | The Birthday Special: Open Arduino: The Winners Announcement! Project14 | The Birthday Special: Open Arduino Projects: Part 2! IR intervalometer for camera Project14 | Open Arduino: You Decide: Meet the Projects: Part 2!

Poster

Upload Preview

Ok

Cancel