Actually, I’m referring to things dropping and how long it takes for that thing to drop a certain distance. If you use this information along with controlling a camera then you can capture things that are falling in a repeatable fashion. For instance, a drop of water as it just hits a pool of water, or maybe just a little later when the water pool splashes back up after reacting to the water droplet.
The favorite equation used for this dropping behavior is
where “s” is the distance, “a” is the acceleration rate, and “t” is the amount of time. This equation assumes the object starts at rest and t=0. The acceleration “a” can be assumed constant with a value of approximately 
I was able to build a simple setup that allowed me to experiment with Arduino controlling a Laser, a light sensor, and a camera (Canon XSi). The experiment performed the following steps:
1. Turn on a laser and insure that the light sensor detected the laser
2. Drop an object through the laser-sensor beam
3. Upon sensing the laser-sensor beam broken, start a delay
4. Once delay has finished, take a picture
5. Turn off the laser
6. Look at the picture to evaluate object’s dropped distance
7. Repeat with different delay amounts
Ok, simple enough. The problem I had was how to release the object repeatedly from a fixed position and as close to already breaking the laser-sensor beam as possible. The object I chose was as ruler, permitting me to visually see the distance traveled.
My object (ruler) release was simple – a nail that I pulled back that released the ruler. I carefully positioned the ruler to just before breaking the light between the laser and sensor. I then release, recorded what the camera saw and repeated.
I also changed the amount of delay. After I had several interesting data points, I plotted the results. I recorded 6 different results for the same delay, plotting the average/min/max. I also plotted a curve-fitted line to determine the least-square best fit for the modified equation (instead of “t”, I used “(t + y)”, where “y” is the unknown amount of camera delay). From this particular experiment, I determined that “y” is about 106msec, which is for some reason, different from other experiments for the same camera.
Here is an example picture taken:
The arduino code is:
#define shutter_close PORTD |= _BV(2);
#define shutter_open PORTD &= ~_BV(2);
#define focus_on PORTD |= _BV(3);
#define focus_off PORTD &= ~_BV(3);
#define laser_on PORTD |= _BV(4);
#define laser_off PORTD &= ~_BV(4);
#define nolight (PINB & 1) // digital pin #8
#define ledon PORTB |= _BV(1)
#define ledoff PORTB &= ~_BV(1)
void setup() {
pinMode(2, OUTPUT); // camera shutter
pinMode(3, OUTPUT); // focus control
pinMode(4, OUTPUT); // Laser control
pinMode(8, INPUT); // light input
pinMode(9, OUTPUT); // led indicator
shutter_open;
focus_off;
ledoff;
laser_off;
Serial.begin(9600);
}
unsigned long amt = 0; // 0 = no extra delay … just the inherent delay
void get_delay() {
unsigned long delay = 0;
unsigned char len = 0;
while(1) {
while(!Serial.available()); // wait for first character
unsigned char c = Serial.read();
if (c >= ‘0’ && c <= ‘9’) {
delay = (delay * 10) + (c – ‘0’); // add in digit
len++;
} else {
if (len == 0) {
Serial.println(“Have to enter a delay”);
return;
} else {
amt = delay;
Serial.print(“new extra delay of “);
Serial.println(amt);
return;
}
}
}
}
void loop() {
while(1) {
Serial.println(“Command? (D, T, A)”);
while(!Serial.available()); // wait for command
unsigned char c = Serial.read();
switch(c) {
case ‘A’: case ‘a’:
laser_on;
while(!Serial.available()) {
if (nolight) ledon;
else ledoff;
}
Serial.read();
laser_off;
break;
case ‘T’: case ‘t’: {
Serial.print(“Delay is camera + “);
Serial.print(amt);
Serial.println(“ms”);
laser_on;
while(nolight); // wait for laser and sensor together
focus_on;
delay(1000); // pre-focus
while(nolight == 0); // wait for light trigger
// turn off laser
// laser_off;
delay(amt); // time to shutter
shutter_close; // close the shutter
ledon; // flag progresst
delay(200); // delay some amount for the shutter/flash to work
shutter_open; // release shutter
focus_off;
ledoff; // flag progress
laser_off;
} break;
case ‘D’: case ‘d’:
get_delay();
break;
case ‘F’: case ‘f’:
focus_on;
delay(1000);
focus_off;
break;
}
}
}
Also the delay begins at 84msec through 86msec depending upon the position in the camera’s sensor. 
Bill Grundmann's Blog 