DIY Ballistic Chronograph

Description

An ESP8266 based, battery operated, optical ballistic chronograph with LCD interface. Current prototype includes a closed-tube sensor for air gun use. Next generation will be an open design suitable for general range use and will include WiFi interface as well as the built-in display.

Another possible use for this circuit (with slight modification) is a high-speed motion sensing camera trigger.

This project is released under the MIT license (https://opensource.org/licenses/MIT) - Enjoy!

Details

This simple chronograph measures the speed of a projectile by measuring the time it takes the projectile to travel a known distance. This is accomplished with 2 IR emitter/detector pairs. Each pair is configured into a beam-break sensor with the output going to ground when triggered. Each of these circuit outputs is attached to a digital IO pin on the Arduino or ESP8266.

Current software uses the CCOUNT register of the ESP8266 which increments at the full clock speed of 80 MHz. This translates to an impressive precision of 0.0125 fps at 1000 fps! This is much improved over the original Arduino version which used the micros() function and was only precise to 4 microseconds for Arduino. However, it's unlikely that the chrono is accurate to this level of precision. Other errors and 'slop' in the design multiply to limit the accuracy of the measured speed to within a foot per second (or so) of the actual speed. Still pretty impressive for less than $40 worth of hardware. Next update should begin to incorporate a web interface (via the ESP8266 built-in WiFi) and possibly also a camera trigger out for high speed photography.

Components

1 × ESP-07/ESP-12 or Olimex ESP-Dev board ESP8266 dev board with multiple IOs

1 × 16" x 1" ID schedule 40 PVC tubing for the sensor tube

1 × 16" x 1" OD cardboard tube for the inside of the sensor tube

2 × IR Emmiter/Detector pair IR LED and photodiode available commonly online

1 × 16x2 I2C LCD Display

Project Logs

Collapse

Starting on the Mark IV version...
Alpha Charlie • 06/01/2016 at 02:02 • 0 comments

Preliminary source code is up at github - https://github.com/alphacharlie/ESPx-Chronograph
Also - finally Starting on the Mark IV version. I've got the timer code working well on the ESP8266 and have recently received some new BPW-34 photodoides. The Mark IV design is an open trap design. Since we're using the ESP8266 which has wifi, I'm also building a web interface into the chronometer. This will allow display of multiple readings and averaging of readings and settings menu.
The first open-trap design will experiment with translucent plastic sheet to diffuse natural sunlight and with LEDs to illuminate the trap area actively to see which works better as a trigger.
Video Demo of Prototype
Alpha Charlie • 02/13/2016 at 20:57 • 0 comments

Here's short demo of the prototype:
The newest version of this project uses the ESP8266. This gives it an order of magnitude boost in precision over the previous version. (The first prototype used an Arduino at 16MHz. But due to the limitations of the 328P was not able to take full advantage of it. The ESP8266 has a CCOUNT register. This is an unsigned 32 bit int that always has a running tally of the clock cycle count at the full 80MHz of the ESP8266. fps speed is then determined by taking the clock cycle rate and dividing it by the difference between the first and second measured CCOUNT:
fps = 80000000 / ( CCOUNT_2 - CCOUNT_1 )
Since the max value of the CCOUNT register is 4294967291 and it increments at 80 MHz, there is a small (1 in 50000 or so) chance that the CCOUNT register will have reset between the first and second measurement. To handle this we check to see if CCOUNT_2 < CCOUNT_1. If it is we can still get fps by doing -
fps = 80000000 / ( ( 4294967291 - CCOUNT_1) + CCOUNT_2 )
Code will go up on Github in the next day or two. Until then...
Mark II Detector
Alpha Charlie • 02/08/2016 at 23:00 • 0 comments

Shown here is the Mark II detector. It is smaller in diameter, shorter and more sensitive than the first prototype.
This detector is suitable for airgun use and clamps onto the end of the barrel. Each gate circuit has a potentiometer for sensitivity and uses a transistor to amplify the signal from the optical trigger and an SCR to trigger the digital pin(s) of the Arduino.
The length between the first and second optical gate is 12" (1 foot). This makes the FPS calculation exceedingly simple:
FPS = 1000000 / microseconds
To get meters per second we simply multiply our FPS by 0.3048.
MPS = FPS * 0.3048
I should have the source code up on Github in a few days so stay tuned!
Mark I Detector
Alpha Charlie • 02/01/2016 at 20:39 • 0 comments
Above is a picture of the first detector prototype. It used a 3" ID packing tube. The sensor tube consisted of 2 emitter-detector pairs at a fixed distance. Each detector output is amplified by a bipolar transistor and the output is used to trigger an SCR.

The circuit used (schematic above) was one I found on this thread - http://www.electro-tech-online.com/threads/stripboard-layout.31418/ however I hadd to adjust component values to compensate for the supply being 5VDC. I used a 330 ohm resistor instead of 470, a 20K pot instead of 100K and a 3.3K instead of the 10K resistor. (The tube contains two trigger circuits.)
The circuit worked well but triggering was inconsistent due to the sensors having a fairly narrow sensitivity. (perhaps 60 degrees?) The mark II prototype uses a narrower tube and shorter distance between sensors to get more consistent triggering.
If you have problems getting it to trigger-
- use a cell-phone camera to check your emitter. (the camera can see the IR)
- to set the sensitivity reduce the potentiometer resistance until the circuit triggers, then back it off a bit.
- too bright of an emitter will prevent the triggering for small/fast projectiles. So if you have problems, try increasing the value of the current limiting resistor to reduce the emitter brightness.