This post is about an arduino-based intervalometer I built for my camera, a Fuji S9600 dSLR.
I decided to go for a very simple interface: a rotary switch in the middle of a plastic box which would allow me to select 12 pre-defined intervals. I went for a switch and not a potentiometer because I wanted to be certain about the option I select: the reassuring “click” of the rotary switch does exactly that!
Also, I wanted to make the device easy to use, so the labelling of the different options around the rotary switch was very important too.
The Fuji S9600 (a.k.a. Fuji S9100 in the States) has a mini-B USB connector on the side which is used, amongst other things, for a remote shutter release cable. Bob Mahar has “dissected” an original Fuji RR-80 remote release cable and has revealed that the device is actually very simple inside; Bob’s great page on the Fuji RR-80 is here: http://www.trafficshaper.com/RR-80/RR-80.html.
Based on Bob’s page, I came up with the following diagram for the RR-80:
The circuit of the RR80 is simple to build, but I couldn’t find a suitable mini-B USB plug: remember, the camera uses the 5th pin, which is not always available on the plugs you can buy online or at Maplin’s.
http://en.wikipedia.org/wiki/Universal_Serial_Bus
http://en.wikipedia.org/wiki/File:Types-usb_new.svg
After a couple of failed attempts to source a 5-pin USB mini-B connector, I ended up buying a cheap Chinese RR80 clone:
I was actually lucky, because this model has a 2.5″ jack on the side, which allows two cameras to be sync’d (not all the clones have this, I think the JJC clones marked “MA” have it). This meant that I could use a 2.5″ stereo connector in order to connect the arduino with the remote. All the arduino has to do in order to take a photo is to short 2 of the 3 parts of the stereo connector.
I used an old Sparkfun Skinny arduino (it is called “Arduino Pro” now and it’s not red anymore):
This is a 12-pole rotary switch from Maplin and 12 resistors:
I found a simple plastic box at Muji:
First things first: I converted the rotary switch into a “potentiometer”:
In case it’s not clear from the image above, I connected all the pins in the periphery with resistors. The yellow cable coming out from the middle pin of the switch goes to the analog In pin (pin 5 here). The black cable coming out from the 12th pin of the switch goes to the ground and the red cable coming out from the 1st pin of the switch goes to the 3.3V arduino output.
At the opposite side of the arduino board, I used a blue LED on pin 13 (and ground) and on pin 12 I connected a transistor, 2N222A: http://en.wikipedia.org/wiki/File:2n2222A_and_schema.jpg) and the cable (twisted red-black) from the 2.5″ connector.
Here is a better diagram of the wiring of the transistor (to keep things simple, only the transistor is shown here):
For more information on the use of transistors as switches: http://en.wikipedia.org/wiki/Bipolar_junction_transistor
After a few minor tweaks, the prototype was up and running:
The code loaded on the arduino is pretty simple really:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 | /////////////////////////////////////////////////// int swPin = 5; // 12-step switch int ledPin = 13; // Blue & pcb leds int camPin = 12; // Camera pin int sw = 0; // 12-step resistance value int stage = 1; // 12-step stage (i.e. 1 - 12) // this delay is specified by the rotary switch int delaySec; // this is the current second count long currentSec = 0; // this is how long the shutter switch will be on long shutterSec = 100; /////////////////////////////////////////////////// void setup() { // declare the swPin & ledPin as an OUTPUTs pinMode(ledPin, OUTPUT); pinMode(swPin, OUTPUT); // the serial is only used for debugging and for // the calibration of the rotary switch // Serial.begin(9600); } /////////////////////////////////////////////////// // I void loop() { readSwitch(); timeCheck(); // printLine is only used for debugging and for // the calibration of the rotary switch // printLine(); } /////////////////////////////////////////////////// /////////////////////////////////////////////////// void timeCheck(){ if(delaySec<=currentSec){ digitalWrite(ledPin, HIGH); // turn the ledPin on digitalWrite(camPin, HIGH); // turn the camPin on delay(shutterSec); // keep the led and the switch on digitalWrite(ledPin, LOW); // turn the ledPin off digitalWrite(camPin, LOW); // turn the camPin off delay(1000-shutterSec); currentSec = 0; } else{ delay(1000); currentSec = currentSec + 1; } } /////////////////////////////////////////////////// void readSwitch(){ // read the value from the sensor sw = analogRead(swPin); // the serial is only used for debugging and for // the calibration of the rotary switch // Serial.print(sw); if(sw>=0 && sw< 20) { stage = 1; delaySec = 10; } // 10 secs if(sw>=20 && sw< 110) { stage = 2; delaySec = 20; } // 20 secs if(sw>=110 && sw< 200) { stage = 3; delaySec = 30; } // 30 secs if(sw>=200 && sw< 290) { stage = 4; delaySec = 60; } // 1 min if(sw>=290 && sw< 380) { stage = 5; delaySec = 90; } // 1.5 mins if(sw>=380 && sw< 480) { stage = 6; delaySec = 120; } // 2 mins if(sw>=480 && sw< 570) { stage = 7; delaySec = 180; } // 3 mins if(sw>=570 && sw< 660) { stage = 8; delaySec = 300; } // 5 mins if(sw>=660 && sw<750) { stage = 9; delaySec = 600; } // 10 mins if(sw>=750 && sw<850) { stage = 10; delaySec = 900; } // 15 mins if(sw>=850 && sw<950) { stage = 11; delaySec = 1200; } // 20 mins if(sw>=950 && sw<1024) { stage = 12; delaySec = 1800; } // 30 mins } /////////////////////////////////////////////////// void printLine(){ Serial.print(" - Stage: "); Serial.print(stage); Serial.print(" ("); Serial.print(delaySec); Serial.print(") - Next shot in: "); Serial.print(delaySec - currentSec); Serial.println(); } /////////////////////////////////////////////////// |
In order to calibrate the rotary switch, I had enabled the printLine() function (which is commented out in the loop() above and I got the following results on the terminal window (the first number on each line is the pin5 analog in reading):
Now it’s time to put everything in the box. I used my soldering iron to make the necessary holes on the box (I have a tip which I only use to make holes on plastic). Here is everything placed in the box for the first time (to make sure that everything fits the way it should).
The black surfaces you see on bottom of the box are foam boards; you can find them at art supplies shops. The foam boards are easy to cut and shape and, in this case, prevent the battery and the remote control moving around the box.
My next task was to come up with a way of indicating the time interval of each one of the 12 stages of the rotary switch. I didn’t think twice – this was a nice and easy job for processing. I created this image, which I got printed as a 5″ x 7″ in matt paper at photobox.com (10 s = 10 seconds, 1 m = 1 minute):
The Processing code below created the above image:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 | PFont myFont; PFont myFont2; float thisStage; float nextStage; float tp24 = TWO_PI/24; void setup() { size(750, 1070); background(255); smooth(); noStroke(); float adj = -17 * tp24; float space = TWO_PI/120; int diameter = 400; String[] stage = { "10 s", "20 s", "30 s" , "1 m", "1.5 m", "2 m", "3 m", "5 m", "10 m", "15 m", "20 m", "30 m" }; //remember to create the Arial-BoldMT-48 font //otherwise this is not going to work... myFont = createFont("Arial-BoldMT-48", 18,true); myFont2 = createFont("Arial-BoldMT-48", 38,true); for (int i = 0; i < stage.length; i++){ thisStage = (TWO_PI * i /12 - adj); nextStage = (TWO_PI *(i+1)/12 - adj); fill(0,50,100); noStroke(); arc(width/2, 225, diameter, diameter, thisStage, nextStage); fill(255); arc(width/2, 225, diameter, diameter, nextStage - space, nextStage); arc(width/2, 225, diameter, diameter, thisStage, thisStage + space); fill(150); stroke(150); textFont(myFont); textAlign(CENTER,CENTER); text(stage[i],(width/2) + diameter * 0.43 * cos( thisStage + tp24 ), 225 + diameter * 0.43 *sin(thisStage + tp24 )); } //this is the middle white circle fill(255); ellipse(width/2, 225, diameter * 0.6, diameter * 0.6); fill(0,50,100); noStroke(); rect(0,0,150,150); rect(width-150,0,150,150); rect(0,450,width,150); rect(0,height-150,width,150); fill(0); stroke(0); textFont(myFont2); textAlign(CENTER,CENTER); text("Arduino-based Intervalometer \n for Fuji Digital SLRs", width/2,height -150 - (450/2) ); textFont(myFont); textAlign(CENTER,CENTER); text("www.arkadian.eu", width/2,height -200); fill(0,50,100,100); noStroke(); for(int x = 1; x < 30; x++){ rect(int(random(0,width)),int(random(450,height-150)),20,20); } saveFrame("frame.png"); } |
The 7″ x 5″ prints in matt paper (the glossy photo paper would get fingerprints):
I had to make two more holes at the top part of the box to secure the cover.
Here is my intervalometer in its final form.
As you can see from the photo below, the intervals are clearly visible:
That’s it, the end… In the next few weeks I will post a couple of videos put together using frames taken with this brand new intervalometer.
This must be my longest post ever…
