Initial commit

.gitignore

@@ -0,0 +1 @@
+firmware/.pio

README.md

@@ -0,0 +1,19 @@
+# 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.
+
+## Hardware
+
+Take the STL files from the 'hardware' directory or modify the included OpenSCAD design and create your own custom STLs.
+
+Required Materials:
+
+TODO
+
+## 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.

firmware/.gitignore

@@ -0,0 +1 @@
+.pio

firmware/OpenChrono/OpenChrono.ino

@@ -0,0 +1,62 @@
+/*
+ * OpenChrono.ino
+ *
+ * OpenChrono BB speed measurement device.
+ *
+ * Copyright (c) 2022 Thomas Buck <thomas@xythobuz.de>
+ *
+ * The goal is to measure the speed of a BB moving through the device.
+ */
+
+#include "timing.h"
+#include "ticks.h"
+#include "lcd.h"
+#include "config.h"
+
+static void calculate(uint16_t a, uint16_t b) {
+    uint16_t ticks = 0;
+
+    if (b >= a) {
+        // simple case - just return difference
+        ticks = b - a;
+    } else {
+        // the timer overflowed between measurements!
+        uint32_t tmp = ((uint32_t)b) - ((uint32_t)a);
+        tmp += 0x10000;
+        ticks = (uint16_t)tmp;
+    }
+
+    tick_new_value(ticks);
+    lcd_new_value();
+}
+
+static void measure() {
+    cli(); // disable interrupts before interacting with values
+
+    // reset interrupts
+    trigger_a = 0;
+    trigger_b = 0;
+
+    uint16_t a = time_a, b = time_b;
+
+    sei(); // enable interrupts immediately afterwards
+
+    calculate(a, b);
+}
+
+void setup() {
+    lcd_init();
+    delay(SCREEN_TIMEOUT); // show splash screen
+
+    timer_init();
+    interrupt_init();
+}
+
+void loop() {
+    if ((time_a == 1) && (time_b == 1)) {
+        // we got an event on both inputs
+        measure();
+    }
+
+    lcd_loop();
+}

firmware/OpenChrono/adc.cpp

@@ -0,0 +1,37 @@
+/*
+ * adc.cpp
+ *
+ * OpenChrono BB speed measurement device.
+ *
+ * https://provideyourown.com/2012/secret-arduino-voltmeter-measure-battery-voltage/
+ */
+
+#include <Arduino.h>
+
+#include "adc.h"
+
+long readVcc(void) {
+    // Read 1.1V reference against AVcc
+    // set the reference to Vcc and the measurement to the internal 1.1V reference
+#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
+    ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
+#elif defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
+    ADMUX = _BV(MUX5) | _BV(MUX0);
+#elif defined (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
+    ADMUX = _BV(MUX3) | _BV(MUX2);
+#else
+    ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
+#endif
+
+    delay(2); // Wait for Vref to settle
+    ADCSRA |= _BV(ADSC); // Start conversion
+    while (bit_is_set(ADCSRA,ADSC)); // measuring
+
+    uint8_t low  = ADCL; // must read ADCL first - it then locks ADCH
+    uint8_t high = ADCH; // unlocks both
+
+    long result = (high<<8) | low;
+
+    result = 1125300L / result; // Calculate Vcc (in mV); 1125300 = 1.1*1023*1000
+    return result; // Vcc in millivolts
+}

firmware/OpenChrono/adc.h

@@ -0,0 +1,15 @@
+/*
+ * adc.cpp
+ *
+ * OpenChrono BB speed measurement device.
+ *
+ * https://provideyourown.com/2012/secret-arduino-voltmeter-measure-battery-voltage/
+ */
+
+#ifndef __ADC_H__
+#define __ADC_H__
+
+// Vcc in millivolts
+long readVcc(void);
+
+#endif // __ADC_H__

firmware/OpenChrono/config.h

@@ -0,0 +1,83 @@
+/*
+ * config.h
+ *
+ * OpenChrono BB speed measurement device.
+ *
+ * Copyright (c) 2022 Thomas Buck <thomas@xythobuz.de>
+ */
+
+#ifndef __CONFIG_H__
+#define __CONFIG_H__
+
+// --------------------------------------
+
+#define VERSION "0.0.1"
+
+// --------------------------------------
+
+// hardware details
+
+#define SENSOR_DISTANCE 70.0 /* in mm */
+#define BB_WEIGHT 0.25 /* in g */
+
+// --------------------------------------
+
+// which unit to show on history screen
+
+#define METRIC 0
+#define IMPERIAL 1
+#define JOULES 2
+
+#define PREFERRED_UNITS JOULES
+
+// --------------------------------------
+
+// order and duration of screens
+
+#define SCREEN_CURRENT 0
+#define SCREEN_MIN 1
+#define SCREEN_AVERAGE 2
+#define SCREEN_MAX 3
+#define SCREEN_HISTORY 4
+
+#define SCREEN_ROTATION { \
+    SCREEN_CURRENT,       \
+    SCREEN_CURRENT,       \
+    SCREEN_MIN,           \
+    SCREEN_AVERAGE,       \
+    SCREEN_MAX,           \
+    SCREEN_HISTORY,       \
+    SCREEN_HISTORY        \
+}
+
+#define SCREEN_TIMEOUT 2500 /* in ms */
+
+// --------------------------------------
+
+// lcd config
+
+#define LCD_TYPE U8G2_SSD1306_128X64_NONAME_F_HW_I2C
+
+#define HEADING_FONT u8g2_font_VCR_OSD_tr
+#define TEXT_FONT u8g2_font_NokiaLargeBold_tr
+
+// --------------------------------------
+
+// history for graph of speeds.
+// should not be too big!
+
+#define HISTORY_BUFFER 50
+
+// --------------------------------------
+
+// placeholder data for debugging purposes
+
+#define DEBUG_TICK_COUNT 0
+#define DEBUG_TICK_DATA {}
+
+//#define DEBUG_TICK_COUNT 8
+//#define DEBUG_TICK_DATA { 8000, 10000, 9000, 11000, 8500, 9500, 10000, 7000 }
+
+// --------------------------------------
+
+#endif // __CONFIG_H__

firmware/OpenChrono/lcd.cpp

@@ -0,0 +1,283 @@
+/*
+ * lcd.cpp
+ *
+ * OpenChrono BB speed measurement device.
+ *
+ * Copyright (c) 2022 Thomas Buck <thomas@xythobuz.de>
+ *
+ * SSD1306 OLED display connected via I2C.
+ */
+
+#include <Arduino.h>
+
+#include "ticks.h"
+#include "adc.h"
+#include "lcd.h"
+#include "config.h"
+
+#include <Wire.h>
+#include <U8g2lib.h>
+
+static uint8_t screens[] = SCREEN_ROTATION;
+static uint8_t lcd_screen = 0;
+static uint64_t lcd_rotate_time = 0;
+
+static LCD_TYPE u8g2(U8G2_R0, U8X8_PIN_NONE);
+
+void lcd_init(void) {
+    u8g2.begin();
+    u8g2.setFontPosBottom();
+
+    u8g2.clearBuffer();
+    u8g2.setFlipMode(1);
+
+    String s = F("OpenChrono");
+    u8g2.setFont(HEADING_FONT);
+    uint8_t heading_height = u8g2.getMaxCharHeight();
+    u8g2.drawStr(
+        0,
+        heading_height,
+        s.c_str()
+    );
+
+    s = F("Version ");
+    s += F(VERSION);
+    u8g2.setFont(TEXT_FONT);
+    u8g2.drawStr(
+        (u8g2.getDisplayWidth() - u8g2.getStrWidth(s.c_str())) / 2,
+        heading_height + u8g2.getMaxCharHeight() + 4,
+        s.c_str()
+    );
+
+    s = String((double)SENSOR_DISTANCE, 0);
+    s += F("mm");
+    u8g2.setFont(TEXT_FONT);
+    u8g2.drawStr(
+        0,
+        u8g2.getDisplayHeight() - u8g2.getMaxCharHeight() - 4,
+        s.c_str()
+    );
+
+    s = String((double)readVcc() / 1000.0, 1);
+    s += F("V");
+    u8g2.setFont(TEXT_FONT);
+    u8g2.drawStr(
+        (u8g2.getDisplayWidth() - u8g2.getStrWidth(s.c_str())) / 2,
+        u8g2.getDisplayHeight() - u8g2.getMaxCharHeight() - 4,
+        s.c_str()
+    );
+
+    s = String((double)BB_WEIGHT, 2);
+    s += F("g");
+    u8g2.setFont(TEXT_FONT);
+    u8g2.drawStr(
+        u8g2.getDisplayWidth() - u8g2.getStrWidth(s.c_str()),
+        u8g2.getDisplayHeight() - u8g2.getMaxCharHeight() - 4,
+        s.c_str()
+    );
+
+    s = F("by xythobuz.de");
+    u8g2.setFont(TEXT_FONT);
+    u8g2.drawStr(
+        (u8g2.getDisplayWidth() - u8g2.getStrWidth(s.c_str())) / 2,
+        u8g2.getDisplayHeight() - 1,
+        s.c_str()
+    );
+
+    u8g2.sendBuffer();
+}
+
+void lcd_new_value(void) {
+    lcd_rotate_time = millis();
+    lcd_screen = 0;
+    lcd_draw(screens[lcd_screen]);
+}
+
+void lcd_draw(uint8_t screen) {
+    // fall back to first screen when no more data available
+    if (tick_count <= 1) {
+        screen = SCREEN_CURRENT;
+    }
+
+    if ((screen == SCREEN_CURRENT) || (screen == SCREEN_AVERAGE)
+            || (screen == SCREEN_MIN) || (screen == SCREEN_MAX)) {
+        if (tick_count < 1) {
+            u8g2.clearBuffer();
+            u8g2.setFlipMode(1);
+
+            String s = F("Ready!");
+            u8g2.setFont(HEADING_FONT);
+            u8g2.drawStr(
+                (u8g2.getDisplayWidth() - u8g2.getStrWidth(s.c_str())) / 2,
+                (u8g2.getDisplayHeight() + u8g2.getMaxCharHeight()) / 2,
+                s.c_str()
+            );
+
+            u8g2.sendBuffer();
+            return;
+        }
+
+        uint16_t tick = 0;
+
+        if (screen == SCREEN_CURRENT) {
+            // only show most recent value
+            tick = tick_history[tick_count - 1];
+        } else if (screen == SCREEN_AVERAGE) {
+            tick = tick_average();
+        } else if (screen == SCREEN_MAX) {
+            tick = tick_min();
+        } else if (screen == SCREEN_MIN) {
+            tick = tick_max();
+        }
+
+        double metric = tick_to_metric(tick);
+        double imperial = metric_to_imperial(metric);
+        double joules = metric_to_joules(metric, BB_WEIGHT);
+
+        u8g2.clearBuffer();
+        u8g2.setFlipMode(1);
+        u8g2.setFont(TEXT_FONT);
+
+        String s;
+
+        if (screen == SCREEN_CURRENT) {
+            s = F("Last Shot (No. ");
+        } else if (screen == SCREEN_AVERAGE) {
+            s = F("Average (of ");
+        } else if (screen == SCREEN_MAX) {
+            s = F("Maximum (of ");
+        } else if (screen == SCREEN_MIN) {
+            s = F("Minimum (of ");
+        }
+        s += String(tick_count);
+        s += F(")");
+
+        u8g2.drawStr(
+            (u8g2.getDisplayWidth() - u8g2.getStrWidth(s.c_str())) / 2,
+            u8g2.getMaxCharHeight(),
+            s.c_str()
+        );
+
+        s = String(metric, 0);
+        s += F(" m/s");
+        u8g2.drawStr(
+            0,
+            u8g2.getMaxCharHeight() * 2 + 1,
+            s.c_str()
+        );
+
+        s = String(imperial, 0);
+        s += F(" FPS");
+        u8g2.drawStr(
+            0,
+            u8g2.getMaxCharHeight() * 3 + 2,
+            s.c_str()
+        );
+
+        s = String(joules, 2);
+        s += F(" J");
+        u8g2.drawStr(
+            0,
+            u8g2.getMaxCharHeight() * 4 + 3,
+            s.c_str()
+        );
+
+        u8g2.sendBuffer();
+    } else if (screen == SCREEN_HISTORY) {
+        uint16_t min = tick_max();
+        uint16_t max = tick_min();
+        String s;
+
+        u8g2.clearBuffer();
+        u8g2.setFlipMode(1);
+        u8g2.setFont(TEXT_FONT);
+
+        // max text
+        double max_metric = tick_to_metric(max);
+        if (PREFERRED_UNITS == METRIC) {
+            s = String(max_metric, 0);
+        } else if (PREFERRED_UNITS == IMPERIAL) {
+            s = String(metric_to_imperial(max_metric), 0);
+        } else {
+            s = String(metric_to_joules(max_metric, BB_WEIGHT), 2);
+        }
+        uint8_t l1 = u8g2.getStrWidth(s.c_str());
+        u8g2.drawStr(
+            0,
+            u8g2.getMaxCharHeight(),
+            s.c_str()
+        );
+
+        // unit indicator
+        uint8_t l2;
+        if (PREFERRED_UNITS == METRIC) {
+            s = F("m/s");
+            l2 = u8g2.getStrWidth(s.c_str());
+            u8g2.drawStr(
+                0,
+                (u8g2.getDisplayHeight() + u8g2.getMaxCharHeight()) / 2,
+                s.c_str()
+            );
+        } else if (PREFERRED_UNITS == IMPERIAL) {
+            s = F("FPS");
+            l2 = u8g2.getStrWidth(s.c_str());
+            u8g2.drawStr(
+                0,
+                (u8g2.getDisplayHeight() + u8g2.getMaxCharHeight()) / 2,
+                s.c_str()
+            );
+        } else {
+            s = F("J");
+            l2 = u8g2.getStrWidth(s.c_str());
+            u8g2.drawStr(
+                0,
+                (u8g2.getDisplayHeight() + u8g2.getMaxCharHeight()) / 2,
+                s.c_str()
+            );
+        }
+
+        // min text
+        double min_metric = tick_to_metric(min);
+        if (PREFERRED_UNITS == METRIC) {
+            s = String(min_metric, 0);
+        } else if (PREFERRED_UNITS == IMPERIAL) {
+            s = String(metric_to_imperial(min_metric), 0);
+        } else {
+            s = String(metric_to_joules(min_metric, BB_WEIGHT), 2);
+        }
+        uint8_t l3 = u8g2.getStrWidth(s.c_str());
+        u8g2.drawStr(
+            0,
+            u8g2.getDisplayHeight() - 1,
+            s.c_str()
+        );
+
+        uint8_t lmax = max(max(l1, l2), l3);
+        uint8_t graph_start = lmax + 1;
+
+        // graph lines
+        uint8_t segment_w = (u8g2.getDisplayWidth() - graph_start) / (tick_count - 1);
+        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),
+                graph_start + ((i + 1) * segment_w),
+                map(tick_history[i + 1], min, max, 0, u8g2.getDisplayHeight() - 1)
+            );
+        }
+
+        u8g2.sendBuffer();
+    }
+}
+
+void lcd_loop(void) {
+    if ((millis() - lcd_rotate_time) > SCREEN_TIMEOUT) {
+        lcd_rotate_time = millis();
+        lcd_screen++;
+        if (lcd_screen >= sizeof(screens)) {
+            lcd_screen = 0;
+        }
+
+        lcd_draw(screens[lcd_screen]);
+    }
+}

firmware/OpenChrono/lcd.h

@@ -0,0 +1,19 @@
+/*
+ * lcd.h
+ *
+ * OpenChrono BB speed measurement device.
+ *
+ * Copyright (c) 2022 Thomas Buck <thomas@xythobuz.de>
+ *
+ * SSD1306 OLED display connected via I2C.
+ */
+
+#ifndef __LCD_H__
+#define __LCD_H__
+
+void lcd_init(void);
+void lcd_new_value(void);
+void lcd_draw(uint8_t screen);
+void lcd_loop(void);
+
+#endif // __LCD_H__

firmware/OpenChrono/ticks.cpp

@@ -0,0 +1,119 @@
+/*
+ * ticks.cpp
+ *
+ * OpenChrono BB speed measurement device.
+ *
+ * Copyright (c) 2022 Thomas Buck <thomas@xythobuz.de>
+ *
+ * Some notes about time calculations:
+ * We have Timer1 running with 16MHz
+ * which gives us a tick period of 62.5ns.
+ *
+ * The distance of the sensors is given in mm
+ * in SENSOR_DISTANCE (eg. 70mm).
+ *
+ * period_in_s = 1 / F_CPU
+ * period_in_s = 62.5 / 1000 / 1000 / 1000;
+ * dist_in_m = SENSOR_DISTANCE * 0.1 * 0.01
+ * travel_time_in_s = ticks * period_in_s;
+ * speed = dist_in_m / travel_time_in_s;
+ *
+ * period_in_s = 0.0000000625
+ * dist_in_m = 0.07m
+ * ticks = 2000
+ * travel_time_in_s = 0.000125
+ * speed = 560 m/s
+ *
+ * speed = (SENSOR_DISTANCE / 1000) / (ticks * 62.5 / 1000 / 1000 / 1000)
+ * speed = SENSOR_DISTANCE / (ticks * 62.5 / 1000 / 1000)
+ * speed = SENSOR_DISTANCE / (ticks * 1000 / F_CPU)
+ *
+ * Because we can at max measure 0xFFFF ticks
+ * this gives us a slowest speed we can measure.
+ * 0xFFFF = 65535 ticks
+ * 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)
+ */
+
+#include <Arduino.h>
+
+#include "ticks.h"
+#include "config.h"
+
+uint16_t tick_history[HISTORY_BUFFER] = DEBUG_TICK_DATA;
+uint8_t tick_count = DEBUG_TICK_COUNT;
+
+void tick_new_value(uint16_t ticks) {
+    // store new value in history buffer
+    if (tick_count < HISTORY_BUFFER) {
+        tick_history[tick_count] = ticks;
+        tick_count++;
+    } else {
+        for (uint8_t i = 0; i < HISTORY_BUFFER - 1; i++) {
+            tick_history[i] = tick_history[i + 1];
+        }
+        tick_history[HISTORY_BUFFER - 1] = ticks;
+    }
+}
+
+uint16_t tick_average() {
+    if (tick_count == 0) {
+        return 0;
+    }
+
+    uint64_t sum = 0;
+    for (uint8_t i = 0; i < tick_count; i++) {
+        sum += tick_history[i];
+    }
+    sum /= (uint64_t)tick_count;
+    return (uint16_t)sum;
+}
+
+uint16_t tick_max() {
+    if (tick_count == 0) {
+        return 0;
+    }
+
+    uint16_t cmp = 0;
+    for (uint8_t i = 0; i < tick_count; i++) {
+        if (tick_history[i] > cmp) {
+            cmp = tick_history[i];
+        }
+    }
+    return cmp;
+}
+
+uint16_t tick_min() {
+    if (tick_count == 0) {
+        return 0;
+    }
+
+    uint16_t cmp = 0xFFFF;
+    for (uint8_t i = 0; i < tick_count; i++) {
+        if (tick_history[i] < cmp) {
+            cmp = tick_history[i];
+        }
+    }
+    return cmp;
+}
+
+double tick_to_metric(uint16_t ticks) {
+    // v = d / t
+    double period = 1000.0 / ((double)(F_CPU));
+    double time = period * (double)ticks;
+    double speed = (double)SENSOR_DISTANCE / time;
+    return speed;
+}
+
+double metric_to_imperial(double speed) {
+    // convert m/s to f/s
+    speed *= 3.28084;
+    return speed;
+}
+
+double metric_to_joules(double speed, double mass) {
+    // e = 0.5 * m * v^2
+    double energy = 0.5 * mass * speed * speed / 1000.0;
+    return energy;
+}

firmware/OpenChrono/ticks.h

@@ -0,0 +1,23 @@
+/*
+ * ticks.h
+ *
+ * OpenChrono BB speed measurement device.
+ *
+ * Copyright (c) 2022 Thomas Buck <thomas@xythobuz.de>
+ */
+
+#ifndef __TICKS_H__
+#define __TICKS_H__
+
+extern uint16_t tick_history[];
+extern uint8_t tick_count;
+
+void tick_new_value(uint16_t ticks);
+uint16_t tick_average();
+uint16_t tick_max();
+uint16_t tick_min();
+double tick_to_metric(uint16_t ticks);
+double metric_to_imperial(double speed);
+double metric_to_joules(double speed, double mass);
+
+#endif // __TICKS_H__

firmware/OpenChrono/timing.cpp

@@ -0,0 +1,48 @@
+/*
+ * timing.cpp
+ *
+ * OpenChrono BB speed measurement device.
+ *
+ * Copyright (c) 2022 Thomas Buck <thomas@xythobuz.de>
+ *
+ * Two phototransistors connected to external interrupts 0 and 1.
+ */
+
+#include <Arduino.h>
+
+#include "timing.h"
+#include "config.h"
+
+volatile uint8_t trigger_a = 0, trigger_b = 0;
+volatile uint16_t time_a = 0, time_b = 0;
+
+void interrupt_init() {
+    // trigger both on rising edge
+    EICRA = (1 << ISC00) | (1 << ISC01);
+    EICRA |= (1 << ISC10) | (1 << ISC11);
+
+    // enable interrupts
+    EIMSK = (1 << INT0) | (1 << INT1);
+}
+
+ISR(INT0_vect) {
+    time_a = timer_get();
+    trigger_a = 1;
+}
+
+ISR(INT1_vect) {
+    time_b = timer_get();
+    trigger_b = 1;
+}
+
+// --------------------------------------
+
+void timer_init() {
+    // normal mode, prescaler 1
+    TCCR1A = 0;
+    TCCR1B = (1 << CS10);
+}
+
+uint16_t timer_get() {
+    return TCNT1;
+}

firmware/OpenChrono/timing.h

@@ -0,0 +1,22 @@
+/*
+ * timing.h
+ *
+ * OpenChrono BB speed measurement device.
+ *
+ * Copyright (c) 2022 Thomas Buck <thomas@xythobuz.de>
+ *
+ * Two phototransistors connected to external interrupts 0 and 1.
+ */
+
+#ifndef __TIMING_H__
+#define __TIMING_H__
+
+extern volatile uint8_t trigger_a, trigger_b;
+extern volatile uint16_t time_a, time_b;
+
+void interrupt_init();
+
+void timer_init();
+uint16_t timer_get();
+
+#endif // __TIMING_H__

firmware/platformio.ini

@@ -0,0 +1,12 @@
+[platformio]
+default_envs = arduino
+src_dir = OpenChrono
+
+[env:arduino]
+platform = atmelavr
+framework = arduino
+board = nanoatmega328
+lib_deps =
+  SPI
+  Wire
+  olikraus/U8g2@^2.33.4

hardware/extern/threads.scad

@@ -0,0 +1,382 @@
+/*
+ * ISO-standard metric threads, following this specification:
+ *          http://en.wikipedia.org/wiki/ISO_metric_screw_thread
+ *
+ * Copyright 2020 Dan Kirshner - dan_kirshner@yahoo.com
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ *
+ * Version 2.4.  2019-07-14  Add test option - do not render threads.
+ * Version 2.3.  2017-08-31  Default for leadin: 0 (best for internal threads).
+ * Version 2.2.  2017-01-01  Correction for angle; leadfac option.  (Thanks to
+ *                           Andrew Allen <a2intl@gmail.com>.)
+ * Version 2.1.  2016-12-04  Chamfer bottom end (low-z); leadin option.
+ * Version 2.0.  2016-11-05  Backwards compatibility (earlier OpenSCAD) fixes.
+ * Version 1.9.  2016-07-03  Option: tapered.
+ * Version 1.8.  2016-01-08  Option: (non-standard) angle.
+ * Version 1.7.  2015-11-28  Larger x-increment - for small-diameters.
+ * Version 1.6.  2015-09-01  Options: square threads, rectangular threads.
+ * Version 1.5.  2015-06-12  Options: thread_size, groove.
+ * Version 1.4.  2014-10-17  Use "faces" instead of "triangles" for polyhedron
+ * Version 1.3.  2013-12-01  Correct loop over turns -- don't have early cut-off
+ * Version 1.2.  2012-09-09  Use discrete polyhedra rather than linear_extrude ()
+ * Version 1.1.  2012-09-07  Corrected to right-hand threads!
+ */
+
+// Examples.
+//
+// Standard M8 x 1.
+// metric_thread (diameter=8, pitch=1, length=4);
+
+// Square thread.
+// metric_thread (diameter=8, pitch=1, length=4, square=true);
+
+// Non-standard: long pitch, same thread size.
+//metric_thread (diameter=8, pitch=4, length=4, thread_size=1, groove=true);
+
+// Non-standard: 20 mm diameter, long pitch, square "trough" width 3 mm,
+// depth 1 mm.
+//metric_thread (diameter=20, pitch=8, length=16, square=true, thread_size=6,
+//               groove=true, rectangle=0.333);
+
+// English: 1/4 x 20.
+//english_thread (diameter=1/4, threads_per_inch=20, length=1);
+
+// Tapered.  Example -- pipe size 3/4" -- per:
+// http://www.engineeringtoolbox.com/npt-national-pipe-taper-threads-d_750.html
+// english_thread (diameter=1.05, threads_per_inch=14, length=3/4, taper=1/16);
+
+// Thread for mounting on Rohloff hub.
+//difference () {
+//   cylinder (r=20, h=10, $fn=100);
+//
+//   metric_thread (diameter=34, pitch=1, length=10, internal=true, n_starts=6);
+//}
+
+
+// ----------------------------------------------------------------------------
+function segments (diameter) = min (50, max (ceil (diameter*6), 25));
+
+
+// ----------------------------------------------------------------------------
+// diameter -    outside diameter of threads in mm. Default: 8.
+// pitch    -    thread axial "travel" per turn in mm.  Default: 1.
+// length   -    overall axial length of thread in mm.  Default: 1.
+// internal -    true = clearances for internal thread (e.g., a nut).
+//               false = clearances for external thread (e.g., a bolt).
+//               (Internal threads should be "cut out" from a solid using
+//               difference ()).  Default: false.
+// n_starts -    Number of thread starts (e.g., DNA, a "double helix," has
+//               n_starts=2).  See wikipedia Screw_thread.  Default: 1.
+// thread_size - (non-standard) axial width of a single thread "V" - independent
+//               of pitch.  Default: same as pitch.
+// groove      - (non-standard) true = subtract inverted "V" from cylinder
+//                (rather thanadd protruding "V" to cylinder).  Default: false.
+// square      - true = square threads (per
+//               https://en.wikipedia.org/wiki/Square_thread_form).  Default:
+//               false.
+// rectangle   - (non-standard) "Rectangular" thread - ratio depth/(axial) width
+//               Default: 0 (standard "v" thread).
+// angle       - (non-standard) angle (deg) of thread side from perpendicular to
+//               axis (default = standard = 30 degrees).
+// taper       - diameter change per length (National Pipe Thread/ANSI B1.20.1
+//               is 1" diameter per 16" length). Taper decreases from 'diameter'
+//               as z increases.  Default: 0 (no taper).
+// leadin      - 0 (default): no chamfer; 1: chamfer (45 degree) at max-z end;
+//               2: chamfer at both ends, 3: chamfer at z=0 end.
+// leadfac     - scale of leadin chamfer (default: 1.0 = 1/2 thread).
+// test        - true = do not render threads (just draw "blank" cylinder).
+//               Default: false (draw threads).
+module metric_thread (diameter=8, pitch=1, length=1, internal=false, n_starts=1,
+                      thread_size=-1, groove=false, square=false, rectangle=0,
+                      angle=30, taper=0, leadin=0, leadfac=1.0, test=false)
+{
+   // thread_size: size of thread "V" different than travel per turn (pitch).
+   // Default: same as pitch.
+   local_thread_size = thread_size == -1 ? pitch : thread_size;
+   local_rectangle = rectangle ? rectangle : 1;
+
+   n_segments = segments (diameter);
+   h = (test && ! internal) ? 0 : (square || rectangle) ? local_thread_size*local_rectangle/2 : local_thread_size / (2 * tan(angle));
+
+   h_fac1 = (square || rectangle) ? 0.90 : 0.625;
+
+   // External thread includes additional relief.
+   h_fac2 = (square || rectangle) ? 0.95 : 5.3/8;
+
+   tapered_diameter = diameter - length*taper;
+
+   difference () {
+      union () {
+         if (! groove) {
+            if (! test) {
+               metric_thread_turns (diameter, pitch, length, internal, n_starts,
+                                    local_thread_size, groove, square, rectangle, angle,
+                                    taper);
+            }
+         }
+
+         difference () {
+
+            // Solid center, including Dmin truncation.
+            if (groove) {
+               cylinder (r1=diameter/2, r2=tapered_diameter/2,
+                         h=length, $fn=n_segments);
+            } else if (internal) {
+               cylinder (r1=diameter/2 - h*h_fac1, r2=tapered_diameter/2 - h*h_fac1,
+                         h=length, $fn=n_segments);
+            } else {
+
+               // External thread.
+               cylinder (r1=diameter/2 - h*h_fac2, r2=tapered_diameter/2 - h*h_fac2,
+                         h=length, $fn=n_segments);
+            }
+
+            if (groove) {
+               if (! test) {
+                  metric_thread_turns (diameter, pitch, length, internal, n_starts,
+                                       local_thread_size, groove, square, rectangle,
+                                       angle, taper);
+               }
+            }
+         }
+      }
+
+      // chamfer z=0 end if leadin is 2 or 3
+      if (leadin == 2 || leadin == 3) {
+         difference () {
+            cylinder (r=diameter/2 + 1, h=h*h_fac1*leadfac, $fn=n_segments);
+
+            cylinder (r2=diameter/2, r1=diameter/2 - h*h_fac1*leadfac, h=h*h_fac1*leadfac,
+                      $fn=n_segments);
+         }
+      }
+
+      // chamfer z-max end if leadin is 1 or 2.
+      if (leadin == 1 || leadin == 2) {
+         translate ([0, 0, length + 0.05 - h*h_fac1*leadfac]) {
+            difference () {
+               cylinder (r=diameter/2 + 1, h=h*h_fac1*leadfac, $fn=n_segments);
+               cylinder (r1=tapered_diameter/2, r2=tapered_diameter/2 - h*h_fac1*leadfac, h=h*h_fac1*leadfac,
+                         $fn=n_segments);
+            }
+         }
+      }
+   }
+}
+
+
+// ----------------------------------------------------------------------------
+// Input units in inches.
+// Note: units of measure in drawing are mm!
+module english_thread (diameter=0.25, threads_per_inch=20, length=1,
+                      internal=false, n_starts=1, thread_size=-1, groove=false,
+                      square=false, rectangle=0, angle=30, taper=0, leadin=0,
+                      leadfac=1.0, test=false)
+{
+   // Convert to mm.
+   mm_diameter = diameter*25.4;
+   mm_pitch = (1.0/threads_per_inch)*25.4;
+   mm_length = length*25.4;
+
+   echo (str ("mm_diameter: ", mm_diameter));
+   echo (str ("mm_pitch: ", mm_pitch));
+   echo (str ("mm_length: ", mm_length));
+   metric_thread (mm_diameter, mm_pitch, mm_length, internal, n_starts,
+                  thread_size, groove, square, rectangle, angle, taper, leadin,
+                  leadfac, test);
+}
+
+// ----------------------------------------------------------------------------
+module metric_thread_turns (diameter, pitch, length, internal, n_starts,
+                            thread_size, groove, square, rectangle, angle,
+                            taper)
+{
+   // Number of turns needed.
+   n_turns = floor (length/pitch);
+
+   intersection () {
+
+      // Start one below z = 0.  Gives an extra turn at each end.
+      for (i=[-1*n_starts : n_turns+1]) {
+         translate ([0, 0, i*pitch]) {
+            metric_thread_turn (diameter, pitch, internal, n_starts,
+                                thread_size, groove, square, rectangle, angle,
+                                taper, i*pitch);
+         }
+      }
+
+      // Cut to length.
+      translate ([0, 0, length/2]) {
+         cube ([diameter*3, diameter*3, length], center=true);
+      }
+   }
+}
+
+
+// ----------------------------------------------------------------------------
+module metric_thread_turn (diameter, pitch, internal, n_starts, thread_size,
+                           groove, square, rectangle, angle, taper, z)
+{
+   n_segments = segments (diameter);
+   fraction_circle = 1.0/n_segments;
+   for (i=[0 : n_segments-1]) {
+      rotate ([0, 0, i*360*fraction_circle]) {
+         translate ([0, 0, i*n_starts*pitch*fraction_circle]) {
+            //current_diameter = diameter - taper*(z + i*n_starts*pitch*fraction_circle);
+            thread_polyhedron ((diameter - taper*(z + i*n_starts*pitch*fraction_circle))/2,
+                               pitch, internal, n_starts, thread_size, groove,
+                               square, rectangle, angle);
+         }
+      }
+   }
+}
+
+
+// ----------------------------------------------------------------------------
+module thread_polyhedron (radius, pitch, internal, n_starts, thread_size,
+                          groove, square, rectangle, angle)
+{
+   n_segments = segments (radius*2);
+   fraction_circle = 1.0/n_segments;
+
+   local_rectangle = rectangle ? rectangle : 1;
+
+   h = (square || rectangle) ? thread_size*local_rectangle/2 : thread_size / (2 * tan(angle));
+   outer_r = radius + (internal ? h/20 : 0); // Adds internal relief.
+   //echo (str ("outer_r: ", outer_r));
+
+   // A little extra on square thread -- make sure overlaps cylinder.
+   h_fac1 = (square || rectangle) ? 1.1 : 0.875;
+   inner_r = radius - h*h_fac1; // Does NOT do Dmin_truncation - do later with
+                                // cylinder.
+
+   translate_y = groove ? outer_r + inner_r : 0;
+   reflect_x   = groove ? 1 : 0;
+
+   // Make these just slightly bigger (keep in proportion) so polyhedra will
+   // overlap.
+   x_incr_outer = (! groove ? outer_r : inner_r) * fraction_circle * 2 * PI * 1.02;
+   x_incr_inner = (! groove ? inner_r : outer_r) * fraction_circle * 2 * PI * 1.02;
+   z_incr = n_starts * pitch * fraction_circle * 1.005;
+
+   /*
+    (angles x0 and x3 inner are actually 60 deg)
+
+                          /\  (x2_inner, z2_inner) [2]
+                         /  \
+   (x3_inner, z3_inner) /    \
+                  [3]   \     \
+                        |\     \ (x2_outer, z2_outer) [6]
+                        | \    /
+                        |  \  /|
+             z          |[7]\/ / (x1_outer, z1_outer) [5]
+             |          |   | /
+             |   x      |   |/
+             |  /       |   / (x0_outer, z0_outer) [4]
+             | /        |  /     (behind: (x1_inner, z1_inner) [1]
+             |/         | /
+    y________|          |/
+   (r)                  / (x0_inner, z0_inner) [0]
+
+   */
+
+   x1_outer = outer_r * fraction_circle * 2 * PI;
+
+   z0_outer = (outer_r - inner_r) * tan(angle);
+   //echo (str ("z0_outer: ", z0_outer));
+
+   //polygon ([[inner_r, 0], [outer_r, z0_outer],
+   //        [outer_r, 0.5*pitch], [inner_r, 0.5*pitch]]);
+   z1_outer = z0_outer + z_incr;
+
+   // Give internal square threads some clearance in the z direction, too.
+   bottom = internal ? 0.235 : 0.25;
+   top    = internal ? 0.765 : 0.75;
+
+   translate ([0, translate_y, 0]) {
+      mirror ([reflect_x, 0, 0]) {
+
+         if (square || rectangle) {
+
+            // Rule for face ordering: look at polyhedron from outside: points must
+            // be in clockwise order.
+            polyhedron (
+               points = [
+                         [-x_incr_inner/2, -inner_r, bottom*thread_size],         // [0]
+                         [x_incr_inner/2, -inner_r, bottom*thread_size + z_incr], // [1]
+                         [x_incr_inner/2, -inner_r, top*thread_size + z_incr],    // [2]
+                         [-x_incr_inner/2, -inner_r, top*thread_size],            // [3]
+
+                         [-x_incr_outer/2, -outer_r, bottom*thread_size],         // [4]
+                         [x_incr_outer/2, -outer_r, bottom*thread_size + z_incr], // [5]
+                         [x_incr_outer/2, -outer_r, top*thread_size + z_incr],    // [6]
+                         [-x_incr_outer/2, -outer_r, top*thread_size]             // [7]
+                        ],
+
+               faces = [
+                         [0, 3, 7, 4],  // This-side trapezoid
+
+                         [1, 5, 6, 2],  // Back-side trapezoid
+
+                         [0, 1, 2, 3],  // Inner rectangle
+
+                         [4, 7, 6, 5],  // Outer rectangle
+
+                         // These are not planar, so do with separate triangles.
+                         [7, 2, 6],     // Upper rectangle, bottom
+                         [7, 3, 2],     // Upper rectangle, top
+
+                         [0, 5, 1],     // Lower rectangle, bottom
+                         [0, 4, 5]      // Lower rectangle, top
+                        ]
+            );
+         } else {
+
+            // Rule for face ordering: look at polyhedron from outside: points must
+            // be in clockwise order.
+            polyhedron (
+               points = [
+                         [-x_incr_inner/2, -inner_r, 0],                        // [0]
+                         [x_incr_inner/2, -inner_r, z_incr],                    // [1]
+                         [x_incr_inner/2, -inner_r, thread_size + z_incr],      // [2]
+                         [-x_incr_inner/2, -inner_r, thread_size],              // [3]
+
+                         [-x_incr_outer/2, -outer_r, z0_outer],                 // [4]
+                         [x_incr_outer/2, -outer_r, z0_outer + z_incr],         // [5]
+                         [x_incr_outer/2, -outer_r, thread_size - z0_outer + z_incr], // [6]
+                         [-x_incr_outer/2, -outer_r, thread_size - z0_outer]    // [7]
+                        ],
+
+               faces = [
+                         [0, 3, 7, 4],  // This-side trapezoid
+
+                         [1, 5, 6, 2],  // Back-side trapezoid
+
+                         [0, 1, 2, 3],  // Inner rectangle
+
+                         [4, 7, 6, 5],  // Outer rectangle
+
+                         // These are not planar, so do with separate triangles.
+                         [7, 2, 6],     // Upper rectangle, bottom
+                         [7, 3, 2],     // Upper rectangle, top
+
+                         [0, 5, 1],     // Lower rectangle, bottom
+                         [0, 4, 5]      // Lower rectangle, top
+                        ]
+            );
+         }
+      }
+   }
+}
+
+

hardware/openchrono.scad

@@ -0,0 +1,390 @@
+outer_dia = 55;
+inner_dia = 8.5;
+height = 100;
+
+body_gap = 0.1;
+
+body_screw_off = 10;
+body_screw_pos = 20;
+body_screw_dia = 3.2;
+body_screw_head = 5.8;
+body_screw_depth = 3.2;
+body_screw_insert_dia = 5.0;
+body_screw_insert_height = 15.0;
+
+lcd_pcb_w = 29.0;
+lcd_pcb_h = 29.0;
+lcd_pcb_d = 5.2;
+lcd_hole_dia = 2.0;
+lcd_hole_w = 6.0;
+lcd_hole_h = 2.5;
+lcd_off = 10.0;
+lcd_hole_off_x = 23.1;
+lcd_hole_off_y = 23.65;
+lcd_hole_off_y_total = 0.4;
+lcd_hole_screw_len = 10.0;
+
+arduino_w = 19.0;
+arduino_h = 46.5 + 10;
+arduino_d = 10.0;
+
+bat_w = 11.5;
+bat_l = 45.5;
+bat_tab_w = 9.5;
+bat_tab_h = 8.5;
+bat_tab_d = 2.5; // TODO?
+bat_tab_con_w = 5.0; // TODO?
+bat_tab_con_h = 6.5; // TODO?
+bat_spring_w = 7.5; // TODO?
+bat_spring_dist = 7.5; // TODO?
+bat_wall = 1.0;
+bat_angle = 48;
+
+led_dia = 3.3;
+led_l = 4.5;
+led_off = 15;
+led_ridge_dia = 4.2;
+led_ridge_h = 1.6;
+
+switch_w = 12.0;
+switch_h = 6.5;
+switch_d = 10.0;
+switch_plate_w = 20.5;
+switch_plate_h = switch_h;
+switch_dia = 2.6;
+switch_screw_l = 10.0;
+switch_screw_d = 15.0;
+switch_off = 15;
+
+bat_h = bat_l + bat_spring_dist + 2 * bat_wall + 2 * bat_tab_d;
+
+$fn = 42;
+
+echo("sensor_distance", height - 2 * led_off);
+
+// https://dkprojects.net/openscad-threads/ 
+include <extern/threads.scad>
+
+// 1911
+thread_profile_1911 = [
+    true, // type is_male
+    12.0, // diameter
+    1.0, // pitch
+    0.0, // offset
+    9.0 // length
+];
+
+// M14x1.0 female thread
+thread_profile_m14 = [
+    false, // type is_male
+    14.0, // diameter
+    1.0, // pitch
+    0.0, // offset
+    12.0 // length
+];
+
+// ASG / KWC Cobray Ingram M11 CO2 NBB 6mm
+thread_profile_mac11 = [
+    false, // type is_male
+    16.5, // diameter
+    1.5, // pitch
+    8.0, // offset
+    10.0 // length
+];
+
+// debug / testing
+thread_profile_none = [ false, 0, 0, 0, 0 ];
+
+thread_profile = thread_profile_m14;
+thread_base = 1.0;
+
+// how deep things on the outside have to be set in
+function circle_offset_deviation(off, dia) =
+    dia * (1 - sin(acos(off * 2 / dia))) / 2;
+
+module lcd_cutout() {
+    difference() {
+        cube([lcd_pcb_w, lcd_pcb_h, lcd_pcb_d + 10]);
+        
+        for (x = [0, lcd_pcb_w - lcd_hole_w])
+        for (y = [0, lcd_pcb_h - lcd_hole_w])
+        translate([x, y, -1])
+            cube([lcd_hole_w, lcd_hole_w, lcd_hole_h + 1]);
+    }
+            
+    for (x = [0, lcd_hole_off_x])
+    for (y = [0, lcd_hole_off_y])
+    translate([x + lcd_hole_w / 2, y + lcd_hole_w / 2 - lcd_hole_off_y_total, lcd_hole_h - lcd_hole_screw_len])
+    cylinder(d = lcd_hole_dia, h = lcd_hole_screw_len + 1);
+}
+
+module arduino_cutout() {
+    cube([arduino_w, arduino_h, arduino_d]);
+}
+
+module bat_cutout() {
+    // battery
+    translate([0, 0, bat_tab_d + bat_wall])
+    cube([bat_w, bat_w, bat_l + bat_spring_dist]);
+    
+    // negative terminal
+    for (z = [0, bat_l + bat_spring_dist + 2 * bat_wall + bat_tab_d])
+    translate([(bat_w - bat_tab_w) / 2, (bat_w - bat_tab_h) / 2, z])
+    cube([bat_tab_w, bat_tab_h + (bat_w - bat_tab_h) / 2, bat_tab_d]);
+
+    // spring
+    for (z = [bat_tab_d, bat_l + bat_spring_dist + bat_wall + bat_tab_d])
+    translate([(bat_w - bat_spring_w) / 2, (bat_w - bat_spring_w) / 2, z - 0.1])
+    cube([bat_spring_w, bat_spring_w + (bat_w - bat_spring_w) / 2, bat_wall + 0.2]);
+}
+
+module switch_cutout() {
+    translate([-switch_w / 2, -10, -switch_h / 2])
+    cube([switch_w, switch_d + 10, switch_h]);
+    
+    translate([-switch_plate_w / 2, -switch_d, -switch_plate_h / 2])
+    cube([switch_plate_w, 10, switch_plate_h]);
+    
+    for (x = [1, -1])
+    scale([x, 1, 1])
+    translate([-switch_screw_d / 2, -10, 0])
+    rotate([-90, 0, 0])
+    cylinder(d = switch_dia, h = switch_screw_l + 10);
+}
+
+module thread(profile, thread_draw) {
+    if (profile[0]) {
+        // male thread
+        difference() {
+            union() {
+                cylinder(d = outer_dia, h = thread_base);
+                metric_thread(profile[1], profile[2], profile[4] + thread_base, test=!thread_draw);
+            }
+            
+            translate([0, 0, -1])
+            cylinder(d = inner_dia, h = profile[4] + thread_base + 2);
+        }
+    } else {
+        // female thread
+        difference() {
+            cylinder(d = outer_dia, h = thread_base + profile[4] + profile[3]);
+            
+            metric_thread(profile[1], profile[2], profile[4] + thread_base + 1, true, test=!thread_draw);
+            
+            translate([0, 0, thread_base + profile[4]])
+            cylinder(d = profile[1] + 2, h = profile[3] + 1);
+            
+            translate([0, 0, -1])
+            cylinder(d = inner_dia, h = profile[4] + thread_base + profile[3] + 2);
+        } 
+    }
+}
+
+module half_body(right_side) {
+    difference() {
+        // body
+        cylinder(d = outer_dia, h = height);
+        
+        // inner tube
+        translate([0, 0, -1])
+        cylinder(d = inner_dia, h = height + 2);
+        
+        // remove half of cylinder
+        translate([-outer_dia / 2 - 1, -outer_dia + body_gap / 2, -1])
+        cube([outer_dia + 2, outer_dia, height + 2]);
+        
+        // led cutouts
+        for (x = [1, -1])
+        scale([x, 1, 1])
+        for (z = [led_off, height - led_off])
+        translate([inner_dia / 2 - 1, 0, z])
+        rotate([0, 90, 0]) {
+            cylinder(d = led_dia, h = led_l + led_ridge_h + 1);
+            
+            translate([0, 0, led_l + 1])
+            cylinder(d = led_ridge_dia, h = led_ridge_h);
+        }
+        
+        // TODO hacky sensor cable, arduino side
+        for (z = [1, -1])
+        translate([0, 0, height / 2])
+        scale([right_side ? -1 : 1, 1, z])
+        translate([0, 0, height / 2 - led_off])
+        hull() {
+            for (x = [0, 5])
+            translate([-inner_dia / 2 - led_l - led_ridge_h - x, 0, 0])
+            rotate([0, 90, 0])
+            cylinder(d = led_ridge_dia, h = led_ridge_h);
+            
+            translate([-inner_dia / 2 - led_l - led_ridge_h - 5, 0, -10])
+            cylinder(d = led_ridge_dia, h = led_ridge_h);
+        }
+        
+        // TODO hacky led cable, led side
+        for (z = [1, -1])
+        translate([0, 0, height / 2])
+        scale([right_side ? 1 : -1, 1, z])
+        translate([0, 0, height / 2 - led_off])
+        hull() {
+            for (x = [0, 5])
+            translate([-inner_dia / 2 - led_l - led_ridge_h - x, 0, 0])
+            rotate([0, 90, 0])
+            cylinder(d = led_ridge_dia, h = led_ridge_h);
+            
+            translate([-inner_dia / 2 - led_l - led_ridge_h - 5, 0, -height / 2 + led_off - 1])
+            cube([led_ridge_dia + 2, led_ridge_dia - 2, led_ridge_h]);
+        }
+    }
+}
+
+module screw_holes(with_head) {
+    for (x = [body_screw_pos, -body_screw_pos])
+    for (z = [body_screw_off, height - body_screw_off])
+    translate([x, 0, z])
+    rotate([-90, 0, 0]) {
+        translate([0, 0, -1])
+        if (with_head)
+        cylinder(d = body_screw_dia, h = outer_dia / 2 + 2);
+        else
+        cylinder(d = body_screw_insert_dia, h = body_screw_insert_height);
+        
+        if (with_head)
+        translate([0, 0, outer_dia / 2 - circle_offset_deviation(body_screw_pos + body_screw_head / 2, outer_dia) - body_screw_depth - 2])
+        cylinder(d = body_screw_head, h = 50);
+    }
+}
+
+module left_half(thread_draw) {
+    difference() {
+        union() {
+            half_body(false);
+            
+            translate([0, 0, height])
+            thread(thread_profile, thread_draw);
+        }
+        
+        translate([-outer_dia / 2 - 1, -outer_dia / 2 - 1 + body_gap / 2, height - 1])
+        cube([outer_dia + 2, outer_dia / 2 + 1, 50]);
+        
+        screw_holes(false);
+        
+        translate([0, outer_dia / 2 - circle_offset_deviation(lcd_pcb_h / 2, outer_dia) - lcd_pcb_d, height / 2 + lcd_off])
+        rotate([0, 90, 0])
+        translate([lcd_pcb_w / 2, 0, -lcd_pcb_h / 2])
+        rotate([90, 0, 180])
+        lcd_cutout();
+        
+        translate([-outer_dia / 2 + ((outer_dia / 2) - (inner_dia / 2) - arduino_w) / 2, arduino_d / 2, -arduino_h / 2 + height / 2])
+        rotate([90, 0, 0])
+        arduino_cutout();
+        
+        translate([0, outer_dia / 2 - circle_offset_deviation(switch_plate_w / 2, outer_dia), height / 2 - switch_off])
+        rotate([0, 0, 180])
+        switch_cutout();
+        
+        // TODO hacky switch cable
+        translate([-16, -10, height / 2 - switch_off])
+        rotate([-90, 0, -27])
+        cylinder(d = switch_h - 2, h = outer_dia);
+        
+        // TODO hacky lcd cable
+        translate([-15, -10, 60])
+        rotate([-90, 0, -12])
+        cylinder(d = 6.0, h = outer_dia);
+        
+        // TODO hacky led cable
+        translate([0, 0, height / 2 + 3]) {
+            translate([inner_dia / 2 + led_l + led_ridge_dia / 2, led_ridge_h + inner_dia / 2 + 2, 0])
+            rotate([90, 0, 0])
+            cylinder(d = led_ridge_dia, h = led_ridge_h + inner_dia / 2 + 2);
+            
+            hull() {
+                translate([inner_dia / 2 + led_l + led_ridge_dia / 2, led_ridge_h + inner_dia / 2 + 2, 0])
+                rotate([90, 0, 0])
+                cylinder(d = led_ridge_dia, h = led_ridge_h);
+            
+                translate([inner_dia / 2 + led_l + led_ridge_dia / 2 - 5, led_ridge_h + inner_dia / 2 + 2, 0])
+                rotate([0, 90, 0])
+                cylinder(d = led_ridge_dia, h = led_ridge_h + 5);
+            }
+            
+            translate([inner_dia / 2 + led_l + led_ridge_dia / 2 - 25, led_ridge_h + inner_dia / 2 + 2, 0])
+            rotate([0, 90, 0])
+            cylinder(d = led_ridge_dia, h = led_ridge_h + 25);
+            
+            hull() {
+                translate([inner_dia / 2 + led_l + led_ridge_dia / 2 - 25, led_ridge_h + inner_dia / 2 + 2, 0])
+                rotate([90, 0, 0])
+                cylinder(d = led_ridge_dia, h = led_ridge_h + 10);
+            
+                translate([inner_dia / 2 + led_l + led_ridge_dia / 2 - 25, led_ridge_h + inner_dia / 2 + 2, 0])
+                rotate([0, 90, 0])
+                cylinder(d = led_ridge_dia, h = led_ridge_h);
+            }
+        }
+    }
+}
+
+module right_half(thread_draw) {
+    difference() {
+        union() {
+            half_body(true);
+            
+            translate([0, 0, height])
+            rotate([0, 0, 180])
+            thread(thread_profile, thread_draw);
+        }
+        
+        translate([-outer_dia / 2 - 1, -outer_dia / 2 - 1 + body_gap / 2, height - 1])
+        cube([outer_dia + 2, outer_dia / 2 + 1, 50]);
+        
+        screw_holes(true);
+        
+        translate([outer_dia / 2 - arduino_w -((outer_dia / 2) - (inner_dia / 2) - arduino_w) / 2, arduino_d / 2, -arduino_h / 2 + height / 2])
+        rotate([90, 0, 0])
+        arduino_cutout();
+        
+        for (a = [0, bat_angle, -bat_angle])
+        rotate([0, 0, a])
+        translate([-bat_w / 2, outer_dia / 2 - bat_w, (height - bat_h) / 2])
+        bat_cutout();
+    }
+}
+
+module assembly_closed(thread_draw) {
+    right_half(thread_draw);
+    
+    rotate([0, 0, 180])
+    left_half(thread_draw);
+}
+
+module assembly_opened(angle, thread_draw) {
+    translate([-outer_dia / 2, 0, 0]) {
+        rotate([0, 0, angle / 2])
+        translate([outer_dia / 2, 0, 0])
+        right_half(thread_draw);
+        
+        rotate([0, 0, -angle / 2])
+        translate([outer_dia / 2, 0, 0])
+        rotate([0, 0, 180])
+        left_half(thread_draw);
+    }
+}
+
+module print() {
+    translate([outer_dia / 2 + 5, 0, 0])
+    left_half(true);
+    
+    translate([-outer_dia / 2 - 5, 0, 0])
+    right_half(true);
+}
+
+//lcd_cutout();
+
+//left_half(false);
+//right_half(false);
+
+//assembly_closed(false);
+//assembly_opened(90, false);
+
+print();