Remote Canon DSLR Video Trigger

UPDATE: You might want to check out my newer, simpler, cheaper version of this device.  Just as effective, but less complex and much cheaper:https://www.instructables.com/id/Long-Range-Canon-DSLR-Video-Trigger-V2-greatly-s/

If you are still interested in this version, read on!

I had a problem that I needed to solve:

Remotely and wirelessly trigger the video recording on my Canon 60D DSLR camera, non-line of sight, from further than an IR remote would allow.    

This would eliminate a lot of dead footage when shooting solo or when you want to be in the shot with other people.  

As anyone who has looked into this knows, there are NO commercially available systems (or even really any hacked together non-commercial systems that I could find) available for doing this.  Still pictures, no problem, but Canon doesn't have a way to do that for video without an IR remote (which is about 10ft, line of sight range).   I looked into what I had (both materials and skillset), and decided on building a solution.  This should work on any Canon DSLR that shoots video (T2i, T3i, 60d, 7d, 5d Mk2) but I have only tested it on my camera.

My solution uses an atmega328 chip on proto board (basically just a scratch built Arduino), a commercially available RF photo trigger and an IR LED to trigger the camera to record.   

The basics of the solution are this:

1: The commercial RF shutter trigger sends a signal to take a photo, which the Arduino reads (as a state change on the input pin).
2: The Arduino triggers the IR LED in a sequence which tells the camera (thru it's IR receiver) to take a video.
3: The control box beeps once to provide an audible alert that recording has fired off, and the power LED starts blinking
4: When the RF trigger button is pushed again to stop recording, the same sequence happens again, except the box beeps twice, and the power LED stops flashing and returns to solid.  

Now I have a trigger which will allow me to start video recording from at least 150ft away (the RF trigger claims 300ft, but I have only tested it out to 150ft so far).

My apologies ahead of time, this is not really a step-by-step "How to", but more of an overview of how it was built.  I am bad about taking pictures during building something, I usually think of it after I am done.   

This could also be done with a custom-built RF solution, but for simplicity, time and cost effectiveness, I chose to do it with a readily available commercial solution.   I also realize what I am doing here is a fairly simple thing for an Arduino to do, and there are probably much simpler, cheaper, more elegant ways to do this.  This is how I knew to do it, and the tools I had available.  If you come up with a different (better) way, please post a link to your Instructable in the comments.   

Step 1: What You Will Need

 (Or more accurately: What I used)

You can build this with just a regular Arduino board, and a few off the shelf parts if you want.  I didn't want to use my actual Arduino, for both space considerations, and the fact that I only have one.  I had an ATmega328 chip from a prior project to build one from scratch, so I did.

If you are building one from scratch, here are the parts you need to build the Arduino and power supply:

1 10k ohm resistor (for Arduino reset)
1 220ohm resistor (for Power LED)
1 Battery block/connector - 9V
1 Battery, 9v
2 Ceramic Capacitor - 22pF
1 Crystal - 16Mhz
1 Electrolytic Capacitor 100uF/25v
1 Electrolytic Capacitor 10uF/10v
1 Pushbutton momentary switch (for Arduino reset)
1 Rectifier Diode - 1N4001
1 Power Switch - I used a nice RS one with a built-in LED - RS Part # 275-0009
1 Voltage Regulator - 5V - LM7805
1 ATmega328p microcontroller chip with Arduino Bootloader (Sparkfun  sku: DEV-10524, or elsewhere online)
1 28-pin DIP Socket (DON'T solder your ATmega directly to the protoboard)
1 2.1mm center positive DC Jack, Panel Mount
1 Enclosure with breadboard - Datak - Protobox Kit # 12-206 from Vetco Electronics (www.vetco.net )


Once you have those parts (Or if you are just going to use an Arduino of some description), here are the remaining parts needed:

1 Piezo Speaker - RS Part #273-059
1 Stereo Jack 3.5mm - I used a Panel Mount version in my enclosure
1 Stereo Plug 3.5mm, Male - This is for making the IR emitter the way I did, more explanation later.
1 Stereo Jack 2.5mm - Panel Mount
1 Stereo 3.5mm Extension (6" or so will do, I use a longer one, because thats what I had, and it gives some versatility)
2 IR LED (Again due to the way I made my IR emitter)
1 47ohm resistor (for IR LED)
and finally, your commercial RF Shutter Trigger. I used an Alzo Wireless Radio Shutter Release (http://www.amazon.com/gp/product/B001KA19E0 )  - Make sure you get the one specifically with the 2.5mm jack for the Canon 60d, T3i, etc.  

Tools/materials needed to complete this project:

- Soldering iron and solder (and other associated soldering stuff)
- Wire (22AWG, or there about)
- Glue gun and glue
- Heat shrink tubing (to clean up/insulate connections, if desired)
- Drill and appropriately sized bits for adding the jacks to your project box
- Phillips head screwdriver (for opening/closing the project box, and securing your protoboard inside)
- Small piece of neoprene or foam to pad battery compartment


Carry onwards...  

Step 2: Building Your System

This is going to be focused on building your system from scratch.  If you are simply going to use an Arduino, skip to the Arduino code page.   

I have included a schematic diagram, and a breadboard diagram picture from Fritzing.  See the attached PDF for a better resolution schematic diagram. 

These are the basics you need to make the system work.   I will leave the circuit board layout up to you, mine was fairly messy and took a lot of hours of soldering and messing with things.   As you can see in the pictures, it's not very pretty, but it works.   

A few design notes on why certain things are the way they are:

The 2.5mm jack has the RF Shutter trigger attached to it.   When the trigger fires, it makes a contact between the ground and the tip connector on the jack.   If you do a half-press on the shutter trigger button, it does the focus, which uses the ring (middle) connector on the jack , but since I didn't care about that for video, I don't hook that up.

The 3.5mm jack with the IR LED is so that you can add an extension to the IR LED to allow it to reach in front of the camera's IR Receiver.   I had also already built a DSLR.bot IR unit to use with my iPhone.  (See this Instructable for how to do that:  https://www.instructables.com/id/DIY-Infrared-transmitter-for-iPhone-iPod/ )   In order to keep the flexibility and not have to re-create another piece, I simply used that as my IR transmitter.  You may have to adjust the way you make your system if you don't go that route.   Using the DSLR.Bot style transmitter, I do not use the ground on the 3.5mm Jack, I just use the R and L channels.   

On the enclosure, there is a 2.1mm DC input jack.  This is despite the enclosure having a battery compartment.  I did this just to give it the option of having a wall wart to power it, in case I ever needed that.  (NOTE: if you add this, make sure you unplug the internal battery first before plugging the wall wart in.)  

I have left out the 3.5mm jack, and just have the IR LED directly attached in the diagrams.   

This step takes time and patience and planning to put it all together.  You are mostly on your own to figure out the best way.   Follow the schematic and the breadboard diagram and you should be able to figure it out.  

Step 3: Putting It All Together

It's time to roll the whole thing into it's enclosure.   See the pictures for how it generally all fits.  

Some notes, the power switch I used contains an LED.   This is wired into a pin on the Arduino so that it can be controlled.  When you first turn the box on, it will take a second to light up.    

The piezo buzzer is installed on the outside of the box, because I couldn't manage to squeeze it inside the enclosure. Plus it makes it louder being on the outside.   

The enclosure I used has a removable front panel that you drill the holes in for the 3.5mm jack, 2.5mm jack and power button.   Be careful when drilling it for the larger holes, use a step bit, or start with a smaller bit and work your way up, otherwise you risk breaking it (Which I stupidly did).   

A note for the battery compartment of this specific project box.  A 9v battery is loose in the compartment, I used a piece of foam type material I had and hot glued it to the bottom of the compartment. This gave a nice tight fit when the battery door is closed.  You don't want your battery bouncing around in there.  

I also made sure to hot-glue the jacks and the switch, and any wiring that might get tugged on when changing the battery to make it more durable in the field.  

I took the RF receiver and added a velcro square to the back of it, and to the top of the case so it would not be flopping around.

Finally, I made a hotshoe mount out of some plastic material I had to mount the whole thing on the top of the camera (sorry, no pictures of this, but you can see the box mounted on the camera in the pictures).   

Step 4: Arduino Code

Here is the Arduino code to make the whole thing run.  

Credit for the IR remote control code goes to Martin Koch  http://controlyourcamera.blogspot.com/  with his thanks  to http://www.doc-diy.net/photo/rc-1_hacked/index.php for figuring out the IR code.

The code is well commented, but the general idea is this:

- The SWITCH pin is set to open input state of HIGH, this is the pin the RF trigger is attached to.  
- The state of the Power LED is set to HIGH, and the loop watches for a change from not running to running. If this occurs, the LED blinks (while video is being shot), and vice-versa, once recording stops, the LED returns to solid.
- The Arduino looks for the SWITCH pin to be pulled LOW, indicating the trigger has been pressed.
- Once this occurs, it fires the Start/stop video sequence to the IR LED.
- The video state of running is set or unset.
- The Piezo buzzer beeps (once for start, twice for stop)

Simple as that.

The LED blink code was written from a sample of code I found that allows the LED to blink without using the delay(); function so that no button presses are missed during a delay in the loop.   A small delay is written into the piezo buzzer function because this fires immediately after the recording stops or starts, and doesn't run continuously.

I don't have an AVR programmer, so I used my Arduino to write the code to the atmega328 chip I had simply by pulling the stock chip off my Arduino, inserting the chip I was using for this project, writing the code to it, and swapping it out again.  

Here is the code (also attached in a .TXT file, rename to .pde) :

/*
Based on Arduino sketch for simulating a Canon RC-1 IR remote control to start and stop video recording on a Canon 5D Mark II or 7D
 2010, Martin Koch
 http://controlyourcamera.blogspot.com/
 Huge thanks go to http://www.doc-diy.net/photo/rc-1_hacked/index.php for figuring out the IR code.

 Modified by JustinHerx for accepting input from a remote (wired/wireless) and turning the
 output into an IR command to activate/deactivate video recording on a Canon 5D MII, 7D, 60D, etc.
 Parts required:
 - Arduino
 - Power LED (or switch with power LED, I am using an illuminated pushbutton switch from RadioShack # 275-0009)
 - Piezo buzzer (RadioShack #273-059)
 - 2.5mm jack to attach camera trigger
 - IR LED to trigger camera
 - Resistor for LED
 */

const int irLED = 11;
const int SWITCH = 7;
const int buzzPin = 8;
const int powerLED = 4;
boolean running = false;
int ledState = HIGH; // ledState used to set the LED
long previousMillis = 0; // will store last time LED was updated
long interval = 200; // interval at which to blink (milliseconds)

unsigned int pulseDuration = 10; //microseconds
//The required 15 microseconds pulseDuration didn't work since digitalWrite consumes some additional time
//thats adds to pulseDuration value. 10 to 12 microseconds worked for me.

unsigned int photo = 7330; //A 7330 microseconds delay between bursts shoots a photo.
unsigned int video = 5360; //A 5360 microseconds delay between bursts starts/stops video recording.

void setup() {
//Serial.begin(9600); // uncomment for debugging
pinMode(irLED, OUTPUT);
pinMode(SWITCH, INPUT);
pinMode(buzzPin, OUTPUT);
pinMode(powerLED, OUTPUT);
digitalWrite(SWITCH, HIGH); //turn on internal 20 k pullup resistor so the open input state is HIGH.
digitalWrite(buzzPin, LOW);
digitalWrite(powerLED, HIGH);

}

void loop() { //run again and again

if (running == true) // This part of the loop is to test if the camera has been triggered to record
// and blinks the power LED while recording.
{

//Serial.print("running"); //uncomment for debugging
//Serial.println();

unsigned long currentMillis = millis();

if(currentMillis - previousMillis > interval) {
// save the last time you blinked the LED
previousMillis = currentMillis;

// if the LED is off turn it on and vice-versa:
if (ledState == LOW)
{
ledState = HIGH;
}
else
{
ledState = LOW;
}
// set the LED with the ledState of the variable:
digitalWrite(powerLED, ledState);
}
}

if (digitalRead(SWITCH) == LOW) { //read switch input
shoot(video); //start or stop video recording
if (running == false) //detect the state of recording and invert it
{
running = true;
}
else
{
running = !running;
digitalWrite(powerLED, HIGH);
}
piezoBeep(); //beep the buzzer to indicate that recording has started or stopped
delay(500);
}
}

void shoot(unsigned int delayBetweenBursts) { //sends the IR signal

//send first 16 bursts
for(int i=0; i<16; i++) {
digitalWrite(irLED, HIGH);
delayMicroseconds(pulseDuration);
digitalWrite(irLED, LOW);
delayMicroseconds(pulseDuration);
}

delayMicroseconds(delayBetweenBursts);

//send second 16 bursts
for(int i=0; i<16; i++) {
digitalWrite(irLED, HIGH);
delayMicroseconds(pulseDuration);
digitalWrite(irLED, LOW);
delayMicroseconds(pulseDuration);
}
return;
}

void piezoBeep(){ //beeps the piezo buzzer, once for start of recording, twice for end of recording
if (running == true)
{
digitalWrite(buzzPin, HIGH);
delay(250);
digitalWrite(buzzPin, LOW);
}
else
{
digitalWrite(buzzPin, HIGH);
delay(250);
digitalWrite(buzzPin, LOW);
delay(100);
digitalWrite(buzzPin, HIGH);
delay(250);
digitalWrite(buzzPin, LOW);
}
}

Step 5: Use, Conclusion, Improvements

Here is how to set it all up:

1.  Plug the RF remote shutter trigger into the 2.5mm input jack on your project box
2. Power on the RF remote receiver
3. Power on the project box
4. Point the IR LED at the IR Receiver on your camera (mine is on the hand grip right below the shutter release button)
5. Turn your Canon DSLR on, and over to video mode (I would also suggest setting your camera "Auto power off" to longer than 1 minute, especially if it takes you a couple minutes to get into position for your shot)
6. Set your Drive mode to be Remote (either 10 seconds or 2 seconds, it doesn't matter), it has to be in this mode to receive the IR signal.
7.  Shoot away.

Conclusion:

I am very happy with how this project turned out, and I am looking forward to getting a lot of use out of it.  I have been shooting mountain bike and outdoor stuff with my camera, so it's nice to be able to ride in the shot you are taking.


Possible improvements/enhancements to the project:

- Integrate the RF trigger directly into the project so as not to have a separate piece.  Although, the advantage of having it separate is so you can use the RF shutter trigger for its intended purpose if you don't want to shoot video, just stills.
- Make the power LED pin a PWM pin and do a nice smooth fade up and down when blinking the LED (didn't think of this one until I was done)
- Add a photo sensor to detect when the camera enters/exits record mode (it flashes the AF illuminator on the front of the camera when this happens).  This would fail-safe the process a bit, in case your IR LED wasn't triggering the video for some reason.
- Custom PCB for much simpler assembly than on a proto board.
- Smaller piezo buzzer, installed inside the case
- Louder piezo buzzer
- Rechargeable battery
- Sound/Sensor triggering (this is getting slightly out of scope for this project tho)