Archive for Sensor

Photographing Splashing Droplets

Up until now I’ve been using a photogate sensor and the Camera Axe to take pictures of water and milk droplets. After some research I found manypeopleonline were using solenoid valves to create droplets and take pictures of them. The big advantage to this method is it’s easy to collide drops which is was very difficult and random using my old method. I decided I’d make a new valve sensor (pre-built version available here) for the Camera Axe and document how to make your own since I didn’t find any detailed instructions or part lists on the web.

Building It

I knew I wanted to have a way to trigger my camera on a fairly long exposure in a dark room (I use a 1 second exposure). Then make a water droplet. Wait a little while. Make a second water droplet that would collide with the first droplet’s splash. And then wait a little more until the collision before triggering the flash. With this in mind I started making the different pieces I needed and connecting them together.

The only new circuit I needed was a simple motor driver circuit to drive the solenoid. Below is the one I designed and here are the PCB files I designed in Eagle.

Valve Sensor Circuit

Next I had to find and order the parts.

After assembly here is what it looks like:

I also made a new version of the Camera Axe software with the valve sensor. You can download this new version (3.0.03) from

Using it with the Camera Axe

Plug your camera into Camera/Flash1. Plug your flash (or flashes using a splitter cable) into Camera/Flash2. Plug this new valve sensor into Sensor1. Below is a picture of my setup. It has two flashes, a camera, the Camera Axe, and the valve sensor.

Go to the valve sensor menu. Set drop1 size to a good starting size like 80. Set drop2 delay and drop2 size to 0 (we will start with only a single drop). Set Flash delay to around 200 ms. Then turn off the lights and press the “Set” button. This will trigger the camera and the flash. Now adjust the flash delay by 10 ms increments until you have a good droplet picture. Below is a video sequence of 20 images stepping through a milk drop splash. The images go from 220 to 420 ms.

If you want to do colliding drops timing is more complicated. As a starting point I’d suggest a drop1 size of 80, drop2 delay of 40, drop2 size 50, and a flash delay of 200 ms. Then adjust the flash delay until you find the time of collision. Then you can start adjusting other timing parameters to get all sorts of different types of pictures.

You can find lots of photos (including droplet pictures) on the Camera Axe flickr group. Below are a few of my favorites from yesterday.

Comments (10)

Photographing a Speeding Bullet

I’d like to start with a big thanks going to Chris Callander.  When he saw the Camera Axe project he shared his idea for a new sensor with me.  I took his ideas and developed this new projectile sensor and updated the Camera Axe software to support it.  I doubt I would have ever came up with this new sensor idea without Chris.  The ideas that get shared in the open source community are great!  The hardware and software for this project are shared under the Creative Commons Attribution 3.0 License.

You can purchase the Camera Axe and this projectile sensor at this store or built it yourself (parts list below).

This new projectile sensor is designed to help photograph speeding bullets on the Camera Axe platform, but since I used the Arduino development environment, anyone using an Arduino could easily adapt the this hardware and software to their purposes.

This new sensor has two IR sensors spaced exactly two inches apart.  The user inputs the distance from the sensor to the desired position of the projectile when the picture is taken.  Based on the time it takes the projectile to travel those two inches between the sensors, a velocity for the projectile can be determined.  Since bullets and other projectiles basically travel at a constant velocity, it is easy for the microcontroller to calculate the delay in microseconds until the picture is taken.   I ran into a few gotchas in the software while I was writing it.

  • Needed to use digitalRead() with the sensors and not analogRead() (analog read is too slow at 100 us)
  • Used integer math because floating point math is very slow in Arduino
  • Had to be careful with my order of operations or I would overflow 32 bit unsigned integers in certain cases

I’m very pleased with the results.  I’ve tested it with an airgun that travels at a relatively slow 500 ft/sec (half the speed of sound), but my calculations show that the Camera Axe’s 16 MHz ATmega168 chip can easily predict the position of a high speed riffle (several times the speed of sound) to within a fraction of an inch.  I had known that this should work, but it was still amazing to see it working perfectly in the real world, considering all the micro fluctuations that I didn’t account for in the calculations.  In the end, things like gravity, air resistance, and quantum forces just didn’t matter 🙂

[Update: Alan Sailer correctly pointed out the IR transistor I’m using only works at 15us, this would limit photos to around 2x the speed of sound, see the comments for options on faster transistor options.]

Below is a schematic of this new projectile sensor sensor and here are the Eagle files.

If you’re planning to build your own, then this is my parts list

Here is a list of updated files:

  • Updated Camera Axe label.  Nothing special here.
  • Updated Camera Axe source code to support this new sensor.  One nice feature of the projectile code is that I print out the feet/sec or the cm/sec that the bullet was traveling.  While this wasn’t needed for photography; it is still fun to see the numbers.
  • Updated user manual to include the software changes.

Using the Projectile Sensor with the Camera Axe

First, visually line up the IR LEDs to the IR transistors so that they are pointing at each other. Then just plug the 3.5mm cord from Sensor1 on the Camera Axe to Sensor1 on the projection board. Next do the same for sensor2. Plug a flash into Camera/Flash1 on the Camera Axe. Turn on the Camera Axe and go to the sensor menu. (Optional if you want to change from inches to centimeters press [Menu]+[Set]+[Left] while turning on the Camera Axe to enter the special menu to change from English units to Metric units.) In this menu you can set the distance from the sensor to where the projectile should be on the picture (0->999 cm/inch).

You can test your the projectile sensor’s set up by putting your finger in front of the first sensor. After one second a message will display saying that the “second trigger failed”. After this message goes away, put your hand in front of the second sensor and then your other hand in front of the first sensor. This will basically simulate an infinitely fast projectile and the Camera Axe will display the speed of a fast projectile (something more than 45 times the speed of sound).

This sensor should generally be placed at the end of the gun barrel so you don’t need to worry about the bullet hitting the circuit board or sensors.  The bullet/projectile must pass through this sensor before it hits the target.  In my setup I have everything firmly bolted to a table and trigger the gun with a string from a safe distance.

Pretty Pictures

Last but not least, here are a few of the pictures I took with this new sensor.  Taking these pictures was possible with the Camera Axe before I had the projectile sensor using a microphone or a laser sensor, but it involved a lot of trial and error.  With the projectile sensor, every picture is what I was shooting for (pun intended).

First, visually line up the IR LEDs to the IR transistors so that they are pointing at each other. Then just plug the 3.5mm cord from Sensor1 on the Camera Axe to Sensor1 on the projection board. Next do the same for sensor2. Plug a flash into Camera/Flash1 on the Camera Axe. Turn on the Camera Axe and go to the sensor menu. (Optional if you want to change from inches to centimeters press [Menu]+[Set]+[Left] while turning on the Camera Axe to enter the special menu to change from English units to Metric units.) In this menu you can set the distance from the sensor to where the projectile should be on the picture (0->999 cm/inch).

You can test your the projectile sensor’s set up by putting your finger in front of the first sensor. After one second a message will display saying that the “second trigger failed”. After this message goes away, put your hand in front of the second sensor and then your other hand in front of the first sensor. This will basically simulate an infinitely fast projectile and the Camera Axe will display the speed of a fast projectile (something more than 45 times the speed of sound).

Comments (41)

Realtime Graphing of Accelerometer/Gyroscope Data

During my naive days as a university student the only time I graphed data was when some professor required a graph in the lab report. Back in those days I always just looked at the numbers to see what what was happening. It wasn’t until I worked on much more complex real world problems that I admitted graphing the data can help. It’s ironic that as I’ve become a better engineer I’ve realized how important it is to take advantage of every crutch I can fine. These days I graph just about every kind of data I see. Want to know when all the office birthdays are? Let me graph that out for you…

Graphing data lets my mind understand what is happening much faster/better the raw numbers. I know there are some less experienced programmers/engineers that need to learn this. The holy grail for software is real time graphing of the data your application is using. So often people add this sort of feature in at the end, but I think there are benefits to doing it first since it reduces debugging time. At my job we have a whole team dedicated to real time graphing of the data processed by our 3D graphics processors. I am always extra friendly to the people on this team because I fully realize how much easier they make my job. In short I’m a graphing fan boy so it should be no surprise that I wrote some graphing software for my hobby projects. I did this as the first step in a much larger autonomous flying vehicle project that I’m working on.

Since my ultimate goal is a flying vehicle I knew I’d need an inertia measurement unit (IMU). I wanted something with accelerometers to measure acceleration and gyroscopes to measure rotation. After some research I found the ADXL330 is a good accelerometer and the IDG300 is a good gyroscope. I use this Sparkfun 5 degrees of freedom (DOF) device that has both of these chips integrated onto a single small board. These chips measure acceleration along all three axises (x,y,z) and the gryroscopes measures pitch and roll. This means I am missing yaw, but I decided I can add an electronic compass in the future to get this data. I have an Arduino so that is the microcontroller I used.

With all the hardware figured out I already knew that taking this many inputs into a project and expecting it to do what I want was not going to happen on my first try. So to make the debugging less frustrating I decided to graph out all these signals. I will probably add some derived data to these graphs in the future as I get further on this project, but I think it makes sense to share this simple version of the generic graphing software before things get overly complicated.

I used the open source Arduino SDK to compile the code for my microcontroller. Here is the code I wrote for the Arduino. This code reads the sensors and then writes this data onto the serial bus. This software lets you figure out the frequency you want to refresh this data and then will sample the sensors as many times as it can while hitting this refresh frequency. Multisampling helps reduce sensor noise. The reason I didn’t want to send every sensor value over the serial bus is because that it too much data. For my uses I limited the refresh frequency to 100 times per second.

The graphing was done with the open source Processing language. I had never used Processing before, but I found it very easy to use and in a few hundred lines of code got some pretty nice graphing functionality. In a nutshell Processing is a java based language with a bunch of drawing and IO helper functions. Here is the graphing code I wrote for Processing. Besides graphing the data in real time, this software also supports logging all the data to a file and applying a smoothing filter to the data. I wrote this code pretty cleanly so it should be easy to add and remove more data to the graphs.

Here’s a movie of me shaking the sensors in a few different directions and you can see the graphs react accordingly. I’ll let you derive your own conclusions, but it looks like I have a good deal of work ahead of me.

Comments (26)

Camera Axe

I made a new version of Camera AxeHere is my store where I sell them.

Camera Axe is open hardware and open software project that helps you get some of those difficult to capture photographs. It can use various sensors like light triggers and sound triggers to activate a camera or a flash. Here are a few sample images of the things this hardware has captured.

Here is a gallery with more pretty pictures. I apologize that some of them are a little blurry. I dropped and damaged my flash about a week ago and don’t have the funds to buy a new one right now. The flash now does a few micro pre-flash outputs before the full flash is triggered. This is is why some of the images have a weaker ghost images in them causing a blurry appearance. (UPDATE: Here is are some new photos I shot once I got my flash repaired. And here are some more.)

These are just a few images I’ve used to test this software/hardware. The possible uses range from taking pictures of wildlife while you’re not there to photographing a bullet piercing an apple. The fact that everything is open source offers advantages over solutions that are being sold today (beyond the cheaper price). As an example lets say you want to take pictures of wildlife at sunrise/sunset. You could modify the software so the light sensor only actives the camera at light levels that represent sunrise/sunset and then you could use the microphone to actually detect animal movement. Since the hardware is easily understood you can add new sensors as needed, one sensor I’ve thought about making is piezo pressure sensor.

Camera Axe Component List

Here is a list of the components you need to make Camera Axe.

Break Away Headers $2.50
Mini Push Button Switch $0.35
Serial Enabled 16×2 LCD $24.95
16 MHZ Crystal $1.50
ATmega328 with Arduino Bootloader $5.50
DIP Sockets Solder Tail – 28-Pin 0.3″ $1.50
5V Voltage Regulator $1.25
Optoisolator with Darlington Driver – 1 Channel $1.25
0.1 uF Capacitor (4) $1.00
22 pF Capacitor (2) $0.50
10 uF Capacitor (3) $1.35
RF Link 2400bps Receiver – 315MHz $4.95
3-Pin Screw Terminals 3.5mm Pitch (2) $3.00
Super Bright LED – Green (4) $3.80
DIP Sockets Solder Tail – 8-Pin $1.50
Diode Rectifier – 1A 50V (2) $0.30
Custom Circuit Board PCB $21.43
NPN Transistor (2) $0.54
Plastic Enclosure $7.62
3.5 mm Audio Jack (4) $1.40
Push Button Switch (6) $7.80
1M Ohm Potentiometer $0.90
Op Amp $0.33
9V Battery Holder $1.05
1/4 Watt Resistors * 47 (1) * 220 (4) * 1K (1) * 10K (14) * 100K (1) $2.52
McMasters Carr
#2 Spacer – 3/16″ OD, 3/16″ LENGTH (4) $1.04
#4 Spacer – 3/16″ OD, 5/16″ Length (4) $1.16
Undersized 4-40 Nut (4) $3.28
Undersized 2/56 Nut (4) $5.23
2-56 Bolt – 5/8″ Length (4) $4.64
4-40 Bolt – 3/4″ Length (4) $5.09
Total Cost $119.23

Getting the bill of material cost significantly under $70 should be pretty easy if anyone want to make 10’s of these. Many of the parts above start significant volume discounts at pretty low quantities. Also some of the hardware from McMasters I only needed 4 of something but I had to buy a pack of 100 so building multiple (or finding a supplier where you could buy 4) would decrease the price by about $15. You could reduce the cost the the PCB from $21.43 to about $6.50 if you ordered them in quantities of 17 from BatchPCB’s supplier Gold PhoenixPCB (I’d really suggest using BatchPCB until you know what you’re doing). Lastly, redesigning the board to use surface mounted parts would lead to large cost savings.

Camera Axe Hardware

I designed this circuit and PCB board in Eagle. Eagle is a powerful circuit and PCB design tool. You can get a free version for non-commercial use. This is the first PCB I ever designed and must say that Eagle combined with these four great Sparkfun tutorials (1, 2, 3, 4) really got me up to speed. I then sent my design to BatchPCB. It took a little over a month to get my test board back, but it worked great. Here are my eagle files for this project and the Girber files I sent to BatchPCB. If you install the free version of Eagle you can look at and modify my schematic and board layout. Below is a picture of this boards schematic for those who don’t want to install Eagle to look at it.

Being my first board I made a few mistakes with the PCB that I’ll correct if I ever print more boards. Luckily all my mistakes were minor and the board I printed works fine.

  • Rename “Light” to “Sensor” on the silkscreen since that is a better description.
  • One of the bolt holes is one grid point off center so I should make sure all the bolt holds are centered.
  • I should label the value of the Potentiometer on the silkscreen (1M ohm).
  • The silkscreen for the RF receiver is missing +5 for one of it’s pins.
  • The LEDs are too bright and the 220 ohm resistors should be replaced with something larger.
  • The schematic is correct, but the parts I used for the focus and shutter are ECB transistors.  These have an odd pin layout for transistors (1=emitter, 2=collector, 3=base).  Switch these to a normal transistor (1=collector, 2=base, 3=emitter).

After I got the PCB back, it was just a matter of soldering all the components in place. If others want to build this and want more detailed directions on soldering the circuit board components into place, I may be willing to write an instruction guide to assist in this.


To make the enclosure I designed the holds I needed to drill and the few places I needed to cut with my Dremel in Inkscape. Then I just printed that out onto some sticky paper and had the pattern I needed to cut out on the box. This worked out pretty slick. Here is the cutout pattern I designed (drill/cut template, final sticker template).


I used an ATMega328 with the Arduino bootloader for my microcontroller. This means I could use the very popular and easy to use open source Arduino development environment. I used version 0014, but newer versions are usually backwards compatible with older ones. You can download the Arduino development software here.

In order to download software to this board you will need this programming dongle.

Here is the software I wrote for this project. I’ve created this video that demonstrates some of the features of this software.

Flash Trigger

Female Hotshoe (Cheaper ones available, but this one has is good quality) $16.50
3.5 mm Extension Cord $5.24
External Flash (I assume you already have one)
Total Cost $21.74

This allows you to plug the flash into Camera Axe. While Camera Axe can trigger your camera directly, if you need an instantaneous capture you should use the flash. This page gives the expected shutter lag for many cameras. The flash reacts to it’s triggering in well under a millisecond.

Notice: Camera Axe assumes you have an EOS compatible flash. Some older flashes use high voltages to trigger them. If you use one of these high voltage flash units you will likely blow Camera Axe’s optoisolater and need to replace it. I use a Canon 580EX flash, but there are many other options. Here is a list of flashes that should be safe.

Camera Trigger

Plug to trigger your camera (Price varies by plug (see below) under $5.00
Audio cord with 3.5 mm plug $3.15
Total Cost $8.15

The higher end Canon DSLR cameras (20D, 30D, 40D, 50D, 5D, 1D) have a a special Canon Plug called N3. I have not been able to find this plug for sale anywhere, but you can buy a cheap Chinese trigger for these cameras on Ebay for under $5 and use the N3 plug from it. I have a 30D so this is what I demonstrate here. Canon’s lower end cameras (300D, 500D, 1000D) use the much cheaper and easier to get 2.5 mm jack. I’m not sure what Nikon use, but I’m sure a little research will figure that out.

Sound Sensor

Electret Microphone $0.95
Audio cord with 3.5 mm plug $3.15
Total Cost $4.10

Electret microphones like this need some serious amplification. Luckily I put all that amplification on Camera Axe’s PCB. You can adjust the sensitivity of the microphone with the potentiometer on Camera Axe’s PCB. Just play with it until you find a sensitivity you like.

Light Sensor

Photo Transistor $0.42
Audio cord with 3.5 mm plug $3.15
Total Cost $3.57

Most photo transistors filter out visible light and only trigger on IR light. I did some searching and found this one that triggers on visible and IR light. This is nice because one of the uses I had for this was to use it in conjunction with a cheap $5 laser pointer (search Google or Amazon) to create a laser trigger. All you do is point the laser at this and when the beam is broken you trigger the camera or flash.

Another good use of the this sensor is taking pictures of lightning. It will make getting night time lightning less work and you can even get daytime lightning which is something human reflexes can’t manage.

Remote Control

RF Link Transmitter – 315MHz $3.95
Other parts ???
Total Cost ???

I put a receiver in Camera Axe so I could trigger it remotely. The transmitter I put in along with this receiver should have a range of about 200 ft, but I have not verified this distance yet. I did verify the remote works at closer ranges by putting together a breadboard circuit to verify it. The circuit is extremely simple since this device just needs power, ground, and a serial transmit wire to send the it the signal. Maybe I’ll make a nice remote someday, but until then you’ll need to design your own if you need this feature. Here is the Arduino software I used to test this feature.

Comments (76)

An I2C Bus Example Using the DS1307 Real-Time Clock

A more complete description of I2C can be read here on Wikipedia, but I will give you the four sentence summary here. I2C is a serial data bus protocol that allows multiple devices to connect to each other with fairly slow data transfer rates. These slow data transfer rates are fast enough for many devices and allow the bus to be very simple to implement. The real beauty of this protocol is that you can control up to 112 devices with just two wires from a microcontroller. Many microcontrollers have a libraries to support I2C; on Arduino the official Wire library handles the details for you.

In this example I use an Arduino board as the bus master and have just one slave device on the I2C bus, a DS1307. You can read the DS1307 data sheet here. As I mentioned before Arduino has a library called Wire that handles all the details of the I2C protocol. Wire uses analog pin 4 for the Serial Data (SDA) connection and analog pin 5 for the Serial Clock (SCL) connection. The I2C protocol defines the bus as an open drain bus, which means you need to use pull-up resistors on each of the two bus wires. Here is the circuit of how I wired the DS1307 to Arduino using a I2C bus.

Here is the code I wrote. There are a lot of other places on the web that have code for using the DS1307, but I couldn’t find a simple and efficient one that just did what I needed. This code has two main functions for accessing the DS1307. One sets the time and date, and the other gets the time and date. The DS1307 returns it’s numbers coded in binary-coded decimal (BCD). This code also converts the numbers returned from the DS1307 out of BCD for you. If all you want to do is display the time BCD is probably better, but most of the time I won’t be just displaying the time. Instead I’ll be using it to decide when to run events and for this it’s better to work with normal numbers.

// Maurice Ribble 
// 4-17-2008

// This code tests the DS1307 Real Time clock on the Arduino board.
// The ds1307 works in binary coded decimal or BCD.  You can look up
// bcd in google if you aren't familior with it.  There can output
// a square wave, but I don't expose that in this code.  See the
// ds1307 for it's full capabilities.

#include "Wire.h"
#define DS1307_I2C_ADDRESS 0x68

// Convert normal decimal numbers to binary coded decimal
byte decToBcd(byte val)
  return ( (val/10*16) + (val%10) );

// Convert binary coded decimal to normal decimal numbers
byte bcdToDec(byte val)
  return ( (val/16*10) + (val%16) );

// Stops the DS1307, but it has the side effect of setting seconds to 0
// Probably only want to use this for testing
/*void stopDs1307()

// 1) Sets the date and time on the ds1307
// 2) Starts the clock
// 3) Sets hour mode to 24 hour clock
// Assumes you're passing in valid numbers
void setDateDs1307(byte second,        // 0-59
                   byte minute,        // 0-59
                   byte hour,          // 1-23
                   byte dayOfWeek,     // 1-7
                   byte dayOfMonth,    // 1-28/29/30/31
                   byte month,         // 1-12
                   byte year)          // 0-99
   Wire.send(decToBcd(second));    // 0 to bit 7 starts the clock
   Wire.send(decToBcd(hour));      // If you want 12 hour am/pm you need to set
                                   // bit 6 (also need to change readDateDs1307)

// Gets the date and time from the ds1307
void getDateDs1307(byte *second,
          byte *minute,
          byte *hour,
          byte *dayOfWeek,
          byte *dayOfMonth,
          byte *month,
          byte *year)
  // Reset the register pointer
  Wire.requestFrom(DS1307_I2C_ADDRESS, 7);

  // A few of these need masks because certain bits are control bits
  *second     = bcdToDec(Wire.receive() & 0x7f);
  *minute     = bcdToDec(Wire.receive());
  *hour       = bcdToDec(Wire.receive() & 0x3f);  // Need to change this if 12 hour am/pm
  *dayOfWeek  = bcdToDec(Wire.receive());
  *dayOfMonth = bcdToDec(Wire.receive());
  *month      = bcdToDec(Wire.receive());
  *year       = bcdToDec(Wire.receive());

void setup()
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
  // Change these values to what you want to set your clock to.
  // You probably only want to set your clock once and then remove
  // the setDateDs1307 call.
  second = 45;
  minute = 3;
  hour = 7;
  dayOfWeek = 5;
  dayOfMonth = 17;
  month = 4;
  year = 8;
  setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year);

void loop()
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;

  getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
  Serial.print(hour, DEC);
  Serial.print(minute, DEC);
  Serial.print(second, DEC);
  Serial.print("  ");
  Serial.print(month, DEC);
  Serial.print(dayOfMonth, DEC);
  Serial.print(year, DEC);
  Serial.print("  Day_of_week:");
  Serial.println(dayOfWeek, DEC);


UPDATE 5-20-2008
Updated the code to fix a few bugs Fabien pointed out. He also informed me of this: “Because you’re hooking up the clock to analog pins 4 & 5 on the Arduino and using the Wire lib, you don’t need to bother with pull-up resistors in your schematics. Turns out that the Arduino has built-in pull-up resistors for these pins. The Two Wire library enables the built-in pull-ups in the twi_init() function in twi.c (located here: \arduino-0011\hardware\libraries\Wire\utility).”

Thanks Fabien!

Comments (77)

« Previous Page« Previous entries « Previous Page · Next Page » Next entries »Next Page »