reduce flash mem usage by moving common text to a const.

Fixes https://github.com/awonak/alt-gravity/issues/12

Reviewed-on: https://git.pinkduck.xyz/awonak/libGravity/pulls/23

examples/clock_mod/clock_mod.ino

@@ -17,7 +17,7 @@
  *
  */
 
-#include "gravity.h"
+#include <libGravity.h>
 
 // Firmware state variables.
 struct Channel {

firmware/Gravity/Gravity.ino

@@ -2,7 +2,7 @@
  * @file Gravity.ino
  * @author Adam Wonak (https://github.com/awonak/)
  * @brief Alt firmware version of Gravity by Sitka Instruments.
- * @version v2.0.1 - June 2025 awonak - Full rewrite
+ * @version v2.0.0 - June 2025 awonak - Full rewrite
  * @version v1.0 - August 2023 Oleksiy H - Initial release
  * @date 2025-07-04
  *
@@ -37,16 +37,18 @@
  *      Shift - hold and rotate encoder to change current selected output channel.
  *
  * EXT:
- *      External clock input. When Gravity is set to INTERNAL clock mode, this
+ *      External clock input. When Gravity is set to INTERNAL or MIDI clock
- *      input is used to reset clocks.
+ *      source, this input is used to reset clocks.
  *
  * CV1:
+ *      External analog input used to provide modulation to any channel parameter.
+ *
  * CV2:
  *      External analog input used to provide modulation to any channel parameter.
  *
  */
 
-#include <gravity.h>
+#include <libGravity.h>
 
 #include "app_state.h"
 #include "channel.h"
@@ -89,18 +91,8 @@ void loop() {
     // Process change in state of inputs and outputs.
     gravity.Process();
 
-    // Read CVs and call the update function for each channel.
+    // Check if cv run or reset is active and read cv.
-    int cv1 = gravity.cv1.Read();
+    CheckRunReset(gravity.cv1, gravity.cv2);
-    int cv2 = gravity.cv2.Read();
-
-    for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
-        auto& ch = app.channel[i];
-        // Only apply CV to the channel when the current channel has cv
-        // mod configured.
-        if (ch.isCvModActive()) {
-            ch.applyCvMod(cv1, cv2);
-        }
-    }
 
     // Check for dirty state eligible to be saved.
     stateManager.update(app);
@@ -155,17 +147,41 @@ void HandleIntClockTick(uint32_t tick) {
 }
 
 void HandleExtClockTick() {
-    if (gravity.clock.InternalSource()) {
+    switch (app.selected_source) {
-        // Use EXT as Reset when internally clocked.
+        case Clock::SOURCE_INTERNAL:
+        case Clock::SOURCE_EXTERNAL_MIDI:
+            // Use EXT as Reset when not used for clock source.
             ResetOutputs();
             gravity.clock.Reset();
-    } else {
+            break;
-        // Register clock tick.
+        default:
+            // Register EXT cv clock tick.
             gravity.clock.Tick();
     }
     app.refresh_screen = true;
 }
 
+void CheckRunReset(AnalogInput& cv1, AnalogInput& cv2) {
+    // Clock Run
+    if (app.cv_run == 1 || app.cv_run == 2) {
+        const int val = (app.cv_run == 1) ? cv1.Read() : cv2.Read();
+        if (val > AnalogInput::GATE_THRESHOLD && gravity.clock.IsPaused()) {
+            gravity.clock.Start();
+            app.refresh_screen = true;
+        } else if (val < AnalogInput::GATE_THRESHOLD && !gravity.clock.IsPaused()) {
+            gravity.clock.Stop();
+            ResetOutputs();
+            app.refresh_screen = true;
+        }
+    }
+
+    // Clock Reset
+    if ((app.cv_reset == 1 && cv1.IsRisingEdge(AnalogInput::GATE_THRESHOLD)) ||
+        (app.cv_reset == 2 && cv2.IsRisingEdge(AnalogInput::GATE_THRESHOLD))) {
+        gravity.clock.Reset();
+    }
+}
+
 //
 // UI handlers for encoder and buttons.
 //
@@ -203,26 +219,21 @@ void HandleEncoderPressed() {
                 gravity.encoder.SetReverseDirection(app.encoder_reversed);
             }
             if (app.selected_param == PARAM_MAIN_SAVE_DATA) {
-                if (app.selected_sub_param < MAX_SAVE_SLOTS) {
+                if (app.selected_sub_param < StateManager::MAX_SAVE_SLOTS) {
                     app.selected_save_slot = app.selected_sub_param;
                     stateManager.saveData(app);
                 }
             }
             if (app.selected_param == PARAM_MAIN_LOAD_DATA) {
-                if (app.selected_sub_param < MAX_SAVE_SLOTS) {
+                if (app.selected_sub_param < StateManager::MAX_SAVE_SLOTS) {
                     app.selected_save_slot = app.selected_sub_param;
                     stateManager.loadData(app, app.selected_save_slot);
                     InitGravity(app);
                 }
             }
-            if (app.selected_param == PARAM_MAIN_RESET_STATE) {
-                if (app.selected_sub_param == 0) {  // Reset
-                    stateManager.reset(app);
-                    InitGravity(app);
-                }
-            }
             if (app.selected_param == PARAM_MAIN_FACTORY_RESET) {
                 if (app.selected_sub_param == 0) {  // Erase
+                    // Show bootsplash during slow erase operation.
                     Bootsplash();
                     stateManager.factoryReset(app);
                     InitGravity(app);
@@ -276,6 +287,14 @@ void editMainParameter(int val) {
             gravity.clock.SetTempo(gravity.clock.Tempo() + val);
             app.tempo = gravity.clock.Tempo();
             break;
+        case PARAM_MAIN_RUN:
+            updateSelection(app.selected_sub_param, val, 3);
+            app.cv_run = app.selected_sub_param;
+            break;
+        case PARAM_MAIN_RESET:
+            updateSelection(app.selected_sub_param, val, 3);
+            app.cv_reset = app.selected_sub_param;
+            break;
         case PARAM_MAIN_SOURCE: {
             byte source = static_cast<int>(app.selected_source);
             updateSelection(source, val, Clock::SOURCE_LAST);
@@ -292,15 +311,13 @@ void editMainParameter(int val) {
             }
             break;
         }
+        // These changes are applied upon encoder button press.
         case PARAM_MAIN_ENCODER_DIR:
             updateSelection(app.selected_sub_param, val, 2);
             break;
         case PARAM_MAIN_SAVE_DATA:
         case PARAM_MAIN_LOAD_DATA:
-            updateSelection(app.selected_sub_param, val, MAX_SAVE_SLOTS + 1);
+            updateSelection(app.selected_sub_param, val, StateManager::MAX_SAVE_SLOTS + 1);
-            break;
-        case PARAM_MAIN_RESET_STATE:
-            updateSelection(app.selected_sub_param, val, 2);
             break;
         case PARAM_MAIN_FACTORY_RESET:
             updateSelection(app.selected_sub_param, val, 2);

firmware/Gravity/app_state.h

@@ -12,24 +12,26 @@
 #ifndef APP_STATE_H
 #define APP_STATE_H
 
-#include <gravity.h>
+#include <libGravity.h>
 
 #include "channel.h"
 
 // Global state for settings and app behavior.
 struct AppState {
     int tempo = Clock::DEFAULT_TEMPO;
-    bool encoder_reversed = false;
+    Channel channel[Gravity::OUTPUT_COUNT];
-    bool refresh_screen = true;
-    bool editing_param = false;
     byte selected_param = 0;
     byte selected_sub_param = 0;  // Temporary value for editing params.
     byte selected_channel = 0;    // 0=tempo, 1-6=output channel
     byte selected_swing = 0;
     byte selected_save_slot = 0;  // The currently active save slot.
+    byte cv_run = 0;
+    byte cv_reset = 0;
     Clock::Source selected_source = Clock::SOURCE_INTERNAL;
     Clock::Pulse selected_pulse = Clock::PULSE_PPQN_24;
-    Channel channel[Gravity::OUTPUT_COUNT];
+    bool editing_param = false;
+    bool encoder_reversed = false;
+    bool refresh_screen = true;
 };
 
 extern AppState app;

firmware/Gravity/channel.h

@@ -13,7 +13,7 @@
 #define CHANNEL_H
 
 #include <Arduino.h>
-#include <gravity.h>
+#include <libGravity.h>
 
 #include "euclidean.h"
 
@@ -70,14 +70,6 @@ class Channel {
         base_duty_cycle = 50;
         base_offset = 0;
         base_swing = 50;
-        base_euc_steps = 1;
-        base_euc_hits = 1;
-
-        cvmod_clock_mod_index = base_clock_mod_index;
-        cvmod_probability = base_probability;
-        cvmod_duty_cycle = base_duty_cycle;
-        cvmod_offset = base_offset;
-        cvmod_swing = base_swing;
 
         cv1_dest = CV_DEST_NONE;
         cv2_dest = CV_DEST_NONE;
@@ -88,78 +80,100 @@ class Channel {
         _recalculatePulses();
     }
 
+    bool isCvModActive() const { return cv1_dest != CV_DEST_NONE || cv2_dest != CV_DEST_NONE; }
+
     // Setters (Set the BASE value)
 
     void setClockMod(int index) {
         base_clock_mod_index = constrain(index, 0, MOD_CHOICE_SIZE - 1);
-        if (!isCvModActive()) {
-            cvmod_clock_mod_index = base_clock_mod_index;
-            _recalculatePulses();
-        }
     }
 
     void setProbability(int prob) {
         base_probability = constrain(prob, 0, 100);
-        if (!isCvModActive()) {
-            cvmod_probability = base_probability;
-            _recalculatePulses();
-        }
     }
 
     void setDutyCycle(int duty) {
         base_duty_cycle = constrain(duty, 1, 99);
-        if (!isCvModActive()) {
-            cvmod_duty_cycle = base_duty_cycle;
-            _recalculatePulses();
-        }
     }
 
     void setOffset(int off) {
         base_offset = constrain(off, 0, 99);
-        if (!isCvModActive()) {
-            cvmod_offset = base_offset;
-            _recalculatePulses();
-        }
     }
     void setSwing(int val) {
         base_swing = constrain(val, 50, 95);
-        if (!isCvModActive()) {
-            cvmod_swing = base_swing;
-            _recalculatePulses();
-        }
     }
 
     // Euclidean
     void setSteps(int val) {
-        base_euc_steps = constrain(val, 1, MAX_PATTERN_LEN);
-        if (cv1_dest != CV_DEST_EUC_STEPS && cv2_dest != CV_DEST_EUC_STEPS) {
         pattern.SetSteps(val);
     }
-    }
     void setHits(int val) {
-        base_euc_hits = constrain(val, 1, base_euc_steps);
-        if (cv1_dest != CV_DEST_EUC_HITS && cv2_dest != CV_DEST_EUC_HITS) {
         pattern.SetHits(val);
     }
-    }
 
-    void setCv1Dest(CvDestination dest) { cv1_dest = dest; }
+    void setCv1Dest(CvDestination dest) {
-    void setCv2Dest(CvDestination dest) { cv2_dest = dest; }
+        cv1_dest = dest;
+        _recalculatePulses();
+    }
+    void setCv2Dest(CvDestination dest) {
+        cv2_dest = dest;
+        _recalculatePulses();
+    }
     CvDestination getCv1Dest() const { return cv1_dest; }
     CvDestination getCv2Dest() const { return cv2_dest; }
 
     // Getters (Get the BASE value for editing or cv modded value for display)
+    int getProbability() const { return base_probability; }
+    int getDutyCycle() const { return base_duty_cycle; }
+    int getOffset() const { return base_offset; }
+    int getSwing() const { return base_swing; }
+    int getClockMod() const { return pgm_read_word_near(&CLOCK_MOD[getClockModIndex()]); }
+    int getClockModIndex() const { return base_clock_mod_index; }
+    byte getSteps() const { return pattern.GetSteps(); }
+    byte getHits() const { return pattern.GetHits(); }
 
-    int getProbability(bool withCvMod = false) const { return withCvMod ? cvmod_probability : base_probability; }
+    // Getters that calculate the value with CV modulation applied.
-    int getDutyCycle(bool withCvMod = false) const { return withCvMod ? cvmod_duty_cycle : base_duty_cycle; }
+    int getClockModIndexWithMod(int cv1_val, int cv2_val) {
-    int getOffset(bool withCvMod = false) const { return withCvMod ? cvmod_offset : base_offset; }
+        int clock_mod_index = _calculateMod(CV_DEST_MOD, cv1_val, cv2_val, -(MOD_CHOICE_SIZE / 2), MOD_CHOICE_SIZE / 2);
-    int getSwing(bool withCvMod = false) const { return withCvMod ? cvmod_swing : base_swing; }
+        return constrain(base_clock_mod_index + clock_mod_index, 0, MOD_CHOICE_SIZE - 1);
-    int getClockMod(bool withCvMod = false) const { return pgm_read_word_near(&CLOCK_MOD[getClockModIndex(withCvMod)]); }
+    }
-    int getClockModIndex(bool withCvMod = false) const { return withCvMod ? cvmod_clock_mod_index : base_clock_mod_index; }
-    bool isCvModActive() const { return cv1_dest != CV_DEST_NONE || cv2_dest != CV_DEST_NONE; }
 
-    byte getSteps(bool withCvMod = false) const { return withCvMod ? pattern.GetSteps() : base_euc_steps; }
+    int getClockModWithMod(int cv1_val, int cv2_val) {
-    byte getHits(bool withCvMod = false) const { return withCvMod ? pattern.GetHits() : base_euc_hits; }
+        int clock_mod = _calculateMod(CV_DEST_MOD, cv1_val, cv2_val, -(MOD_CHOICE_SIZE / 2), MOD_CHOICE_SIZE / 2);
+        return pgm_read_word_near(&CLOCK_MOD[getClockModIndexWithMod(cv1_val, cv2_val)]);
+    }
+
+    int getProbabilityWithMod(int cv1_val, int cv2_val) {
+        int prob_mod = _calculateMod(CV_DEST_PROB, cv1_val, cv2_val, -50, 50);
+        return constrain(base_probability + prob_mod, 0, 100);
+    }
+
+    int getDutyCycleWithMod(int cv1_val, int cv2_val) {
+        int duty_mod = _calculateMod(CV_DEST_DUTY, cv1_val, cv2_val, -50, 50);
+        return constrain(base_duty_cycle + duty_mod, 1, 99);
+    }
+
+    int getOffsetWithMod(int cv1_val, int cv2_val) {
+        int offset_mod = _calculateMod(CV_DEST_OFFSET, cv1_val, cv2_val, -50, 50);
+        return constrain(base_offset + offset_mod, 0, 99);
+    }
+
+    int getSwingWithMod(int cv1_val, int cv2_val) {
+        int swing_mod = _calculateMod(CV_DEST_SWING, cv1_val, cv2_val, -25, 25);
+        return constrain(base_swing + swing_mod, 50, 95);
+    }
+
+    byte getStepsWithMod(int cv1_val, int cv2_val) {
+        int step_mod = _calculateMod(CV_DEST_EUC_STEPS, cv1_val, cv2_val, 0, MAX_PATTERN_LEN);
+        return constrain(pattern.GetSteps() + step_mod, 1, MAX_PATTERN_LEN);
+    }
+
+    byte getHitsWithMod(int cv1_val, int cv2_val) {
+        // The number of hits is dependent on the modulated number of steps.
+        byte modulated_steps = getStepsWithMod(cv1_val, cv2_val);
+        int hit_mod = _calculateMod(CV_DEST_EUC_HITS, cv1_val, cv2_val, 0, modulated_steps);
+        return constrain(pattern.GetHits() + hit_mod, 1, modulated_steps);
+    }
 
     void toggleMute() { mute = !mute; }
 
@@ -176,6 +190,13 @@ class Channel {
             return;
         }
 
+        if (isCvModActive()) _recalculatePulses();
+
+        int cv1 = gravity.cv1.Read();
+        int cv2 = gravity.cv2.Read();
+        int cvmod_clock_mod_index = getClockModIndexWithMod(cv1, cv2);
+        int cvmod_probability = getProbabilityWithMod(cv1, cv2);
+
         const uint16_t mod_pulses = pgm_read_word_near(&CLOCK_MOD_PULSES[cvmod_clock_mod_index]);
 
         // Conditionally apply swing on down beats.
@@ -211,56 +232,6 @@ class Channel {
             output.Low();
         }
     }
-    /**
-     * @brief Calculate and store cv modded values using bipolar mapping.
-     * Default to base value if not the current CV destination.
-     *
-     * @param cv1_val analog input reading for cv1
-     * @param cv2_val analog input reading for cv2
-     *
-     */
-    void applyCvMod(int cv1_val, int cv2_val) {
-        // Note: This is optimized for cpu performance. This method is called
-        // from the main loop and stores the cv mod values. This reduces CPU
-        // cycles inside the internal clock interrupt, which is preferrable.
-        // However, if RAM usage grows too much, we have an opportunity to
-        // refactor this to store just the CV read values, and calculate the
-        // cv mod value per channel inside the getter methods by passing cv
-        // values. This would reduce RAM usage, but would introduce a
-        // significant CPU cost, which may have undesirable performance issues.
-        if (!isCvModActive()) {
-            cvmod_clock_mod_index = base_clock_mod_index;
-            cvmod_probability = base_clock_mod_index;
-            cvmod_duty_cycle = base_clock_mod_index;
-            cvmod_offset = base_clock_mod_index;
-            cvmod_swing = base_clock_mod_index;
-            return;
-        }
-
-        int dest_mod = _calculateMod(CV_DEST_MOD, cv1_val, cv2_val, -(MOD_CHOICE_SIZE / 2), MOD_CHOICE_SIZE / 2);
-        cvmod_clock_mod_index = constrain(base_clock_mod_index + dest_mod, 0, 100);
-
-        int prob_mod = _calculateMod(CV_DEST_PROB, cv1_val, cv2_val, -50, 50);
-        cvmod_probability = constrain(base_probability + prob_mod, 0, 100);
-
-        int duty_mod = _calculateMod(CV_DEST_DUTY, cv1_val, cv2_val, -50, 50);
-        cvmod_duty_cycle = constrain(base_duty_cycle + duty_mod, 1, 99);
-
-        int offset_mod = _calculateMod(CV_DEST_OFFSET, cv1_val, cv2_val, -50, 50);
-        cvmod_offset = constrain(base_offset + offset_mod, 0, 99);
-
-        int swing_mod = _calculateMod(CV_DEST_SWING, cv1_val, cv2_val, -25, 25);
-        cvmod_swing = constrain(base_swing + swing_mod, 50, 95);
-
-        int step_mod = _calculateMod(CV_DEST_EUC_STEPS, cv1_val, cv2_val, 0, MAX_PATTERN_LEN);
-        pattern.SetSteps(base_euc_steps + step_mod);
-
-        int hit_mod = _calculateMod(CV_DEST_EUC_HITS, cv1_val, cv2_val, 0, MAX_PATTERN_LEN);
-        pattern.SetHits(base_euc_hits + hit_mod);
-
-        // After all cvmod values are updated, recalculate clock pulse modifiers.
-        _recalculatePulses();
-    }
 
    private:
     int _calculateMod(CvDestination dest, int cv1_val, int cv2_val, int min_range, int max_range) {
@@ -270,13 +241,19 @@ class Channel {
     }
 
     void _recalculatePulses() {
-        const uint16_t mod_pulses = pgm_read_word_near(&CLOCK_MOD_PULSES[cvmod_clock_mod_index]);
+        int cv1 = gravity.cv1.Read();
-        _duty_pulses = max((long)((mod_pulses * (100L - cvmod_duty_cycle)) / 100L), 1L);
+        int cv2 = gravity.cv2.Read();
-        _offset_pulses = (long)((mod_pulses * (100L - cvmod_offset)) / 100L);
+        int clock_mod_index = getClockModIndexWithMod(cv1, cv2);
+        int duty_cycle = getDutyCycleWithMod(cv1, cv2);
+        int offset = getOffsetWithMod(cv1, cv2);
+        int swing = getSwingWithMod(cv1, cv2);
+        const uint16_t mod_pulses = pgm_read_word_near(&CLOCK_MOD_PULSES[clock_mod_index]);
+        _duty_pulses = max((long)((mod_pulses * (100L - duty_cycle)) / 100L), 1L);
+        _offset_pulses = (long)((mod_pulses * (100L - offset)) / 100L);
 
         // Calculate the down beat swing amount.
-        if (cvmod_swing > 50) {
+        if (swing > 50) {
-            int shifted_swing = cvmod_swing - 50;
+            int shifted_swing = swing - 50;
             _swing_pulse_amount = (long)((mod_pulses * (100L - shifted_swing)) / 100L);
         } else {
             _swing_pulse_amount = 0;
@@ -289,15 +266,6 @@ class Channel {
     byte base_duty_cycle;
     byte base_offset;
     byte base_swing;
-    byte base_euc_steps;
-    byte base_euc_hits;
-
-    // Base value with cv mod applied.
-    byte cvmod_clock_mod_index;
-    byte cvmod_probability;
-    byte cvmod_duty_cycle;
-    byte cvmod_offset;
-    byte cvmod_swing;
 
     // CV mod configuration
     CvDestination cv1_dest;

firmware/Gravity/display.h

@@ -47,7 +47,7 @@ const uint8_t TEXT_FONT[437] U8G2_FONT_SECTION("velvetscreen") PROGMEM =
  * https://stncrn.github.io/u8g2-unifont-helper/
  * "%/0123456789ABCDEFILNORSTUVXx"
  */
-const uint8_t LARGE_FONT[766] U8G2_FONT_SECTION("stk-l") =
+const uint8_t LARGE_FONT[766] U8G2_FONT_SECTION("stk-l") PROGMEM =
     "\35\0\4\4\4\5\3\1\6\20\30\0\0\27\0\0\0\1\77\0\0\2\341%'\17;\226\261\245FL"
     "\64B\214\30\22\223\220)Bj\10Q\232\214\42R\206\310\210\21d\304\30\32a\254\304\270!\0/\14"
     "\272\272\275\311H\321g\343\306\1\60\37|\373\35CJT\20:fW\207\320\210\60\42\304\204\30D\247"
@@ -100,11 +100,12 @@ constexpr uint8_t CHANNEL_BOX_HEIGHT = 14;
 enum ParamsMainPage : uint8_t {
     PARAM_MAIN_TEMPO,
     PARAM_MAIN_SOURCE,
+    PARAM_MAIN_RUN,
+    PARAM_MAIN_RESET,
     PARAM_MAIN_PULSE,
     PARAM_MAIN_ENCODER_DIR,
     PARAM_MAIN_SAVE_DATA,
     PARAM_MAIN_LOAD_DATA,
-    PARAM_MAIN_RESET_STATE,
     PARAM_MAIN_FACTORY_RESET,
     PARAM_MAIN_LAST,
 };
@@ -123,6 +124,22 @@ enum ParamsChannelPage : uint8_t {
     PARAM_CH_LAST,
 };
 
+// Common/resused strings stored as const to save on flash memory.
+const char* const STR_24_PPQN = "24 PPQN";
+const char* const STR_4_PPQN = "4 PPQN";
+const char* const STR_1_PPQN = "1 PPQN";
+const char* const STR_CV_1 = "CV 1";
+const char* const STR_CV_2 = "CV 2";
+const char* const STR_NONE = "NONE";
+const char* const STR_EXT = "EXT";
+const char* const STR_X = "X";
+const char* const STR_DEFAULT = "DEFAULT";
+const char* const STR_REVERSED = "REVERSED";
+const char* const STR_FLIPPED = "FLIPPED";
+const char* const STR_BACK = "BACK TO MAIN";
+const char* const STR_EUC_STEPS = "EUCLID STEPS";
+const char* const STR_EUC_HITS = "EUCLID HITS";
+
 // Helper function to draw centered text
 void drawCenteredText(const char* text, int y, const uint8_t* font) {
     gravity.display.setFont(font);
@@ -214,10 +231,10 @@ void swingDivisionMark() {
 
 // Human friendly display value for save slot.
 String displaySaveSlot(int slot) {
-    if (slot >= 0 && slot < MAX_SAVE_SLOTS / 2) {
+    if (slot >= 0 && slot < StateManager::MAX_SAVE_SLOTS / 2) {
         return String("A") + String(slot + 1);
-    } else if (slot >= MAX_SAVE_SLOTS / 2 && slot <= MAX_SAVE_SLOTS) {
+    } else if (slot >= StateManager::MAX_SAVE_SLOTS / 2 && slot <= StateManager::MAX_SAVE_SLOTS) {
-        return String("B") + String(slot - (MAX_SAVE_SLOTS / 2) + 1);
+        return String("B") + String(slot - (StateManager::MAX_SAVE_SLOTS / 2) + 1);
     }
 }
 
@@ -236,30 +253,61 @@ void DisplayMainPage() {
         case PARAM_MAIN_TEMPO:
             // Serial MIDI is too unstable to display bpm in real time.
             if (app.selected_source == Clock::SOURCE_EXTERNAL_MIDI) {
-                mainText = F("EXT");
+                mainText = STR_EXT;
             } else {
                 mainText = String(gravity.clock.Tempo());
             }
             subText = F("BPM");
             break;
         case PARAM_MAIN_SOURCE:
-            mainText = F("EXT");
+            mainText = STR_EXT;
             switch (app.selected_source) {
                 case Clock::SOURCE_INTERNAL:
                     mainText = F("INT");
                     subText = F("CLOCK");
                     break;
                 case Clock::SOURCE_EXTERNAL_PPQN_24:
-                    subText = F("24 PPQN");
+                    subText = STR_24_PPQN;
                     break;
                 case Clock::SOURCE_EXTERNAL_PPQN_4:
-                    subText = F("4 PPQN");
+                    subText = STR_4_PPQN;
+                    break;
+                case Clock::SOURCE_EXTERNAL_PPQN_1:
+                    subText = STR_1_PPQN;
                     break;
                 case Clock::SOURCE_EXTERNAL_MIDI:
                     subText = F("MIDI");
                     break;
             }
             break;
+        case PARAM_MAIN_RUN:
+            mainText = F("RUN");
+            switch (app.cv_run) {
+                case 0:
+                    subText = STR_NONE;
+                    break;
+                case 1:
+                    subText = STR_CV_1;
+                    break;
+                case 2:
+                    subText = STR_CV_2;
+                    break;
+            }
+            break;
+        case PARAM_MAIN_RESET:
+            mainText = F("RST");
+            switch (app.cv_reset) {
+                case 0:
+                    subText = STR_NONE;
+                    break;
+                case 1:
+                    subText = STR_CV_1;
+                    break;
+                case 2:
+                    subText = STR_CV_2;
+                    break;
+            }
+            break;
         case PARAM_MAIN_PULSE:
             mainText = F("OUT");
             switch (app.selected_pulse) {
@@ -267,25 +315,25 @@ void DisplayMainPage() {
                     subText = F("PULSE OFF");
                     break;
                 case Clock::PULSE_PPQN_24:
-                    subText = F("24 PPQN PULSE");
+                    subText = STR_24_PPQN;
                     break;
                 case Clock::PULSE_PPQN_4:
-                    subText = F("4 PPQN PULSE");
+                    subText = STR_4_PPQN;
                     break;
                 case Clock::PULSE_PPQN_1:
-                    subText = F("1 PPQN PULSE");
+                    subText = STR_1_PPQN;
                     break;
             }
             break;
         case PARAM_MAIN_ENCODER_DIR:
             mainText = F("DIR");
-            subText = app.selected_sub_param == 0 ? F("DEFAULT") : F("REVERSED");
+            subText = app.selected_sub_param == 0 ? STR_DEFAULT : STR_REVERSED;
             break;
         case PARAM_MAIN_SAVE_DATA:
         case PARAM_MAIN_LOAD_DATA:
-            if (app.selected_sub_param == MAX_SAVE_SLOTS) {
+            if (app.selected_sub_param == StateManager::MAX_SAVE_SLOTS) {
-                mainText = F("x");
+                mainText = STR_X;
-                subText = F("BACK TO MAIN");
+                subText = STR_BACK;
             } else {
                 // Indicate currently active slot.
                 if (app.selected_sub_param == app.selected_save_slot) {
@@ -297,22 +345,13 @@ void DisplayMainPage() {
                               : F("LOAD FROM SLOT");
             }
             break;
-        case PARAM_MAIN_RESET_STATE:
-            if (app.selected_sub_param == 0) {
-                mainText = F("RST");
-                subText = F("RESET ALL");
-            } else {
-                mainText = F("x");
-                subText = F("BACK TO MAIN");
-            }
-            break;
         case PARAM_MAIN_FACTORY_RESET:
             if (app.selected_sub_param == 0) {
                 mainText = F("DEL");
                 subText = F("FACTORY RESET");
             } else {
-                mainText = F("x");
+                mainText = STR_X;
-                subText = F("BACK TO MAIN");
+                subText = STR_BACK;
             }
             break;
     }
@@ -321,7 +360,7 @@ void DisplayMainPage() {
     drawCenteredText(subText.c_str(), SUB_TEXT_Y, TEXT_FONT);
 
     // Draw Main Page menu items
-    String menu_items[PARAM_MAIN_LAST] = {F("TEMPO"), F("SOURCE"), F("PULSE OUT"), F("ENCODER DIR"), F("SAVE"), F("LOAD"), F("RESET"), F("ERASE")};
+    String menu_items[PARAM_MAIN_LAST] = {F("TEMPO"), F("SOURCE"), F("CLK RUN"), F("CLK RESET"), F("PULSE OUT"), F("ENCODER DIR"), F("SAVE"), F("LOAD"), F("ERASE")};
     drawMenuItems(menu_items, PARAM_MAIN_LAST);
 }
 
@@ -338,10 +377,12 @@ void DisplayChannelPage() {
     // When editing a param, just show the base value. When not editing show
     // the value with cv mod.
     bool withCvMod = !app.editing_param;
+    int cv1 = gravity.cv1.Read();
+    int cv2 = gravity.cv2.Read();
 
     switch (app.selected_param) {
         case PARAM_CH_MOD: {
-            int mod_value = ch.getClockMod(withCvMod);
+            int mod_value = withCvMod ? ch.getClockModWithMod(cv1, cv2): ch.getClockMod();
             if (mod_value > 1) {
                 mainText = F("/");
                 mainText += String(mod_value);
@@ -354,31 +395,31 @@ void DisplayChannelPage() {
             break;
         }
         case PARAM_CH_PROB:
-            mainText = String(ch.getProbability(withCvMod)) + F("%");
+            mainText = String(withCvMod ? ch.getProbabilityWithMod(cv1, cv2) : ch.getProbability()) + F("%");
             subText = F("HIT CHANCE");
             break;
         case PARAM_CH_DUTY:
-            mainText = String(ch.getDutyCycle(withCvMod)) + F("%");
+            mainText = String(withCvMod ? ch.getDutyCycleWithMod(cv1, cv2) : ch.getDutyCycle()) + F("%");
             subText = F("PULSE WIDTH");
             break;
         case PARAM_CH_OFFSET:
-            mainText = String(ch.getOffset(withCvMod)) + F("%");
+            mainText = String(withCvMod ? ch.getOffsetWithMod(cv1, cv2) : ch.getOffset()) + F("%");
             subText = F("SHIFT HIT");
             break;
         case PARAM_CH_SWING:
             ch.getSwing() == 50
                 ? mainText = F("OFF")
-                : mainText = String(ch.getSwing(withCvMod)) + F("%");
+                : mainText = String(withCvMod ? ch.getSwingWithMod(cv1, cv2) : ch.getSwing()) + F("%");
-            subText = "DOWN BEAT";
+            subText = F("DOWN BEAT");
             swingDivisionMark();
             break;
         case PARAM_CH_EUC_STEPS:
-            mainText = String(ch.getSteps(withCvMod));
+            mainText = String(withCvMod ? ch.getStepsWithMod(cv1, cv2) : ch.getSteps());
-            subText = "EUCLID STEPS";
+            subText = STR_EUC_STEPS;
             break;
         case PARAM_CH_EUC_HITS:
-            mainText = String(ch.getHits(withCvMod));
+            mainText = String(withCvMod ? ch.getHitsWithMod(cv1, cv2) : ch.getHits());
-            subText = "EUCLID HITS";
+            subText = STR_EUC_HITS;
             break;
         case PARAM_CH_CV1_DEST:
         case PARAM_CH_CV2_DEST: {
@@ -403,10 +444,10 @@ void DisplayChannelPage() {
                     subText = F("SWING");
                     break;
                 case CV_DEST_EUC_STEPS:
-                    subText = F("EUCLID STEPS");
+                    subText = STR_EUC_STEPS;
                     break;
                 case CV_DEST_EUC_HITS:
-                    subText = F("EUCLID HITS");
+                    subText = STR_EUC_HITS;
                     break;
             }
             break;
@@ -473,16 +514,17 @@ void Bootsplash() {
     gravity.display.firstPage();
     do {
         int textWidth;
+        String loadingText = F("LOADING....");
         gravity.display.setFont(TEXT_FONT);
 
-        textWidth = gravity.display.getStrWidth(SKETCH_NAME);
+        textWidth = gravity.display.getStrWidth(StateManager::SKETCH_NAME);
-        gravity.display.drawStr(16 + (textWidth / 2), 20, SKETCH_NAME);
+        gravity.display.drawStr(16 + (textWidth / 2), 20, StateManager::SKETCH_NAME);
 
-        textWidth = gravity.display.getStrWidth(SEMANTIC_VERSION);
+        textWidth = gravity.display.getStrWidth(StateManager::SEMANTIC_VERSION);
-        gravity.display.drawStr(16 + (textWidth / 2), 32, SEMANTIC_VERSION);
+        gravity.display.drawStr(16 + (textWidth / 2), 32, StateManager::SEMANTIC_VERSION);
 
-        textWidth = gravity.display.getStrWidth("LOADING....");
+        textWidth = gravity.display.getStrWidth(loadingText.c_str());
-        gravity.display.drawStr(26 + (textWidth / 2), 44, "LOADING....");
+        gravity.display.drawStr(26 + (textWidth / 2), 44, loadingText.c_str());
     } while (gravity.display.nextPage());
 }
 

firmware/Gravity/save_state.cpp

@@ -15,9 +15,20 @@
 
 #include "app_state.h"
 
+// Define the constants for the current firmware.
+const char StateManager::SKETCH_NAME[] = "ALT GRAVITY";
+const char StateManager::SEMANTIC_VERSION[] = "V2.0.0BETA4";  // NOTE: This should match the version in the library.properties file.
+
+// Number of available save slots.
+const byte StateManager::MAX_SAVE_SLOTS = 10;
+const byte StateManager::TRANSIENT_SLOT = 10;
+
+// Define the minimum amount of time between EEPROM writes.
+const unsigned long StateManager::SAVE_DELAY_MS = 2000;
+
 // Calculate the starting address for EepromData, leaving space for metadata.
-static const int METADATA_START_ADDR = 0;
+const int StateManager::METADATA_START_ADDR = 0;
-static const int EEPROM_DATA_START_ADDR = sizeof(StateManager::Metadata);
+const int StateManager::EEPROM_DATA_START_ADDR = sizeof(StateManager::Metadata);
 
 StateManager::StateManager() : _isDirty(false), _lastChangeTime(0) {}
 
@@ -76,6 +87,8 @@ void StateManager::reset(AppState& app) {
     app.selected_channel = default_app.selected_channel;
     app.selected_source = default_app.selected_source;
     app.selected_pulse = default_app.selected_pulse;
+    app.cv_run = default_app.cv_run;
+    app.cv_reset = default_app.cv_reset;
 
     for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
         app.channel[i].Init();
@@ -129,6 +142,8 @@ void StateManager::_saveState(const AppState& app, byte slot_index) {
     save_data.selected_channel = app.selected_channel;
     save_data.selected_source = static_cast<byte>(app.selected_source);
     save_data.selected_pulse = static_cast<byte>(app.selected_pulse);
+    save_data.cv_run = app.cv_run;
+    save_data.cv_reset = app.cv_reset;
 
     // TODO: break this out into a separate function. Save State should be
     // broken out into global / per-channel save methods. When saving via
@@ -137,13 +152,13 @@ void StateManager::_saveState(const AppState& app, byte slot_index) {
     for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
         const auto& ch = app.channel[i];
         auto& save_ch = save_data.channel_data[i];
-        save_ch.base_clock_mod_index = ch.getClockModIndex(false);
+        save_ch.base_clock_mod_index = ch.getClockModIndex();
-        save_ch.base_probability = ch.getProbability(false);
+        save_ch.base_probability = ch.getProbability();
-        save_ch.base_duty_cycle = ch.getDutyCycle(false);
+        save_ch.base_duty_cycle = ch.getDutyCycle();
-        save_ch.base_offset = ch.getOffset(false);
+        save_ch.base_offset = ch.getOffset();
-        save_ch.base_swing = ch.getSwing(false);
+        save_ch.base_swing = ch.getSwing();
-        save_ch.base_euc_steps = ch.getSteps(false);
+        save_ch.base_euc_steps = ch.getSteps();
-        save_ch.base_euc_hits = ch.getHits(false);
+        save_ch.base_euc_hits = ch.getHits();
         save_ch.cv1_dest = static_cast<byte>(ch.getCv1Dest());
         save_ch.cv2_dest = static_cast<byte>(ch.getCv2Dest());
     }
@@ -168,6 +183,8 @@ void StateManager::_loadState(AppState& app, byte slot_index) {
     app.selected_channel = load_data.selected_channel;
     app.selected_source = static_cast<Clock::Source>(load_data.selected_source);
     app.selected_pulse = static_cast<Clock::Pulse>(load_data.selected_pulse);
+    app.cv_run = load_data.cv_run;
+    app.cv_reset = load_data.cv_reset;
 
     for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
         auto& ch = app.channel[i];

firmware/Gravity/save_state.h

@@ -13,22 +13,11 @@
 #define SAVE_STATE_H
 
 #include <Arduino.h>
-#include <gravity.h>
+#include <libGravity.h>
 
 // Forward-declare AppState to avoid circular dependencies.
 struct AppState;
 
-// Define the constants for the current firmware.
-const char SKETCH_NAME[] = "ALT GRAVITY";
-const char SEMANTIC_VERSION[] = "V2.0.0BETA2";
-
-// Number of available save slots.
-const byte MAX_SAVE_SLOTS = 10;  // Count of save slots 0 - 9 to save/load  presets.
-const byte TRANSIENT_SLOT = 10;  // Transient slot index to persist state when powered off.
-
-// Define the minimum amount of time between EEPROM writes.
-static const unsigned long SAVE_DELAY_MS = 2000;
-
 /**
  * @brief Manages saving and loading of the application state to and from EEPROM.
  * The number of user slots is defined by MAX_SAVE_SLOTS, and one additional slot
@@ -39,6 +28,11 @@ static const unsigned long SAVE_DELAY_MS = 2000;
  */
 class StateManager {
    public:
+    static const char SKETCH_NAME[];
+    static const char SEMANTIC_VERSION[];
+    static const byte MAX_SAVE_SLOTS;
+    static const byte TRANSIENT_SLOT;
+
     StateManager();
 
     // Populate the AppState instance with values from EEPROM if they exist.
@@ -82,6 +76,8 @@ class StateManager {
         byte selected_channel;
         byte selected_source;
         byte selected_pulse;
+        byte cv_run;
+        byte cv_reset;
         ChannelState channel_data[Gravity::OUTPUT_COUNT];
     };
 
@@ -92,6 +88,10 @@ class StateManager {
     void _saveState(const AppState& app, byte slot_index);
     void _loadState(AppState& app, byte slot_index);
 
+    static const unsigned long SAVE_DELAY_MS;
+    static const int METADATA_START_ADDR;
+    static const int EEPROM_DATA_START_ADDR;
+
     bool _isDirty;
     unsigned long _lastChangeTime;
 };

library.properties

@@ -0,0 +1,10 @@
+name=libGravity
+version=2.0.0beta3
+author=Adam Wonak
+maintainer=awonak <github.com/awonak>
+sentence=Hardware abstraction library for Sitka Instruments Gravity eurorack module
+category=Other
+license=MIT
+url=https://github.com/awonak/libGravity
+architectures=avr
+depends=uClock,RotaryEncoder,U8g2

src/analog_input.h

@@ -19,6 +19,8 @@ const int CALIBRATED_HIGH = 512;
 
 class AnalogInput {
    public:
+    static const int GATE_THRESHOLD = 0;
+
     AnalogInput() {}
     ~AnalogInput() {}
 
@@ -74,6 +76,18 @@ class AnalogInput {
      */
     inline float Voltage() { return ((read_ / 512.0) * 5.0); }
 
+    /**
+     * Checks for a rising edge transition across a threshold.
+     *
+     * @param threshold The value that the input must cross.
+     * @return True if the value just crossed the threshold from below, false otherwise.
+     */
+    inline bool IsRisingEdge(int16_t threshold) const {
+        bool was_high = old_read_ > threshold;
+        bool is_high = read_ > threshold;
+        return is_high && !was_high;
+    }
+
    private:
     uint8_t pin_;
     int16_t read_;

src/clock.h

@@ -15,7 +15,7 @@
 #include <NeoHWSerial.h>
 
 #include "peripherials.h"
-#include "uClock.h"
+#include "uClock/uClock.h"
 
 // MIDI clock, start, stop, and continue byte definitions - based on MIDI 1.0 Standards.
 #define MIDI_CLOCK 0xF8
@@ -35,6 +35,8 @@ class Clock {
         SOURCE_INTERNAL,
         SOURCE_EXTERNAL_PPQN_24,
         SOURCE_EXTERNAL_PPQN_4,
+        SOURCE_EXTERNAL_PPQN_2,
+        SOURCE_EXTERNAL_PPQN_1,
         SOURCE_EXTERNAL_MIDI,
         SOURCE_LAST,
     };
@@ -96,6 +98,14 @@ class Clock {
                 uClock.setClockMode(uClock.EXTERNAL_CLOCK);
                 uClock.setInputPPQN(uClock.PPQN_4);
                 break;
+            case SOURCE_EXTERNAL_PPQN_2:
+                uClock.setClockMode(uClock.EXTERNAL_CLOCK);
+                uClock.setInputPPQN(uClock.PPQN_2);
+                break;
+            case SOURCE_EXTERNAL_PPQN_1:
+                uClock.setClockMode(uClock.EXTERNAL_CLOCK);
+                uClock.setInputPPQN(uClock.PPQN_1);
+                break;
             case SOURCE_EXTERNAL_MIDI:
                 uClock.setClockMode(uClock.EXTERNAL_CLOCK);
                 uClock.setInputPPQN(uClock.PPQN_24);

src/digital_output.h

@@ -82,7 +82,6 @@ class DigitalOutput {
     unsigned long last_triggered_;
     uint8_t trigger_duration_;
     uint8_t cv_pin_;
-    uint8_t led_pin_;
     bool on_;
 
     void update(uint8_t state) {

src/libGravity.cpp

@@ -1,5 +1,5 @@
 /**
- * @file gravity.cpp
+ * @file libGravity.cpp
  * @author Adam Wonak (https://github.com/awonak)
  * @brief Library for building custom scripts for the Sitka Instruments Gravity module.
  * @version 0.1
@@ -9,7 +9,7 @@
  *
  */
 
-#include "gravity.h"
+#include "libGravity.h"
 
 // Initialize the static pointer for the EncoderDir class to null. We want to
 // have a static pointer to decouple the ISR from the global gravity object.

src/libGravity.h

@@ -1,5 +1,5 @@
 /**
- * @file gravity.h
+ * @file libGravity.h
  * @author Adam Wonak (https://github.com/awonak)
  * @brief Library for building custom scripts for the Sitka Instruments Gravity module.
  * @version 0.1

src/uClock/uClock.cpp

@@ -32,7 +32,7 @@
  * DEALINGS IN THE SOFTWARE.
  */
 #include "uClock.h"
-#include "uClock/platforms/avr.h"
+#include "platforms/avr.h"
 
 //
 // Platform specific timer setup/control

uClock/uClock.h

@@ -1,180 +0,0 @@
-/*!
- *  @file       uClock.h
- *  Project     BPM clock generator for Arduino
- *  @brief      A Library to implement BPM clock tick calls using hardware interruption. Supported and tested on AVR boards(ATmega168/328, ATmega16u4/32u4 and ATmega2560) and ARM boards(RPI2040, Teensy, Seedstudio XIAO M0 and ESP32)
- *  @version    2.2.1
- *  @author     Romulo Silva
- *  @date       10/06/2017
- *  @license    MIT - (c) 2024 - Romulo Silva - contact@midilab.co
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef __U_CLOCK_H__
-#define __U_CLOCK_H__
-
-#include <Arduino.h>
-#include <inttypes.h>
-
-namespace umodular { namespace clock {
-
-#define MIN_BPM	1
-#define MAX_BPM	400
-
-#define PHASE_FACTOR 16
-#define PLL_X 220
-
-#define SECS_PER_MIN  (60UL)
-#define SECS_PER_HOUR (3600UL)
-#define SECS_PER_DAY  (SECS_PER_HOUR * 24L)
-
-class uClockClass {
-
-    public:
-        enum ClockMode {
-            INTERNAL_CLOCK = 0,
-            EXTERNAL_CLOCK
-        };
-
-        enum ClockState {
-            PAUSED = 0,
-            STARTING,
-            STARTED
-        };
-
-        enum PPQNResolution {
-            PPQN_1 = 1,
-            PPQN_2 = 2,
-            PPQN_4 = 4,
-            PPQN_8 = 8,
-            PPQN_12 = 12,
-            PPQN_24 = 24,
-            PPQN_48 = 48,
-            PPQN_96 = 96,
-            PPQN_384 = 384,
-            PPQN_480 = 480,
-            PPQN_960 = 960
-        };
-
-        ClockState clock_state;
-
-        uClockClass();
-
-        void setOnOutputPPQN(void (*callback)(uint32_t tick)) {
-            onOutputPPQNCallback = callback;
-        }
-
-        void setOnSync24(void (*callback)(uint32_t tick)) {
-            onSync24Callback = callback;
-        }
-
-        void setOnClockStart(void (*callback)()) {
-            onClockStartCallback = callback;
-        }
-
-        void setOnClockStop(void (*callback)()) {
-            onClockStopCallback = callback;
-        }
-
-        void init();
-        void setOutputPPQN(PPQNResolution resolution);
-        void setInputPPQN(PPQNResolution resolution);
-
-        void handleTimerInt();
-        void handleExternalClock();
-        void resetCounters();
-
-        // external class control
-        void start();
-        void stop();
-        void pause();
-        void setTempo(float bpm);
-        float getTempo();
-
-        // for software timer implementation(fallback for no board support)
-        void run();
-
-        // external timming control
-        void setClockMode(ClockMode tempo_mode);
-        ClockMode getClockMode();
-        void clockMe();
-        // for smooth slave tempo calculate display you should raise the
-        // buffer_size of ext_interval_buffer in between 64 to 128. 254 max size.
-        // note: this doesn't impact on sync time, only display time getTempo()
-        // if you dont want to use it, it is default set it to 1 for memory save
-        void setExtIntervalBuffer(uint8_t buffer_size);
-
-        // elapsed time support
-        uint8_t getNumberOfSeconds(uint32_t time);
-        uint8_t getNumberOfMinutes(uint32_t time);
-        uint8_t getNumberOfHours(uint32_t time);
-        uint8_t getNumberOfDays(uint32_t time);
-        uint32_t getNowTimer();
-        uint32_t getPlayTime();
-
-        uint32_t bpmToMicroSeconds(float bpm);
-
-    private:
-        float inline freqToBpm(uint32_t freq);
-        float inline constrainBpm(float bpm);
-        void calculateReferencedata();
-
-        void (*onOutputPPQNCallback)(uint32_t tick);
-        void (*onSync24Callback)(uint32_t tick);
-        void (*onClockStartCallback)();
-        void (*onClockStopCallback)();
-
-        // clock input/output control
-        PPQNResolution output_ppqn = PPQN_96;
-        PPQNResolution input_ppqn = PPQN_24;
-        // output and internal counters, ticks and references
-        uint32_t tick;
-        uint32_t int_clock_tick;
-        uint8_t mod_clock_counter;
-        uint16_t mod_clock_ref;
-
-        uint8_t mod_sync24_counter;
-        uint16_t mod_sync24_ref;
-        uint32_t sync24_tick;
-
-        // external clock control
-        volatile uint32_t ext_clock_us;
-        volatile uint32_t ext_clock_tick;
-        volatile uint32_t ext_interval;
-        uint32_t last_interval;
-        uint32_t sync_interval;
-
-        float tempo;
-        uint32_t start_timer;
-        ClockMode clock_mode;
-
-        volatile uint32_t * ext_interval_buffer = nullptr;
-        uint8_t ext_interval_buffer_size;
-        uint16_t ext_interval_idx;
-};
-
-} } // end namespace umodular::clock
-
-extern umodular::clock::uClockClass uClock;
-
-extern "C" {
-    extern volatile uint32_t _millis;
-}
-
-#endif /* __U_CLOCK_H__ */