Before finalizing a design, I think it would be worthwhile to determine just how fast the blades can open and close. I wouldn't expect a very fast speed. These blades are large and comparatively heavy.
Before finalizing a design, I think it would be worthwhile to determine just how fast the blades can open and close. I wouldn't expect a very fast speed. These blades are large and comparatively heavy.
Why? The shutter is going to open as fast as it can open and a microcontroller based design should not be different if the top speed is 1/5 second or 1/500.Originally Posted by Ernest Purdum
The microcontroller needs to do the following:
detect a button press or other signal
read the desired shutter speed (need some way to set this)
trigger the open solenoid (this is easily done by sending power to a transistor - the transistor switches on the power to the solenoid)
at the same time switch the hold solenoid (same basic thing, but another transistor)
Then it can shut off the open solenoid
Wait the allotted time
Shut the hold solenoid.
The software for triggering the shutter is really easy. The hardest part is deciding how you are going to enter the desired shutter speed (buttons, knob, pre-set, read a light meter...)
I know there are some examples of using arduino as a camera trigger, and I'd imagine they could be easily extended to include the open solenoid pulse.
Shouldn't be a problem to hack a one-button interface. This is what I came up with just now; only took me 2 LPs.
/**************
shutter
**************
/*A program to drive a solenoid-controlled photographic shutter.
2010 chaz miller, this software is licensed under the gnu gplv3
see http://www.gnu.org/licenses/gpl.html for details
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR
IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE.
*/
/*
hook the shutter relay/solenoid up to pin 12, which will go high when the shutter is intended to be open,
and will be grounded otherwise. Hook trigger switch to pin 2 (I think) so as to ground the pin
when the switch is closed. To choose a shutter speed, turn on the microcontroller while holding
the button/trigger closed. The LED will blink 5 times. Press the button N times, where 2^-N is the
desired speed (ex. press 1 time for 1/2s, 2 times for 1/4s, 5 times for 1/32s, 9 times for 1/512s).
The LED will blink 3 times. The speed will be stored in memory until updated. Speeds over 9 (1/512s)
will act as "Bulb"/*/
#include "EEPROM.h"
#define outpin 12 //hook solenoid/relay to pin 12
#define button 0 //hook button to pin 2
#define fudge 0 //amount of time in ms tacked onto shutter speeds to account for opening/closing
long fired; //increments when user presses fire button
int spd; //the desired shutter speed as 2^-spd seconds
void setup(){
for (int i=0; i<14; i++){
pinMode(i, OUTPUT); //set all pins to output
}
digitalWrite(2, HIGH); //interrupt pin
delay(20);
if(!digitalRead(2)){
spd=buttonChooser(2,0,2000);
EEPROM.write(spd, 255);
}
else{spd=EEPROM.read(255);}
attachInterrupt(button, fire, FALLING);//create interrupt for trigger button, on pin 2 I think
} //end setup
void loop(){
if (spd>9){
if(fired){
digitalWrite(outpin, HIGH);
delay(10);
while(digitalRead(button)==0){
delay(10);}
digitalWrite(outpin, LOW);
delay(100);
fired=0;
}
}
else{
if(fired){
digitalWrite(outpin, HIGH);
delay((2^(-(spd))*1000)+fudge);
digitalWrite(outpin, LOW);
delay(100);
fired=0;
}
}
} //end loop
void fire(){ //will increment when you press the fire button
fired++;
}// end fire
/*
******************
buttonChooser(customized )
******************
Watch a button and return how many times it is pressed. Useful for
program input. Will wait for
additional button presses only if it has been less than timeOut milliseconds
since the last button press, or in case no buttons have been pressed, since the
function is called. Watches for low pulses by default.
*/
int buttonChooser(int pin, boolean state, int timeOut){
int presses = 0;
long t0, t1;
t1=t0=millis();
for(int i=0; i<6; i++){ //blink 5 timees
digitalWrite(13,HIGH);
delay(300);
digitalWrite(13,LOW);
delay(100);
}
while(millis()<t0+30000){ //emergency timeout loop....could be set to 1
while(!state==digitalRead(pin)){
if (millis()>t1+timeOut){ //this loop waits for button to change state, returns if it's not pressed
for(int i=0; i<4; i++){ //blink 3 timees
digitalWrite(13,HIGH);
delay(100);
digitalWrite(13,LOW);
delay(50);
}
return presses;
}
delay(5); //we are mostly waiting around for the button press here
}
//hurray button pressed
presses++; //count a press
while(state==digitalRead(pin)){
delay(5); //stall while button is held down
}
delay(5);
t1=millis(); //reset the countdown to zero for the next press
}
return presses; //only happens when explodage of the emergency timeout
} //end buttonChooser
Science is what we understand well enough to explain to a computer. Art is everything else we do.
--A=B by Petkovšek et. al.
I'd make the led flash for the amount of time selected. So you have some visual indicator of the speed.
Jack Dahlgren, "Why" is to avoid a design which promises a faster speed than can actually be delivered.
Ernest, you are completely right.
Some years ago I bought an oscilloscope camera that had a #3 Ilex electronic shutter and a built in shutter controller. Its marked high shutter speed is 1/125. This was part of its appeal. Stand-alone Ilex shutter speed controllers' highest marked speed is 1/60.
The wretched thing's top speed is nowhere near 1/125. All of its speeds, including 4 sec., run much slower than indicated.
By the way, the shutter has just one solenoid. It opens the leaves and holds them open. A spring closes them.
A single line of code in that routine will limit the speed to the fastest tested speed. For example the value of spd goes from 0 to 9. If you determined that 7 was the fastest possible speed you could add a line:
spd = min(spd,7)
then plug the device into your USB port, click a button and you are done.
The beauty of a microcontroller here is that you can have the speed be anything from the max tested speed up to a day - given you have a power supply to hold the shutter open. If that shutter can open and close in 1/1000 or 1/10 you are still using the same circuit and same design. You just change the variable.
And if you need to adjust the speed to compensate for it opening more quickly than it closes you can subtract a few milliseconds here and there either as an absolute number or as a percentage or the square root or whatever you can dream up.
Adding a photodetector onto it and a few more wires and lines of code, you could even have the thing self-calibrate itself. Trigger the shutter, start a timer when the light first hits the detector, release the shutter, measure when the light stops, compare the two intervals and adjust.
Posting Permissions
Reply With Quote
Bookmarks