various firmware changes. fix measurement. add uv led support. small values with decimal places. fix graph. set prescaler.

README.md

 # OpenChrono
 
 Chronograph for Airsoft use, released as Free Open Source hardware and software!
-Uses a 3D printed housing to hold an Arduino, an OLED, batteries and two photosensitive light barriers.
+
+Uses a 3D printed housing to hold an Arduino, an OLED display, batteries and two photosensitive IR light barriers.
+
+Fixed mounting on the front of the gun in the style of a silencer.
+
+Can optionally also include UV LEDs to illuminate tracer BBs.
 
 ## Hardware
 
-Take the STL files from the 'hardware' directory or modify the included OpenSCAD design and create your own custom STLs.
+Use the included OpenSCAD design file in `hardware/openchrono.scad` to render your own custom STLs that fit your use-case.
 
 ### Required Parts
 
-| Description        | Type          | Count  |
-| ------------------ | ------------- | ------ |
-| Arduino Nano       |               | 1x     |
-| LCD 128x64 I2C     | SSD1306 0.96" | 1x     |
-| Slide Switch       |               | 1x     |
-| IR Phototransistor | SFH 309 FA-5  | 2x     |
-| IR LED 3mm         |               | 2x     |
-| Resistor           | **TODO**      | 2x     |
-| Resistor           | **TODO**      | 1x     |
-| Screw              | M2 10mm       | 4x     |
-| Screw              | M2.5 10mm     | 2x     |
-| Screw              | M3 10mm       | 4x     |
-| Heatmelt Insert    | M3 8mm        | 4x     |
-| AAA Battery        |               | 3x     |
-| Bat. Terminal Neg. |               | 3x     |
-| Bat. Terminal Pos. |               | 3x     |
+Besides some common stuff like soldering wire and hotglue you need the following parts to build this project.
+
+| Description        | Type          | Count |
+| ------------------ | ------------- | ----- |
+| Arduino Nano       |               | 1x    |
+| LCD 128x64 I2C     | SSD1306 0.96" | 1x    |
+| Slide Switch       |               | 1x    |
+| IR Phototransistor | SFH 309 FA-5  | 2x    |
+| IR LED 3mm         |               | 2x    |
+| Resistor           | 1k Ohm        | 2x    |
+| Resistor           | 100 Ohm       | 1x    |
+| Screw              | M2 10mm       | 4x    |
+| Screw              | M2.5 10mm     | 2x    |
+| Screw              | M3 16mm       | 8x    |
+| Heatmelt Insert    | M3 <= 10mm    | 8x    |
+
+For the UV tracer option you also need the following parts.
+
+| Description | Type    | Count |
+| ----------- | ------- | ----- |
+| UV LED 3mm  |         | 2x    |
+| Resistor    | 100 Ohm | 1x    |
+
+You have different options for powering the project.
+My first version for testing uses a pre-made AA battery holder.
+
+| Description    | Type   | Count |
+| -------------- | ------ | ----- |
+| AA Battery     |        | 3x    |
+| AA Bat. Holder |        | 1x    |
+| Screw (sunk)   | M3 6mm | 2x    |
+
+The originally intended variant is a AAA battery holder printed into the model.
+I don't have the terminals for that yet so it is not finished.
+
+| Description        | Type | Count |
+| ------------------ | ---- | ----- |
+| AAA Battery        |      | 3x    |
+| Bat. Terminal Neg. |      | 3x    |
+| Bat. Terminal Pos. |      | 3x    |
+
+I'm also looking to design a LiPo version with charger included in the future.
 
 ## Software
 
 This project uses the [U8g2 library by olikraus](https://github.com/olikraus/u8g2) to draw to the I2C OLED display.
 
 You can compile and flash the software using either PlatformIO or the standard Arduino IDE.
-In the latter case, install the U8g2 library using the Arduino IDE Library Manager and then flash as usual.
+
+With the Arduino IDE [install the U8g2 library using the Library Manager](https://github.com/olikraus/u8g2/wiki/u8g2install) and then flash as usual.
+
+For PlatformIO run something like the following command.
+
+    pio run -t upload --upload-port /dev/ttyUSB0
+
+Replace `/dev/ttyUSB0` with the port you are using.
+
+### Configuration
+
+Take a look at `firmware/OpenChrono/config.h`.
+This file contains all the settings you can change as a user.
+
+The most important setting is `SENSOR_DISTANCE`, which is given from the 3D model of the case.
+It is echoed when rendering the OpenSCAD design.
+
+You can set `BB_WEIGHT` to the one you use most commonly, and `BB_WEIGHTS` to others interesting for you (`BB_WEIGHTS` should include `BB_WEIGHT`).
+These values are used to calculate the energy in Joules.
+
+Set `PREFERRED_UNITS` to what you would like to see in the 2D graph.
+
+The range of speeds that can be measured is determined by `TIMER_PRESCALER`.
+Take a look at the comment in `firmware/OpenChrono/ticks.cpp` for details.

firmware/OpenChrono/OpenChrono.ino

         ticks = b - a;
     } else {
         // the timer overflowed between measurements!
-        uint32_t tmp = ((uint32_t)b) - ((uint32_t)a);
+        int32_t tmp = ((int32_t)b) - ((int32_t)a);
         tmp += 0x10000;
         ticks = (uint16_t)tmp;
     }
 }
 
 void setup() {
+    // we simply turn on the IR LEDs all the time
     pinMode(IR_LED_PIN, OUTPUT);
     digitalWrite(IR_LED_PIN, HIGH);
 
+    // but the UV LEDs will only be pulsed on firing!
+    pinMode(UV_LED_PIN, OUTPUT);
+    digitalWrite(UV_LED_PIN, LOW);
+
     lcd_init();
     delay(SCREEN_TIMEOUT); // show splash screen
 
 }
 
 void loop() {
-    if ((time_a == 1) && (time_b == 1)) {
-        // we got an event on both inputs
-        measure();
+    if (trigger_b) {
+        if (trigger_a) {
+            // we got an event on both inputs
+            measure();
+        } else {
+            // we got a false second trigger!
+            // clear so next calculation will be correct
+            trigger_b = 0;
+        }
     }
 
     lcd_loop();

firmware/OpenChrono/config.h

 
 // --------------------------------------
 
-// hardware details
-
 #define SENSOR_DISTANCE 70.0 /* in mm */
+
 #define BB_WEIGHT 0.25 /* in g */
 #define BB_WEIGHTS { 0.20, 0.23, 0.25, 0.28, 0.475 } /* in g */
 
 // --------------------------------------
 
 #define IR_LED_PIN 4
+#define UV_LED_PIN 5
+
+// --------------------------------------
+
+// allowed values: 1, 8, 64, 256, 1024
+#define TIMER_PRESCALER 64
 
 // --------------------------------------
 

firmware/OpenChrono/lcd.cpp

 
         uint8_t left_off = (u8g2.getDisplayHeight() - (u8g2.getMaxCharHeight() * 4 + 3)) / 2;
 
-        s = String(metric, 0);
+        if (metric < 10.0) {
+            s = String(metric, 1);
+        } else {
+            s = String(metric, 0);
+        }
         s += F(" m/s");
         uint8_t l1 = u8g2.getStrWidth(s.c_str());
         u8g2.drawStr(
             s.c_str()
         );
 
-        s = String(imperial, 0);
+        if (imperial < 10.0) {
+            s = String(imperial, 1);
+        } else {
+            s = String(imperial, 0);
+        }
         s += F(" FPS");
         uint8_t l2 = u8g2.getStrWidth(s.c_str());
         u8g2.drawStr(
         // max text
         double max_metric = tick_to_metric(max);
         if (PREFERRED_UNITS == METRIC) {
-            s = String(max_metric, 0);
+            if (max_metric < 10.0) {
+                s = String(max_metric, 1);
+            } else {
+                s = String(max_metric, 0);
+            }
         } else if (PREFERRED_UNITS == IMPERIAL) {
-            s = String(metric_to_imperial(max_metric), 0);
+            double max_imperial = metric_to_imperial(max_metric);
+            if (max_imperial < 10.0) {
+                s = String(max_imperial, 1);
+            } else {
+                s = String(max_imperial, 0);
+            }
         } else {
             s = String(metric_to_joules(max_metric, BB_WEIGHT), 2);
         }
         // min text
         double min_metric = tick_to_metric(min);
         if (PREFERRED_UNITS == METRIC) {
-            s = String(min_metric, 0);
+            if (min_metric < 10.0) {
+                s = String(min_metric, 1);
+            } else {
+                s = String(min_metric, 0);
+            }
         } else if (PREFERRED_UNITS == IMPERIAL) {
-            s = String(metric_to_imperial(min_metric), 0);
+            double min_imperial = metric_to_imperial(min_metric);
+            if (min_imperial < 10.0) {
+                s = String(min_imperial, 1);
+            } else {
+                s = String(min_imperial, 0);
+            }
         } else {
             s = String(metric_to_joules(min_metric, BB_WEIGHT), 2);
         }
         for (int i = 0; i < tick_count - 1; i++) {
             u8g2.drawLine(
                 graph_start + (i * segment_w),
-                map(tick_history[i], min, max, 0, u8g2.getDisplayHeight() - 1),
+                map(tick_history[i], min, max, u8g2.getDisplayHeight() - 1, 0),
                 graph_start + ((i + 1) * segment_w),
-                map(tick_history[i + 1], min, max, 0, u8g2.getDisplayHeight() - 1)
+                map(tick_history[i + 1], min, max, u8g2.getDisplayHeight() - 1, 0)
             );
         }
 

firmware/OpenChrono/ticks.cpp

  * speed = SENSOR_DISTANCE / (65535 * 1000 / F_CPU)
  * so we can measure from 17m/s (61km/h, approx. 0.03J @ 0.2g)
  * up to ridulous 1120000m/s (4032000km/h)
+ *
+ * with a prescaler of 8, we can measure from 2.14m/s to 140000m/s
+ * with a prescaler of 64, we can measure from 0.27m/s to 17500m/s
  */
 
 #include <Arduino.h>
 
 double tick_to_metric(uint16_t ticks) {
     // v = d / t
-    double period = 1000.0 / ((double)(F_CPU));
+    double period = 1000.0 / ((double)(F_CPU / TIMER_PRESCALER));
     double time = period * (double)ticks;
     double speed = (double)SENSOR_DISTANCE / time;
     return speed;

firmware/OpenChrono/timing.cpp

  * Copyright (c) 2022 Thomas Buck <thomas@xythobuz.de>
  *
  * Two phototransistors connected to external interrupts 0 and 1.
+ * Timer1 (16bit) used to count time between triggers.
+ * Timer2 (8bit) used for timing UV LED pulse.
  */
 
 #include <Arduino.h>
     EIMSK = (1 << INT0) | (1 << INT1);
 }
 
+/*
+ * this is supposed to be the "input" sensor,
+ * the one that triggers first on firing.
+ */
 ISR(INT0_vect) {
     time_a = timer_get();
     trigger_a = 1;
 }
 
+/*
+ * this is supposed to be the "output" sensor,
+ * the one that triggers after the other sensor.
+ */
 ISR(INT1_vect) {
     time_b = timer_get();
     trigger_b = 1;
+
+    // we now need to turn on the UV led
+    // and make sure it will only be on shortly!
+    timer_start();
+    digitalWrite(UV_LED_PIN, HIGH);
 }
 
 // --------------------------------------
 
-void timer_init() {
-    // normal mode, prescaler 1
+static void timer1_init() {
+    // normal mode
     TCCR1A = 0;
+
+    // prescaler
+#if TIMER_PRESCALER == 1
     TCCR1B = (1 << CS10);
+#elif TIMER_PRESCALER == 8
+    TCCR1B = (1 << CS11);
+#elif TIMER_PRESCALER == 64
+    TCCR1B = (1 << CS11) | (1 << CS10);
+#elif TIMER_PRESCALER == 256
+    TCCR1B = (1 << CS12);
+#elif TIMER_PRESCALER == 1024
+    TCCR1B = (1 << CS12) | (1 << CS10);
+#else
+#error Invalid Prescaler for Timer1
+#endif
+}
+
+static void timer2_init() {
+    // normal mode, no clock source
+    TCCR2A = 0;
+    TCCR2B = 0;
+
+    // enable overflow interrupt
+    TIMSK2 = (1 << TOIE2);
+}
+
+void timer_init() {
+    timer1_init();
+    timer2_init();
 }
 
 uint16_t timer_get() {
     return TCNT1;
 }
+
+void timer_start() {
+    /*
+     * the distance between the second IR sensor
+     * and the UV LEDs is 7.5mm.
+     * Our bullet will travel with a speed of
+     * ~10m/s up to ~300m/s approximately.
+     * So it will move the 7.5mm in
+     * 750us to 25us respectively.
+     * So it makes sense to keep the UV LED
+     * on for 1ms.
+     *
+     * We reach exactly 1ms when counting to 250
+     * with a prescaler of 64 at 16MHz.
+     *
+     * If you __really__ want to increase the brightness
+     * of the tracer, reduce the pulse length here.
+     * Then you can also reduce the UV LED resistor for
+     * higher currents, according to the datasheet of
+     * your UV LED.
+     */
+    const static uint8_t pulse_length = 250;
+
+    // initial value we count up from
+    TCNT2 = 0xFF - pulse_length;
+
+    // prescaler 64
+    TCCR2B = (1 << CS22);
+}
+
+ISR(TIMER2_OVF_vect) {
+    // turn off UV LED
+    digitalWrite(UV_LED_PIN, LOW);
+
+    // and also stop timer
+    TCCR2B = 0;
+}

firmware/OpenChrono/timing.h

 void timer_init();
 uint16_t timer_get();
 
+void timer_start();
+
 #endif // __TIMING_H__