Rollback to v2.0.0beta3 - reverting changes from v2.0.0

Reviewed-on: #28

README.md

@@ -1,18 +1,6 @@
 # Sitka Instruments Gravity Firmware Abstraction
 
-This library helps make writing firmware for the [Sitka Instruments Gravity](https://sitkainstruments.com/gravity/) eurorack module easier by abstracting away the initialization and peripheral interactions. Now your firmware code can just focus on the logic and behavior of the app, and keep the low level code neatly tucked away in this library.
-
-The latest releases of all Sitka Instruments Gravity firmware builds can be found on the [Updater](https://sitkainstruments.com/gravity/updater/) page. You can use this page to flash the latest build directly to the Arduino Nano on the back of your module.
-
-## Project Code Layout
-
-* [`src/`](src/) - **libGravity**: This is the hardware abstraction library used to simplify the creation of new Gravity module firmware by providing common reusable wrappers around the module peripherials like [DigitalOutput](src/digital_output.h#L18) providing methods like [`Update(uint8_t state)`](src/digital_output.h#L45) which allow you to set that output channel voltage high or low, and common module behavior like [Clock](src/clock.h#L30) which provides handlers like [`AttachExtHandler(callback)`](src/clock.h#L69) which takes a callback function to handle external clock tick behavior when receiving clock trigger.
-
-* [`firmware/Gravity`](firmware/Gravity/) - **Alt Gravity**: This is the implementation of the default 6-channel trigger/gate clock modulation firmware. This is a full rewrite of the original firmware designed to use `libGravity` with a focus on open source friendlines.
-
-* `firmware/GridSeq` - **GridSeq**:  Comming Soon.
-
-* [`examples/skeleton`](examples/skeleton/skeleton.ino) - **Skeleton**: This is the bare bones scaffloding for a `libGravity` firmware app.
+This library helps make writing firmware easier by abstracting away the initialization and peripheral interactions. Now your firmware code can just focus on the logic and behavior of the app, and keep the low level code neatly tucked away in this library.
 
 ## Installation
 
@@ -29,14 +17,13 @@ Common directory locations:
 * [uClock](https://github.com/midilab/uClock) [MIT] - (Included with this repo) Handle clock tempo, external clock input, and internal clock timer handler.
 * [RotateEncoder](https://github.com/mathertel/RotaryEncoder) [BSD] - Library for reading and interpreting encoder rotation.
 * [U8g2](https://github.com/olikraus/u8g2/) [MIT] - Graphics helper library.
-* [NeoHWSerial](https://github.com/SlashDevin/NeoHWSerial) [GPL] - Hardware serial library with attachInterrupt.
 
 ## Example
 
 Here's a trivial example showing some of the ways to interact with the library. This script rotates the active clock channel according to the set tempo. The encoder can change the temo or rotation direction. The play/pause button will toggle the clock activity on or off. The shift button will freeze the clock from advancing the channel rotation.
 
 ```cpp
-#include "libGravity.h"
+#include "gravity.h"
 
 byte idx = 0;
 bool reversed = false;
@@ -88,11 +75,11 @@ void HandlePlayPressed() {
     }
 }
 
-void HandleRotate(int val) {
+void HandleRotate(Direction dir, int val) {
     if (selected_param == 0) {
         gravity.clock.SetTempo(gravity.clock.Tempo() + val);
     } else if (selected_param == 1) {
-        reversed = (val < 0);
+        reversed = (dir == DIRECTION_DECREMENT);
     }
 }
 
@@ -124,14 +111,6 @@ void UpdateDisplay() {
 }
 ```
 
-**Building New Firmware Using libGravity**
-
-When starting a new firmware sketch you can use the [skeleton](examples/skeleton/skeleton.ino) app as a place to start.
-
-**Building New Firmware from scratch**
-
-If you do not want to use the libGravity hardware abstraction library and want to roll your own vanilla firmware, take a look at the [peripherials.h](src/peripherials.h) file for the pinout definitions used by the module.
-
 ### Build for release
 
 ```

examples/calibrate_analog/calibrate_analog.ino

@@ -17,7 +17,7 @@
  * TODO: Store the calibration value in EEPROM.
  */
 
-#include "libGravity.h"
+#include "gravity.h"
 
 #define TEXT_FONT u8g2_font_profont11_tf
 #define INDICATOR_FONT u8g2_font_open_iconic_arrow_1x_t
@@ -43,7 +43,7 @@ void NextCalibrationPoint() {
     selected_param = (selected_param + 1) % 6;
 }
 
-void CalibrateCV(int val) {
+void CalibrateCV(Direction dir, int val) {
     AnalogInput* cv = (selected_param > 2) ? &gravity.cv2 : &gravity.cv1;
     switch (selected_param % 3) {
         case 0:

examples/calibrate_analog2/calibrate_analog2.ino

@@ -14,7 +14,7 @@
  *
  */
 
-#include "libGravity.h"
+#include "gravity.h"
 
 #define TEXT_FONT u8g2_font_profont11_tf
 
@@ -39,7 +39,7 @@ void NextCalibrationPoint() {
     selected_param = (selected_param + 1) % 2;
 }
 
-void CalibrateCV(int val) {
+void CalibrateCV(Direction dir, int val) {
     // AnalogInput* cv = (selected_param > 2) ? &gravity.cv2 : &gravity.cv1;
     AnalogInput* cv = &gravity.cv1;
     switch (selected_param % 2) {

examples/hardware_test/hardware_test.ino

@@ -1,4 +1,4 @@
-#include "libGravity.h"
+#include "gravity.h"
 
 byte idx = 0;
 bool reversed = false;
@@ -33,28 +33,28 @@ void IntClock(uint32_t tick) {
     if (tick % 12 == 0  && ! freeze) {
         gravity.outputs[idx].Low();
         if (reversed) {
-            idx = (idx == 0) ? Gravity::OUTPUT_COUNT - 1 : idx - 1;
+            idx = (idx == 0) ? OUTPUT_COUNT - 1 : idx - 1;
         } else {
-            idx = (idx + 1) % Gravity::OUTPUT_COUNT;
+            idx = (idx + 1) % OUTPUT_COUNT;
         }
         gravity.outputs[idx].High();
     }
 }
 
 void HandlePlayPressed() {
-    gravity.clock.Stop();
+    gravity.clock.Pause();
     if (gravity.clock.IsPaused()) {
-        for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
+        for (int i = 0; i < OUTPUT_COUNT; i++) {
             gravity.outputs[i].Low();
         }
     }
 }
 
-void HandleRotate(int val) {
+void HandleRotate(Direction dir, int val) {
     if (selected_param == 0) {
         gravity.clock.SetTempo(gravity.clock.Tempo() + val);
     } else if (selected_param == 1) {
-        reversed = (val < 0);
+        reversed = (dir == DIRECTION_DECREMENT);
     }
 }
 
@@ -80,7 +80,7 @@ void UpdateDisplay() {
     gravity.display.print("Direction: ");
     gravity.display.print((reversed) ? "Backward" : "Forward");
 
-    gravity.display.drawStr(0, selected_param * 10, "x");
+    gravity.display.drawChar(0, selected_param * 10, 0x10, 1, 0, 1);
 
     gravity.display.display();
 }

examples/skeleton/skeleton.ino

@@ -1,118 +0,0 @@
-/**
- * @file skeleton.ino
- * @author YOUR_NAME (<url>)
- * @brief Skeleton app for Sitka Instruments Gravity.
- * @version vX.Y.Z - MONTH YEAR YOUR_NAME
- * @date YYYY-MM-DD
- *
- * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
- * 
- * Skeleton app for basic structure of a new firmware for Sitka Instruments
- * Gravity using the libGravity library.
- *
- * ENCODER:
- *      Press: change between selecting a parameter and editing the parameter.
- *      Hold & Rotate: change current selected output channel.
- *
- * BTN1:
- *      Play/pause - start or stop the internal clock.
- *
- * BTN2:
- *      Shift - hold and rotate encoder to change current selected output channel.
- *
- * EXT:
- *      External clock input. When Gravity is set to INTERNAL or MIDI clock
- *      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 <libGravity.h>
-
-
-
-// Global state for settings and app behavior.
-struct AppState {
-    int tempo = Clock::DEFAULT_TEMPO;
-    Clock::Source selected_source = Clock::SOURCE_INTERNAL;
-    // Add app specific state variables here.
-};
-
-AppState app;
-
-//
-// Arduino setup and loop.
-//
-
-void setup() {
-    // Start Gravity.
-    gravity.Init();
-
-    // Clock handlers.
-    gravity.clock.AttachIntHandler(HandleIntClockTick);
-    gravity.clock.AttachExtHandler(HandleExtClockTick);
-
-    // Encoder rotate and press handlers.
-    gravity.encoder.AttachPressHandler(HandleEncoderPressed);
-    gravity.encoder.AttachRotateHandler(HandleRotate);
-    gravity.encoder.AttachPressRotateHandler(HandlePressedRotate);
-
-    // Button press handlers.
-    gravity.play_button.AttachPressHandler(HandlePlayPressed);
-}
-
-void loop() {
-    // Process change in state of inputs and outputs.
-    gravity.Process();
-
-    // Non-ISR loop behavior.
-}
-
-//
-// Firmware handlers for clocks.
-//
-
-void HandleIntClockTick(uint32_t tick) {
-    bool refresh = false;
-    for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
-        // Process each output tick handlers.
-    }
-}
-
-void HandleExtClockTick() {
-    switch (app.selected_source) {
-        case Clock::SOURCE_INTERNAL:
-        case Clock::SOURCE_EXTERNAL_MIDI:
-            // Use EXT as Reset when not used for clock source.
-            gravity.clock.Reset();
-            break;
-        default:
-            // Register EXT cv clock tick.
-            gravity.clock.Tick();
-    }
-}
-
-//
-// UI handlers for encoder and buttons.
-//
-
-void HandlePlayPressed() {
-}
-
-void HandleEncoderPressed() {
-}
-
-void HandleRotate(int val) {
-}
-
-void HandlePressedRotate(int val) {
-}
-
-//
-// Application logic goes here.
-//

firmware/Euclidean/Euclidean.ino

@@ -0,0 +1,417 @@
+/**
+ * @file Gravity.ino
+ * @author Adam Wonak (https://github.com/awonak/)
+ * @brief Alt firmware version of Gravity by Sitka Instruments.
+ * @version v2.0.1beta1 - February 2026 awonak
+ * @date 2026-02-21
+ *
+ * @copyright MIT - (c) 2026 - Adam Wonak - adam.wonak@gmail.com
+ *
+ * This version of Gravity firmware is a full rewrite that leverages the
+ * libGravity hardware abstraction library. The goal of this project was to
+ * create an open source friendly version of the firmware that makes it easy
+ * for users/developers to modify and create their own original alt firmware
+ * implementations.
+ *
+ * The libGravity library represents wrappers around the
+ * hardware peripherials to make it easy to interact with and add behavior
+ * to them. The library tries not to make any assumptions about what the
+ * firmware can or should do.
+ *
+ * The Gravity firmware is a slightly different implementation of the original
+ * firmware. There are a few notable changes; the internal clock operates at
+ * 96 PPQN instead of the original 24 PPQN, which allows for more granular
+ * quantization of features like duty cycle (pulse width) or offset.
+ * Additionally, this firmware replaces the sequencer with a Euclidean Rhythm
+ * generator.
+ *
+ * ENCODER:
+ *      Press: change between selecting a parameter and editing the parameter.
+ *      Hold & Rotate: change current selected output channel.
+ *
+ * BTN1:
+ *      Play/pause - start or stop the internal clock.
+ *
+ * BTN2:
+ *      Shift - hold and rotate encoder to change current selected output
+ * channel.
+ *
+ * EXT:
+ *      External clock input. When Gravity is set to INTERNAL or MIDI clock
+ *      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 <libGravity.h>
+
+#include "app_state.h"
+#include "channel.h"
+#include "display.h"
+#include "save_state.h"
+
+AppState app;
+StateManager stateManager;
+
+//
+// Arduino setup and loop.
+//
+
+void setup() {
+  // Start Gravity.
+  gravity.Init();
+
+  // Show bootsplash when initializing firmware.
+  Bootsplash();
+  delay(2000);
+
+  // Initialize the state manager. This will load settings from EEPROM
+  stateManager.initialize(app);
+  InitGravity(app);
+
+  // Clock handlers.
+  gravity.clock.AttachIntHandler(HandleIntClockTick);
+  gravity.clock.AttachExtHandler(HandleExtClockTick);
+
+  // Encoder rotate and press handlers.
+  gravity.encoder.AttachPressHandler(HandleEncoderPressed);
+  gravity.encoder.AttachRotateHandler(HandleRotate);
+  gravity.encoder.AttachPressRotateHandler(HandlePressedRotate);
+
+  // Button press handlers.
+  gravity.play_button.AttachPressHandler(HandlePlayPressed);
+}
+
+void loop() {
+  // Process change in state of inputs and outputs.
+  gravity.Process();
+
+  // Read CVs and call the update function for each channel.
+  int cv1 = gravity.cv1.Read();
+  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);
+    }
+  }
+
+  // Clock Run
+  if (app.cv_run == 1 || app.cv_run == 2) {
+    auto &cv = app.cv_run == 1 ? gravity.cv1 : gravity.cv2;
+    int val = cv.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 &&
+       gravity.cv1.IsRisingEdge(AnalogInput::GATE_THRESHOLD)) ||
+      (app.cv_reset == 2 &&
+       gravity.cv2.IsRisingEdge(AnalogInput::GATE_THRESHOLD))) {
+    gravity.clock.Reset();
+  }
+
+  // Check for dirty state eligible to be saved.
+  stateManager.update(app);
+
+  if (app.refresh_screen) {
+    UpdateDisplay();
+  }
+}
+
+//
+// Firmware handlers for clocks.
+//
+
+void HandleIntClockTick(uint32_t tick) {
+  bool refresh = false;
+  for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
+    app.channel[i].processClockTick(tick, gravity.outputs[i]);
+
+    if (app.channel[i].isCvModActive()) {
+      refresh = true;
+    }
+  }
+
+  // Pulse Out gate
+  if (app.selected_pulse != Clock::PULSE_NONE) {
+    int clock_index;
+    switch (app.selected_pulse) {
+    case Clock::PULSE_PPQN_24:
+      clock_index = PULSE_PPQN_24_CLOCK_MOD_INDEX;
+      break;
+    case Clock::PULSE_PPQN_4:
+      clock_index = PULSE_PPQN_4_CLOCK_MOD_INDEX;
+      break;
+    case Clock::PULSE_PPQN_1:
+      clock_index = PULSE_PPQN_1_CLOCK_MOD_INDEX;
+      break;
+    }
+
+    const uint16_t pulse_high_ticks =
+        pgm_read_word_near(&CLOCK_MOD_PULSES[clock_index]);
+    const uint32_t pulse_low_ticks = tick + max((pulse_high_ticks / 2), 1L);
+
+    if (tick % pulse_high_ticks == 0) {
+      gravity.pulse.High();
+    } else if (pulse_low_ticks % pulse_high_ticks == 0) {
+      gravity.pulse.Low();
+    }
+  }
+
+  if (!app.editing_param) {
+    app.refresh_screen |= refresh;
+  }
+}
+
+void HandleExtClockTick() {
+  switch (app.selected_source) {
+  case Clock::SOURCE_INTERNAL:
+  case Clock::SOURCE_EXTERNAL_MIDI:
+    // Use EXT as Reset when not used for clock source.
+    ResetOutputs();
+    gravity.clock.Reset();
+    break;
+  default:
+    // Register EXT cv clock tick.
+    gravity.clock.Tick();
+  }
+  app.refresh_screen = true;
+}
+
+//
+// UI handlers for encoder and buttons.
+//
+
+void HandlePlayPressed() {
+  // Check if SHIFT is pressed to mute all/current channel.
+  if (gravity.shift_button.On()) {
+    if (app.selected_channel == 0) {
+      // Mute all channels
+      for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
+        app.channel[i].toggleMute();
+      }
+    } else {
+      // Mute selected channel
+      auto &ch = GetSelectedChannel();
+      ch.toggleMute();
+    }
+    return;
+  }
+
+  gravity.clock.IsPaused() ? gravity.clock.Start() : gravity.clock.Stop();
+  ResetOutputs();
+  app.refresh_screen = true;
+}
+
+void HandleEncoderPressed() {
+  // Check if leaving editing mode should apply a selection.
+  if (app.editing_param) {
+    if (app.selected_channel == 0) { // main page
+      // TODO: rewrite as switch
+      if (app.selected_param == PARAM_MAIN_ENCODER_DIR) {
+        app.encoder_reversed = app.selected_sub_param == 1;
+        gravity.encoder.SetReverseDirection(app.encoder_reversed);
+      }
+      if (app.selected_param == PARAM_MAIN_ROTATE_DISP) {
+        app.rotate_display = app.selected_sub_param == 1;
+        gravity.display.setFlipMode(app.rotate_display ? 1 : 0);
+      }
+      if (app.selected_param == PARAM_MAIN_SAVE_DATA) {
+        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 < StateManager::MAX_SAVE_SLOTS) {
+          app.selected_save_slot = app.selected_sub_param;
+          // Load pattern data into app state.
+          stateManager.loadData(app, app.selected_save_slot);
+          // Load global performance settings if they have changed.
+          if (gravity.clock.Tempo() != app.tempo) {
+            gravity.clock.SetTempo(app.tempo);
+          }
+          // Load global settings only if clock is not active.
+          if (gravity.clock.IsPaused()) {
+            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);
+        }
+      }
+    }
+    // Only mark dirty and reset selected_sub_param when leaving editing mode.
+    stateManager.markDirty();
+    app.selected_sub_param = 0;
+  }
+
+  app.editing_param = !app.editing_param;
+  app.refresh_screen = true;
+}
+
+void HandleRotate(int val) {
+  // Shift & Rotate check
+  if (gravity.shift_button.On()) {
+    HandlePressedRotate(val);
+    return;
+  }
+
+  if (!app.editing_param) {
+    // Navigation Mode
+    const int max_param =
+        (app.selected_channel == 0) ? PARAM_MAIN_LAST : PARAM_CH_LAST;
+    updateSelection(app.selected_param, val, max_param);
+  } else {
+    // Editing Mode
+    if (app.selected_channel == 0) {
+      editMainParameter(val);
+    } else {
+      editChannelParameter(val);
+    }
+  }
+  app.refresh_screen = true;
+}
+
+void HandlePressedRotate(int val) {
+  updateSelection(app.selected_channel, val, Gravity::OUTPUT_COUNT + 1);
+  app.selected_param = 0;
+  stateManager.markDirty();
+  app.refresh_screen = true;
+}
+
+void editMainParameter(int val) {
+  switch (static_cast<ParamsMainPage>(app.selected_param)) {
+  case PARAM_MAIN_TEMPO:
+    if (gravity.clock.ExternalSource()) {
+      break;
+    }
+    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);
+    app.selected_source = static_cast<Clock::Source>(source);
+    gravity.clock.SetSource(app.selected_source);
+    break;
+  }
+  case PARAM_MAIN_PULSE: {
+    byte pulse = static_cast<int>(app.selected_pulse);
+    updateSelection(pulse, val, Clock::PULSE_LAST);
+    app.selected_pulse = static_cast<Clock::Pulse>(pulse);
+    if (app.selected_pulse == Clock::PULSE_NONE) {
+      gravity.pulse.Low();
+    }
+    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_ROTATE_DISP:
+    updateSelection(app.selected_sub_param, val, 2);
+    break;
+  case PARAM_MAIN_SAVE_DATA:
+  case PARAM_MAIN_LOAD_DATA:
+    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);
+    break;
+  }
+}
+
+void editChannelParameter(int val) {
+  auto &ch = GetSelectedChannel();
+  switch (app.selected_param) {
+  case PARAM_CH_MOD:
+    ch.setClockMod(ch.getClockModIndex() + val);
+    break;
+  case PARAM_CH_EUC_STEPS:
+    ch.setSteps(ch.getSteps() + val);
+    break;
+  case PARAM_CH_EUC_HITS:
+    ch.setHits(ch.getHits() + val);
+    break;
+  case PARAM_CH_CV1_DEST: {
+    byte dest = static_cast<int>(ch.getCv1Dest());
+    updateSelection(dest, val, CV_DEST_LAST);
+    ch.setCv1Dest(static_cast<CvDestination>(dest));
+    break;
+  }
+  case PARAM_CH_CV2_DEST: {
+    byte dest = static_cast<int>(ch.getCv2Dest());
+    updateSelection(dest, val, CV_DEST_LAST);
+    ch.setCv2Dest(static_cast<CvDestination>(dest));
+    break;
+  }
+  }
+}
+
+// Changes the param by the value provided.
+void updateSelection(byte &param, int change, int maxValue) {
+  // Do not apply acceleration if max value is less than 25.
+  if (maxValue < 25) {
+    change = change > 0 ? 1 : -1;
+  }
+  param = constrain(param + change, 0, maxValue - 1);
+}
+
+//
+// App Helper functions.
+//
+
+void InitGravity(AppState &app) {
+  gravity.clock.SetTempo(app.tempo);
+  gravity.clock.SetSource(app.selected_source);
+  gravity.encoder.SetReverseDirection(app.encoder_reversed);
+  gravity.display.setFlipMode(app.rotate_display ? 1 : 0);
+}
+
+void ResetOutputs() {
+  for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
+    gravity.outputs[i].Low();
+  }
+}

firmware/Euclidean/app_state.h

@@ -0,0 +1,44 @@
+/**
+ * @file app_state.h
+ * @author Adam Wonak (https://github.com/awonak/)
+ * @brief Alt firmware version of Gravity by Sitka Instruments.
+ * @version 2.0.1
+ * @date 2025-07-04
+ *
+ * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
+ *
+ */
+
+#ifndef APP_STATE_H
+#define APP_STATE_H
+
+#include <libGravity.h>
+
+#include "channel.h"
+
+// Global state for settings and app behavior.
+struct AppState {
+  int tempo = Clock::DEFAULT_TEMPO;
+  Channel channel[Gravity::OUTPUT_COUNT];
+  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.
+  Clock::Source selected_source = Clock::SOURCE_INTERNAL;
+  Clock::Pulse selected_pulse = Clock::PULSE_PPQN_24;
+  byte cv_run = 0;
+  byte cv_reset = 0;
+  bool editing_param = false;
+  bool encoder_reversed = false;
+  bool rotate_display = false;
+  bool refresh_screen = true;
+};
+
+extern AppState app;
+
+static Channel &GetSelectedChannel() {
+  return app.channel[app.selected_channel - 1];
+}
+
+#endif // APP_STATE_H

firmware/Euclidean/channel.h

@@ -0,0 +1,247 @@
+/**
+ * @file channel.h
+ * @author Adam Wonak (https://github.com/awonak/)
+ * @brief Alt firmware version of Gravity by Sitka Instruments.
+ * @version 2.0.1
+ * @date 2025-07-04
+ *
+ * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
+ *
+ */
+
+#ifndef CHANNEL_H
+#define CHANNEL_H
+
+#include <Arduino.h>
+#include <libGravity.h>
+
+#include "euclidean.h"
+
+// Enums for CV Mod destination
+enum CvDestination : uint8_t {
+  CV_DEST_NONE,
+  CV_DEST_MOD,
+  CV_DEST_EUC_STEPS,
+  CV_DEST_EUC_HITS,
+  CV_DEST_LAST,
+};
+
+static const byte MOD_CHOICE_SIZE = 25;
+
+// Negative numbers are multipliers, positive are divisors.
+static const int CLOCK_MOD[MOD_CHOICE_SIZE] PROGMEM = {
+    // Divisors
+    128, 64, 32, 24, 16, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2,
+    // Internal Clock Unity (quarter note)
+    1,
+    // Multipliers
+    -2, -3, -4, -6, -8, -12, -16, -24};
+
+// This represents the number of clock pulses for a 96 PPQN clock source
+// that match the above div/mult mods.
+static const int CLOCK_MOD_PULSES[MOD_CHOICE_SIZE] PROGMEM = {
+    // Divisor Pulses (96 * X)
+    12288, 6144, 3072, 2304, 1536, 1152, 1056, 960, 864, 768, 672, 576, 480,
+    384, 288, 192,
+    // Internal Clock Pulses
+    96,
+    // Multiplier Pulses (96 / X)
+    48, 32, 24, 16, 12, 8, 6, 4};
+
+static const byte DEFAULT_CLOCK_MOD_INDEX = 16; // x1 or 96 PPQN.
+
+static const byte PULSE_PPQN_24_CLOCK_MOD_INDEX = MOD_CHOICE_SIZE - 1;
+static const byte PULSE_PPQN_4_CLOCK_MOD_INDEX = MOD_CHOICE_SIZE - 6;
+static const byte PULSE_PPQN_1_CLOCK_MOD_INDEX = MOD_CHOICE_SIZE - 9;
+
+class Channel {
+public:
+  Channel() { Init(); }
+
+  void Init() {
+    // Reset base values to their defaults
+    base_clock_mod_index = DEFAULT_CLOCK_MOD_INDEX;
+    base_euc_steps = 1;
+    base_euc_hits = 1;
+
+    cvmod_clock_mod_index = base_clock_mod_index;
+
+    cv1_dest = CV_DEST_NONE;
+    cv2_dest = CV_DEST_NONE;
+
+    pattern.Init(DEFAULT_PATTERN);
+
+    // Calcule the clock mod pulses on init.
+    _recalculatePulses();
+  }
+
+  // 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();
+    }
+  }
+
+  // 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 setCv2Dest(CvDestination dest) { cv2_dest = dest; }
+  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 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;
+  }
+  byte getHits(bool withCvMod = false) const {
+    return withCvMod ? pattern.GetHits() : base_euc_hits;
+  }
+
+  void toggleMute() { mute = !mute; }
+
+  /**
+   * @brief Processes a clock tick and determines if the output should be high
+   * or low. Note: this method is called from an ISR and must be kept as simple
+   * as possible.
+   * @param tick The current clock tick count.
+   * @param output The output object to be modified.
+   */
+  void processClockTick(uint32_t tick, DigitalOutput &output) {
+    // Mute check
+    if (mute) {
+      output.Low();
+      return;
+    }
+
+    const uint16_t mod_pulses =
+        pgm_read_word_near(&CLOCK_MOD_PULSES[cvmod_clock_mod_index]);
+
+    // Euclidian rhythm cycle check
+    if (!output.On()) {
+      // Step check
+      if (tick % mod_pulses == 0) {
+        bool hit = true;
+        // Euclidean rhythm hit check
+        switch (pattern.NextStep()) {
+        case Pattern::REST:
+          hit = false;
+          break;
+        case Pattern::HIT:
+          hit &= true;
+          break;
+        }
+        if (hit) {
+          output.High();
+        }
+      }
+    }
+
+    // Output low check. Half pulse width.
+    const uint32_t duty_cycle_end_tick = tick + _duty_pulses;
+    if (duty_cycle_end_tick % mod_pulses == 0) {
+      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;
+      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 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,
+                                pattern.GetSteps());
+    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) {
+    int mod1 =
+        (cv1_dest == dest) ? map(cv1_val, -512, 512, min_range, max_range) : 0;
+    int mod2 =
+        (cv2_dest == dest) ? map(cv2_val, -512, 512, min_range, max_range) : 0;
+    return mod1 + mod2;
+  }
+
+  void _recalculatePulses() {
+    const uint16_t mod_pulses =
+        pgm_read_word_near(&CLOCK_MOD_PULSES[cvmod_clock_mod_index]);
+    _duty_pulses = max((long)(mod_pulses / 2L), 1L);
+  }
+
+  // User-settable base values.
+  byte base_clock_mod_index;
+  byte base_euc_steps;
+  byte base_euc_hits;
+
+  // Base value with cv mod applied.
+  byte cvmod_clock_mod_index;
+
+  // CV mod configuration
+  CvDestination cv1_dest;
+  CvDestination cv2_dest;
+
+  // Euclidean pattern
+  Pattern pattern;
+
+  // Mute channel flag
+  bool mute;
+
+  // Pre-calculated pulse values for ISR performance
+  uint16_t _duty_pulses;
+};
+
+#endif // CHANNEL_H

firmware/Euclidean/display.h

@@ -0,0 +1,519 @@
+/**
+ * @file display.h
+ * @author Adam Wonak (https://github.com/awonak/)
+ * @brief Alt firmware version of Gravity by Sitka Instruments.
+ * @version 2.0.1
+ * @date 2025-07-04
+ *
+ * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
+ *
+ */
+
+#ifndef DISPLAY_H
+#define DISPLAY_H
+
+#include <Arduino.h>
+
+#include "app_state.h"
+#include "save_state.h"
+
+//
+// UI Display functions for drawing the UI to the OLED display.
+//
+
+/*
+ * Font: velvetscreen.bdf 9pt
+ * https://stncrn.github.io/u8g2-unifont-helper/
+ * "%/0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ */
+const uint8_t TEXT_FONT[437] U8G2_FONT_SECTION("velvetscreen") PROGMEM =
+    "\64\0\2\2\3\3\2\3\4\5\5\0\0\5\0\5\0\0\221\0\0\1\230 \4\200\134%\11\255tT"
+    "R\271RI(\6\252\334T\31)\7\252\134bJ\12+\7\233\345\322J\0,\5\221T\4-\5\213"
+    "f\6.\5\211T\2/"
+    "\6\244\354c\33\60\10\254\354T\64\223\2\61\7\353\354\222\254\6\62\11\254l"
+    "\66J*"
+    "\217\0\63\11\254l\66J\32\215\4\64\10\254l\242\34\272\0\65\11\254l\206\336h"
+    "$\0\66"
+    "\11\254\354T^\61)\0\67\10\254lF\216u\4\70\11\254\354TL*&"
+    "\5\71\11\254\354TL;"
+    ")\0:\6\231UR\0A\10\254\354T\34S\6B\11\254lV\34)\216\4C\11\254\354T\324\61"
+    ")\0D\10\254lV\64G\2E\10\254l\206\36z\4F\10\254l\206^\71\3G\11\254\354TN"
+    "\63)"
+    "\0H\10\254l\242\34S\6I\6\251T\206\0J\10\254\354k\231\24\0K\11\254l\242J\62"
+    "\225\1L\7\254lr{\4M\11\255t\362ZI\353\0N\11\255t\362TI\356\0O\10\254\354T"
+    "\64\223\2P\11\254lV\34)"
+    "g\0Q\10\254\354T\264b\12R\10\254lV\34\251\31S\11\254\354"
+    "FF\32\215\4T\7\253dVl\1U\10\254l\242\63)\0V\11\255t\262Ne\312\21W\12\255"
+    "t\262J*\251.\0X\11\254l\242L*\312\0Y\12\255tr\252\63\312(\2Z\7\253df*"
+    "\7p\10\255\364V\266\323\2q\7\255\364\216\257\5r\10\253d\242\32*"
+    "\2t\6\255t\376#w\11"
+    "\255\364V\245FN\13x\6\233dR\7\0\0\0\4\377\377\0";
+
+/*
+ * Font: STK-L.bdf 36pt
+ * https://stncrn.github.io/u8g2-unifont-helper/
+ * "%/0123456789ABCDEFILNORSTUVXx"
+ */
+const uint8_t LARGE_FONT[766] U8G2_FONT_SECTION("stk-l") =
+    "\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"
+    "\214\331\354\20\11%"
+    "\212\314\0\61\24z\275\245a\244\12\231\71\63b\214\220q\363\377(E\6\62\33|"
+    "\373\35ShT\20:fl\344\14\211\231\301\306T\71\202#g\371\340\201\1\63\34|"
+    "\373\35ShT"
+    "\20:fl\344@r\264\263\222\344,\215\35\42\241\6\225\31\0\64 "
+    "|\373-!\203\206\214!\62\204"
+    "\314\220A#\10\215\30\65b\324\210Q\306\354\354\1\213\225\363\1\65\32|"
+    "\373\15\25[\214\234/\10)"
+    "Y\61j\350\310Y\32;DB\15*\63\0\66\33}\33\236SiV\14;gt^\230Y\302\202\324"
+    "\71\273;EbM\252\63\0\67\23|\373\205\25\17R\316\207\344\350p\312\201#"
+    "\347\35\0\70 |\373"
+    "\35ShT\20:f\331!\22D\310 "
+    ":\205\206\10\11B\307\354\354\20\11\65\250\314\0\71\32|\373"
+    "\35ShT\20:fg\207H,Q\223r\276\30DB\15*\63\0A\26}\33\246r\247\322P\62"
+    "j\310\250\21\343\354\335\203\357\354w\3B$}"
+    "\33\206Dj\226\214\42\61l\304\260\21\303F\14\33\61"
+    "\212\304\222MF\221\30v\316\236=\10\301b\11\0C\27}"
+    "\33\236Si\226\20Bft\376O\211\215"
+    " Db\215\42$\0D\33}\33\206Dj\226\214\32\62l\304\260\21\343\354\177vl\304("
+    "\22K\324"
+    "$\2E\22|\373\205\17R\316KD\30\215\234_>x`\0F\20|"
+    "\373\205\17R\316\227i\262\31"
+    "\71\377\22\0I\7s\333\204\77HL\15{\333\205\201\363\377\77|\360`\0N$}"
+    "\33\6\201\346\314"
+    "\35;\206\12U\242D&\306\230\30cd\210\221!fF\230\31a(+\314\256\63\67\0O\26}"
+    "\33"
+    "\236Si\226\214\32\61\316\376\277\33\61j\310\232Tg\0R\61\216;\6Ek\230\14#"
+    "\61n\304\270"
+    "\21\343F\214\33\61n\304\60\22\243\210\60Q\224j\310\260\61\243\306\20\232"
+    "\325\230QD\206\221\30\67b"
+    "\334\301\1S\42\216;\236c\211\226\220\42\61n\304\270\21c\307R\232,["
+    "\262\203\307\216\65h\16\25"
+    "\21&\253\320\0T\15}\33\206\17R\15\235\377\377\25\0U\21|"
+    "\373\205a\366\377\237\215\30\64D\15"
+    "*\63\0V\26\177\371\205\221\366\377\313\21\343\206\220\42C\25\11r'"
+    "\313\16\3X)~;\206\201\6"
+    "\217\221\30\66\204\20\31\42\244\206\14Cg\320$Q\222\6\315!"
+    "\33\62\212\10\31BD\206\215 v\320"
+    "\302\1x\24\312\272\205A\206\216\220@c\212\224\31$"
+    "S\14\262h\0\0\0\0\4\377\377\0";
+
+#define play_icon_width 14
+#define play_icon_height 14
+static const unsigned char play_icon[28] PROGMEM = {
+    0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x7C, 0x00, 0xFC, 0x00,
+    0xFC, 0x03, 0xFC, 0x0F, 0xFC, 0x0F, 0xFC, 0x03, 0xFC, 0x00,
+    0x7C, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00};
+static const unsigned char pause_icon[28] PROGMEM = {
+    0x00, 0x00, 0x00, 0x00, 0x38, 0x0E, 0x38, 0x0E, 0x38, 0x0E,
+    0x38, 0x0E, 0x38, 0x0E, 0x38, 0x0E, 0x38, 0x0E, 0x38, 0x0E,
+    0x38, 0x0E, 0x38, 0x0E, 0x38, 0x0E, 0x00, 0x00};
+
+// Constants for screen layout and fonts
+constexpr uint8_t SCREEN_CENTER_X = 32;
+constexpr uint8_t MAIN_TEXT_Y = 26;
+constexpr uint8_t SUB_TEXT_Y = 40;
+constexpr uint8_t VISIBLE_MENU_ITEMS = 3;
+constexpr uint8_t MENU_ITEM_HEIGHT = 14;
+constexpr uint8_t MENU_BOX_PADDING = 4;
+constexpr uint8_t MENU_BOX_WIDTH = 64;
+constexpr uint8_t CHANNEL_BOXES_Y = 50;
+constexpr uint8_t CHANNEL_BOX_WIDTH = 18;
+constexpr uint8_t CHANNEL_BOX_HEIGHT = 14;
+
+// Menu items for editing global parameters.
+enum ParamsMainPage : uint8_t {
+  PARAM_MAIN_TEMPO,
+  PARAM_MAIN_RUN,
+  PARAM_MAIN_RESET,
+  PARAM_MAIN_SOURCE,
+  PARAM_MAIN_PULSE,
+  PARAM_MAIN_ENCODER_DIR,
+  PARAM_MAIN_ROTATE_DISP,
+  PARAM_MAIN_SAVE_DATA,
+  PARAM_MAIN_LOAD_DATA,
+  PARAM_MAIN_RESET_STATE,
+  PARAM_MAIN_FACTORY_RESET,
+  PARAM_MAIN_LAST,
+};
+
+// Menu items for editing channel parameters.
+enum ParamsChannelPage : uint8_t {
+  PARAM_CH_MOD,
+  PARAM_CH_EUC_STEPS,
+  PARAM_CH_EUC_HITS,
+  PARAM_CH_CV1_DEST,
+  PARAM_CH_CV2_DEST,
+  PARAM_CH_LAST,
+};
+
+// Helper function to draw centered text
+void drawCenteredText(const char *text, int y, const uint8_t *font) {
+  gravity.display.setFont(font);
+  int textWidth = gravity.display.getStrWidth(text);
+  gravity.display.drawStr(SCREEN_CENTER_X - (textWidth / 2), y, text);
+}
+
+// Helper function to draw right-aligned text
+void drawRightAlignedText(const char *text, int y) {
+  int textWidth = gravity.display.getStrWidth(text);
+  int drawX = (SCREEN_WIDTH - textWidth) - MENU_BOX_PADDING;
+  gravity.display.drawStr(drawX, y, text);
+}
+
+void drawMainSelection() {
+  gravity.display.setDrawColor(1);
+  const int tickSize = 3;
+  const int mainWidth = SCREEN_WIDTH / 2;
+  const int mainHeight = 49;
+  gravity.display.drawLine(0, 0, tickSize, 0);
+  gravity.display.drawLine(0, 0, 0, tickSize);
+  gravity.display.drawLine(mainWidth, 0, mainWidth - tickSize, 0);
+  gravity.display.drawLine(mainWidth, 0, mainWidth, tickSize);
+  gravity.display.drawLine(mainWidth, mainHeight, mainWidth,
+                           mainHeight - tickSize);
+  gravity.display.drawLine(mainWidth, mainHeight, mainWidth - tickSize,
+                           mainHeight);
+  gravity.display.drawLine(0, mainHeight, tickSize, mainHeight);
+  gravity.display.drawLine(0, mainHeight, 0, mainHeight - tickSize);
+  gravity.display.setDrawColor(2);
+}
+
+void drawMenuItems(String menu_items[], int menu_size) {
+  // Draw menu items
+  gravity.display.setFont(TEXT_FONT);
+
+  // Draw selected menu item box
+  int selectedBoxY = 0;
+  if (menu_size >= VISIBLE_MENU_ITEMS && app.selected_param == menu_size - 1) {
+    selectedBoxY = MENU_ITEM_HEIGHT * min(2, app.selected_param);
+  } else if (app.selected_param > 0) {
+    selectedBoxY = MENU_ITEM_HEIGHT;
+  }
+
+  int boxX = MENU_BOX_WIDTH + 1;
+  int boxY = selectedBoxY + 2;
+  int boxWidth = MENU_BOX_WIDTH - 1;
+  int boxHeight = MENU_ITEM_HEIGHT + 1;
+
+  if (app.editing_param) {
+    gravity.display.drawBox(boxX, boxY, boxWidth, boxHeight);
+    drawMainSelection();
+  } else {
+    gravity.display.drawFrame(boxX, boxY, boxWidth, boxHeight);
+  }
+
+  // Draw the visible menu items
+  int start_index = 0;
+  if (menu_size >= VISIBLE_MENU_ITEMS && app.selected_param == menu_size - 1) {
+    start_index = menu_size - VISIBLE_MENU_ITEMS;
+  } else if (app.selected_param > 0) {
+    start_index = app.selected_param - 1;
+  }
+
+  for (int i = 0; i < min(menu_size, VISIBLE_MENU_ITEMS); ++i) {
+    int idx = start_index + i;
+    drawRightAlignedText(menu_items[idx].c_str(),
+                         MENU_ITEM_HEIGHT * (i + 1) - 1);
+  }
+}
+
+// Visual indicators for main section of screen.
+inline void solidTick() { gravity.display.drawBox(56, 4, 4, 4); }
+inline void hollowTick() { gravity.display.drawBox(56, 4, 4, 4); }
+
+// Human friendly display value for save slot.
+String displaySaveSlot(int slot) {
+  if (slot >= 0 && slot < StateManager::MAX_SAVE_SLOTS / 2) {
+    return String("A") + String(slot + 1);
+  } else if (slot >= StateManager::MAX_SAVE_SLOTS / 2 &&
+             slot <= StateManager::MAX_SAVE_SLOTS) {
+    return String("B") + String(slot - (StateManager::MAX_SAVE_SLOTS / 2) + 1);
+  }
+}
+
+// Main display functions
+
+void DisplayMainPage() {
+  gravity.display.setFontMode(1);
+  gravity.display.setDrawColor(2);
+  gravity.display.setFont(TEXT_FONT);
+
+  // Display selected editable value
+  String mainText;
+  String subText;
+
+  switch (app.selected_param) {
+  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");
+    } else {
+      mainText = String(gravity.clock.Tempo());
+    }
+    subText = F("BPM");
+    break;
+  case PARAM_MAIN_RUN:
+    mainText = F("RUN");
+    switch (app.cv_run) {
+    case 0:
+      subText = F("NONE");
+      break;
+    case 1:
+      subText = F("CV1 GATE");
+      break;
+    case 2:
+      subText = F("CV2 GATE");
+      break;
+    }
+    break;
+  case PARAM_MAIN_RESET:
+    mainText = F("RST");
+    switch (app.cv_reset) {
+    case 0:
+      subText = F("NONE");
+      break;
+    case 1:
+      subText = F("CV1 TRIG");
+      break;
+    case 2:
+      subText = F("CV2 TRIG");
+      break;
+    }
+    break;
+  case PARAM_MAIN_SOURCE:
+    mainText = F("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");
+      break;
+    case Clock::SOURCE_EXTERNAL_PPQN_4:
+      subText = F("4 PPQN");
+      break;
+    case Clock::SOURCE_EXTERNAL_PPQN_2:
+      subText = F("2 PPQN");
+      break;
+    case Clock::SOURCE_EXTERNAL_PPQN_1:
+      subText = F("1 PPQN");
+      break;
+    case Clock::SOURCE_EXTERNAL_MIDI:
+      subText = F("MIDI");
+      break;
+    }
+    break;
+  case PARAM_MAIN_PULSE:
+    mainText = F("OUT");
+    switch (app.selected_pulse) {
+    case Clock::PULSE_NONE:
+      subText = F("PULSE OFF");
+      break;
+    case Clock::PULSE_PPQN_24:
+      subText = F("24 PPQN PULSE");
+      break;
+    case Clock::PULSE_PPQN_4:
+      subText = F("4 PPQN PULSE");
+      break;
+    case Clock::PULSE_PPQN_1:
+      subText = F("1 PPQN PULSE");
+      break;
+    }
+    break;
+  case PARAM_MAIN_ENCODER_DIR:
+    mainText = F("DIR");
+    subText = app.selected_sub_param == 0 ? F("DEFAULT") : F("REVERSED");
+    break;
+  case PARAM_MAIN_ROTATE_DISP:
+    mainText = F("DISP");
+    subText = app.selected_sub_param == 0 ? F("DEFAULT") : F("ROTATED");
+    break;
+  case PARAM_MAIN_SAVE_DATA:
+  case PARAM_MAIN_LOAD_DATA:
+    if (app.selected_sub_param == StateManager::MAX_SAVE_SLOTS) {
+      mainText = F("x");
+      subText = F("BACK TO MAIN");
+    } else {
+      // Indicate currently active slot.
+      if (app.selected_sub_param == app.selected_save_slot) {
+        solidTick();
+      }
+      mainText = displaySaveSlot(app.selected_sub_param);
+      subText = (app.selected_param == PARAM_MAIN_SAVE_DATA)
+                    ? F("SAVE TO SLOT")
+                    : 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");
+      subText = F("BACK TO MAIN");
+    }
+    break;
+  }
+
+  drawCenteredText(mainText.c_str(), MAIN_TEXT_Y, LARGE_FONT);
+  drawCenteredText(subText.c_str(), SUB_TEXT_Y, TEXT_FONT);
+
+  // Draw Main Page menu items
+  String menu_items[PARAM_MAIN_LAST] = {
+      F("TEMPO"),     F("RUN"),         F("RST"),         F("SOURCE"),
+      F("PULSE OUT"), F("ENCODER DIR"), F("ROTATE DISP"), F("SAVE"),
+      F("LOAD"),      F("RESET"),       F("ERASE")};
+  drawMenuItems(menu_items, PARAM_MAIN_LAST);
+}
+
+void DisplayChannelPage() {
+  auto &ch = GetSelectedChannel();
+
+  gravity.display.setFontMode(1);
+  gravity.display.setDrawColor(2);
+
+  // Display selected editable value
+  String mainText;
+  String subText;
+
+  // When editing a param, just show the base value. When not editing show
+  // the value with cv mod.
+  bool withCvMod = !app.editing_param;
+
+  switch (app.selected_param) {
+  case PARAM_CH_MOD: {
+    int mod_value = ch.getClockMod(withCvMod);
+    if (mod_value > 1) {
+      mainText = F("/");
+      mainText += String(mod_value);
+      subText = F("DIVIDE");
+    } else {
+      mainText = F("x");
+      mainText += String(abs(mod_value));
+      subText = F("MULTIPLY");
+    }
+    break;
+  }
+
+  case PARAM_CH_EUC_STEPS:
+    mainText = String(ch.getSteps(withCvMod));
+    subText = "EUCLID STEPS";
+    break;
+  case PARAM_CH_EUC_HITS:
+    mainText = String(ch.getHits(withCvMod));
+    subText = "EUCLID HITS";
+    break;
+  case PARAM_CH_CV1_DEST:
+  case PARAM_CH_CV2_DEST: {
+    mainText = (app.selected_param == PARAM_CH_CV1_DEST) ? F("CV1") : F("CV2");
+    switch ((app.selected_param == PARAM_CH_CV1_DEST) ? ch.getCv1Dest()
+                                                      : ch.getCv2Dest()) {
+    case CV_DEST_NONE:
+      subText = F("NONE");
+      break;
+    case CV_DEST_MOD:
+      subText = F("CLOCK MOD");
+      break;
+
+    case CV_DEST_EUC_STEPS:
+      subText = F("EUCLID STEPS");
+      break;
+    case CV_DEST_EUC_HITS:
+      subText = F("EUCLID HITS");
+      break;
+    }
+    break;
+  }
+  }
+
+  drawCenteredText(mainText.c_str(), MAIN_TEXT_Y, LARGE_FONT);
+  drawCenteredText(subText.c_str(), SUB_TEXT_Y, TEXT_FONT);
+
+  // Draw Channel Page menu items
+  String menu_items[PARAM_CH_LAST] = {F("MOD"), F("EUCLID STEPS"),
+                                      F("EUCLID HITS"), F("CV1 MOD"),
+                                      F("CV2 MOD")};
+  drawMenuItems(menu_items, PARAM_CH_LAST);
+}
+
+void DisplaySelectedChannel() {
+  int boxX = CHANNEL_BOX_WIDTH;
+  int boxY = CHANNEL_BOXES_Y;
+  int boxWidth = CHANNEL_BOX_WIDTH;
+  int boxHeight = CHANNEL_BOX_HEIGHT;
+  int textOffset = 7; // Half of font width
+
+  // Draw top and right side of frame.
+  gravity.display.drawHLine(1, boxY, SCREEN_WIDTH - 2);
+  gravity.display.drawVLine(SCREEN_WIDTH - 2, boxY, boxHeight);
+
+  for (int i = 0; i < Gravity::OUTPUT_COUNT + 1; i++) {
+    // Draw box frame or filled selected box.
+    gravity.display.setDrawColor(1);
+    (app.selected_channel == i)
+        ? gravity.display.drawBox(i * boxWidth, boxY, boxWidth, boxHeight)
+        : gravity.display.drawVLine(i * boxWidth, boxY, boxHeight);
+
+    // Draw clock status icon or each channel number.
+    gravity.display.setDrawColor(2);
+    if (i == 0) {
+      gravity.display.setBitmapMode(1);
+      auto icon = gravity.clock.IsPaused() ? pause_icon : play_icon;
+      gravity.display.drawXBMP(2, boxY, play_icon_width, play_icon_height,
+                               icon);
+    } else {
+      gravity.display.setFont(TEXT_FONT);
+      gravity.display.setCursor((i * boxWidth) + textOffset, SCREEN_HEIGHT - 3);
+      gravity.display.print(i);
+    }
+  }
+}
+
+void UpdateDisplay() {
+  app.refresh_screen = false;
+  gravity.display.firstPage();
+  do {
+    if (app.selected_channel == 0) {
+      DisplayMainPage();
+    } else {
+      DisplayChannelPage();
+    }
+    // Global channel select UI.
+    DisplaySelectedChannel();
+  } while (gravity.display.nextPage());
+}
+
+void Bootsplash() {
+  gravity.display.firstPage();
+  do {
+    int textWidth;
+    String loadingText = F("LOADING....");
+    gravity.display.setFont(TEXT_FONT);
+
+    textWidth = gravity.display.getStrWidth(StateManager::SKETCH_NAME);
+    gravity.display.drawStr(4 + (textWidth / 2), 22, StateManager::SKETCH_NAME);
+
+    textWidth = gravity.display.getStrWidth(StateManager::SEMANTIC_VERSION);
+    gravity.display.drawStr(16 + (textWidth / 2), 32,
+                            StateManager::SEMANTIC_VERSION);
+
+    textWidth = gravity.display.getStrWidth(loadingText.c_str());
+    gravity.display.drawStr(26 + (textWidth / 2), 44, loadingText.c_str());
+  } while (gravity.display.nextPage());
+}
+
+#endif // DISPLAY_H

firmware/Euclidean/save_state.cpp

@@ -0,0 +1,237 @@
+/**
+ * @file save_state.cpp
+ * @author Adam Wonak (https://github.com/awonak/)
+ * @brief Alt firmware version of Gravity by Sitka Instruments.
+ * @version 2.0.1
+ * @date 2025-07-04
+ *
+ * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
+ *
+ */
+
+#include "save_state.h"
+
+#include <EEPROM.h>
+
+#include "app_state.h"
+
+// Define the constants for the current firmware.
+const char StateManager::SKETCH_NAME[] = "ALT EUCLIDEAN";
+const char StateManager::SEMANTIC_VERSION[] =
+    "V2.0.1BETA1"; // 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.
+const int StateManager::METADATA_START_ADDR = 0;
+const int StateManager::EEPROM_DATA_START_ADDR = sizeof(StateManager::Metadata);
+
+StateManager::StateManager() : _isDirty(false), _lastChangeTime(0) {}
+
+bool StateManager::initialize(AppState &app) {
+  noInterrupts();
+  bool success = false;
+  if (_isDataValid()) {
+    // Load global settings.
+    _loadMetadata(app);
+    // Load app data from the transient slot.
+    _loadState(app, TRANSIENT_SLOT);
+    success = true;
+  }
+  // EEPROM does not contain save data for this firmware & version.
+  else {
+    // Erase EEPROM and initialize state. Save default pattern to all save
+    // slots.
+    factoryReset(app);
+  }
+  interrupts();
+  return success;
+}
+
+bool StateManager::loadData(AppState &app, byte slot_index) {
+  // Check if slot_index is within max range + 1 for transient.
+  if (slot_index >= MAX_SAVE_SLOTS + 1)
+    return false;
+
+  noInterrupts();
+
+  // Load the state data from the specified EEPROM slot and update the app state
+  // save slot.
+  _loadState(app, slot_index);
+  app.selected_save_slot = slot_index;
+  // Persist this change in the global metadata on next update.
+  _isDirty = true;
+
+  interrupts();
+  return true;
+}
+
+// Save app state to user specified save slot.
+void StateManager::saveData(const AppState &app) {
+  noInterrupts();
+  // Check if slot_index is within max range + 1 for transient.
+  if (app.selected_save_slot >= MAX_SAVE_SLOTS + 1) {
+    interrupts();
+    return;
+  }
+
+  _saveState(app, app.selected_save_slot);
+  _saveMetadata(app);
+  _isDirty = false;
+  interrupts();
+}
+
+// Save transient state if it has changed and enough time has passed since last
+// save.
+void StateManager::update(const AppState &app) {
+  if (_isDirty && (millis() - _lastChangeTime > SAVE_DELAY_MS)) {
+    noInterrupts();
+    _saveState(app, TRANSIENT_SLOT);
+    _saveMetadata(app);
+    _isDirty = false;
+    interrupts();
+  }
+}
+
+void StateManager::reset(AppState &app) {
+  noInterrupts();
+
+  AppState default_app;
+  app.tempo = default_app.tempo;
+  app.selected_param = default_app.selected_param;
+  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();
+  }
+
+  // Load global settings from Metadata
+  _loadMetadata(app);
+
+  _isDirty = false;
+  interrupts();
+}
+
+void StateManager::markDirty() {
+  _isDirty = true;
+  _lastChangeTime = millis();
+}
+
+// Erases all data in the EEPROM by writing 0 to every address.
+void StateManager::factoryReset(AppState &app) {
+  noInterrupts();
+  for (unsigned int i = 0; i < EEPROM.length(); i++) {
+    EEPROM.write(i, 0);
+  }
+  // Initialize eeprom and save default patter to all save slots.
+  _saveMetadata(app);
+  reset(app);
+  for (int i = 0; i < MAX_SAVE_SLOTS; i++) {
+    app.selected_save_slot = i;
+    _saveState(app, i);
+  }
+  _saveState(app, TRANSIENT_SLOT);
+  interrupts();
+}
+
+bool StateManager::_isDataValid() {
+  Metadata metadata;
+  EEPROM.get(METADATA_START_ADDR, metadata);
+  bool name_match = (strcmp(metadata.sketch_name, SKETCH_NAME) == 0);
+  bool version_match = (strcmp(metadata.version, SEMANTIC_VERSION) == 0);
+  return name_match && version_match;
+}
+
+void StateManager::_saveState(const AppState &app, byte slot_index) {
+  // Check if slot_index is within max range + 1 for transient.
+  if (app.selected_save_slot >= MAX_SAVE_SLOTS + 1)
+    return;
+
+  static EepromData save_data;
+
+  save_data.tempo = app.tempo;
+  save_data.selected_param = app.selected_param;
+  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
+  // "update" only save state for the current channel since other channels
+  // will not have changed when saving user edits.
+  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_euc_steps = ch.getSteps(false);
+    save_ch.base_euc_hits = ch.getHits(false);
+    save_ch.cv1_dest = static_cast<byte>(ch.getCv1Dest());
+    save_ch.cv2_dest = static_cast<byte>(ch.getCv2Dest());
+  }
+
+  int address = EEPROM_DATA_START_ADDR + (slot_index * sizeof(EepromData));
+  EEPROM.put(address, save_data);
+}
+
+void StateManager::_loadState(AppState &app, byte slot_index) {
+  // Check if slot_index is within max range + 1 for transient.
+  if (slot_index >= MAX_SAVE_SLOTS + 1)
+    return;
+
+  static EepromData load_data;
+  int address = EEPROM_DATA_START_ADDR + (slot_index * sizeof(EepromData));
+  EEPROM.get(address, load_data);
+
+  // Restore app state from loaded data.
+  app.tempo = load_data.tempo;
+  app.selected_param = load_data.selected_param;
+  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];
+    const auto &saved_ch_state = load_data.channel_data[i];
+
+    ch.setClockMod(saved_ch_state.base_clock_mod_index);
+    ch.setSteps(saved_ch_state.base_euc_steps);
+    ch.setHits(saved_ch_state.base_euc_hits);
+    ch.setCv1Dest(static_cast<CvDestination>(saved_ch_state.cv1_dest));
+    ch.setCv2Dest(static_cast<CvDestination>(saved_ch_state.cv2_dest));
+  }
+}
+
+void StateManager::_saveMetadata(const AppState &app) {
+  Metadata current_meta;
+  strcpy(current_meta.sketch_name, SKETCH_NAME);
+  strcpy(current_meta.version, SEMANTIC_VERSION);
+
+  // Global user settings
+  current_meta.selected_save_slot = app.selected_save_slot;
+  current_meta.encoder_reversed = app.encoder_reversed;
+  current_meta.rotate_display = app.rotate_display;
+
+  EEPROM.put(METADATA_START_ADDR, current_meta);
+}
+
+void StateManager::_loadMetadata(AppState &app) {
+  Metadata metadata;
+  EEPROM.get(METADATA_START_ADDR, metadata);
+  app.selected_save_slot = metadata.selected_save_slot;
+  app.encoder_reversed = metadata.encoder_reversed;
+  app.rotate_display = metadata.rotate_display;
+}

firmware/Euclidean/save_state.h

@@ -0,0 +1,96 @@
+/**
+ * @file save_state.h
+ * @author Adam Wonak (https://github.com/awonak/)
+ * @brief Alt firmware version of Gravity by Sitka Instruments.
+ * @version 2.0.1
+ * @date 2025-07-04
+ *
+ * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
+ *
+ */
+
+#ifndef SAVE_STATE_H
+#define SAVE_STATE_H
+
+#include <Arduino.h>
+#include <libGravity.h>
+
+// Forward-declare AppState to avoid circular dependencies.
+struct AppState;
+
+/**
+ * @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 is reseved for transient state to persist state between power
+ * cycles before state is explicitly saved to a user slot. Metadata is stored in
+ * the beginning of the memory space which stores firmware version information
+ * to validate that the data can be loaded into the current version of AppState.
+ */
+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.
+  bool initialize(AppState &app);
+  // Load data from specified slot.
+  bool loadData(AppState &app, byte slot_index);
+  // Save data to specified slot.
+  void saveData(const AppState &app);
+  // Reset AppState instance back to default values.
+  void reset(AppState &app);
+  // Call from main loop, check if state has changed and needs to be saved.
+  void update(const AppState &app);
+  // Indicate that state has changed and we should save.
+  void markDirty();
+  // Erase all data stored in the EEPROM.
+  void factoryReset(AppState &app);
+
+  // This struct holds the data that identifies the firmware version.
+  struct Metadata {
+    char sketch_name[16];
+    char version[16];
+    // Additional global/hardware settings
+    byte selected_save_slot;
+    bool encoder_reversed;
+    bool rotate_display;
+  };
+  struct ChannelState {
+    byte base_clock_mod_index;
+    byte base_euc_steps;
+    byte base_euc_hits;
+    byte cv1_dest; // Cast the CvDestination enum as a byte for storage
+    byte cv2_dest; // Cast the CvDestination enum as a byte for storage
+  };
+  // This struct holds all the parameters we want to save.
+  struct EepromData {
+    int tempo;
+    byte selected_param;
+    byte selected_channel;
+    byte selected_source;
+    byte selected_pulse;
+    byte cv_run;
+    byte cv_reset;
+    ChannelState channel_data[Gravity::OUTPUT_COUNT];
+  };
+
+private:
+  bool _isDataValid();
+  void _saveMetadata(const AppState &app);
+  void _loadMetadata(AppState &app);
+  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;
+};
+
+#endif // SAVE_STATE_H

firmware/Gravity/Gravity.ino

@@ -2,11 +2,10 @@
  * @file Gravity.ino
  * @author Adam Wonak (https://github.com/awonak/)
  * @brief Alt firmware version of Gravity by Sitka Instruments.
- * @version v2.0.0 - June 2025 awonak - Full rewrite
- * @version v1.0 - August 2023 Oleksiy H - Initial release
- * @date 2025-07-04
+ * @version v2.0.1beta1 - February 2026 awonak
+ * @date 2026-02-21
  *
- * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
+ * @copyright MIT - (c) 2026 - Adam Wonak - adam.wonak@gmail.com
  *
  * This version of Gravity firmware is a full rewrite that leverages the
  * libGravity hardware abstraction library. The goal of this project was to
@@ -34,17 +33,20 @@
  *      Play/pause - start or stop the internal clock.
  *
  * BTN2:
- *      Shift - hold and rotate encoder to change current selected output channel.
+ *      Shift - hold and rotate encoder to change current selected output
+ * channel.
  *
  * EXT:
  *      External clock input. When Gravity is set to INTERNAL or MIDI clock
  *      source, this input is used to reset clocks.
  *
  * CV1:
- *      External analog input used to provide modulation to any channel parameter.
+ *      External analog input used to provide modulation to any channel
+ * parameter.
  *
  * CV2:
- *      External analog input used to provide modulation to any channel parameter.
+ *      External analog input used to provide modulation to any channel
+ * parameter.
  *
  */
 
@@ -66,6 +68,10 @@ void setup() {
   // Start Gravity.
   gravity.Init();
 
+  // Show bootsplash when initializing firmware.
+  Bootsplash();
+  delay(2000);
+
   // Initialize the state manager. This will load settings from EEPROM
   stateManager.initialize(app);
   InitGravity(app);
@@ -87,8 +93,40 @@ void loop() {
   // Process change in state of inputs and outputs.
   gravity.Process();
 
-    // Check if cv run or reset is active and read cv.
-    CheckRunReset(gravity.cv1, gravity.cv2);
+  // Read CVs and call the update function for each channel.
+  int cv1 = gravity.cv1.Read();
+  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);
+    }
+  }
+
+  // Clock Run
+  if (app.cv_run == 1 || app.cv_run == 2) {
+    auto &cv = app.cv_run == 1 ? gravity.cv1 : gravity.cv2;
+    int val = cv.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 &&
+       gravity.cv1.IsRisingEdge(AnalogInput::GATE_THRESHOLD)) ||
+      (app.cv_reset == 2 &&
+       gravity.cv2.IsRisingEdge(AnalogInput::GATE_THRESHOLD))) {
+    gravity.clock.Reset();
+  }
 
   // Check for dirty state eligible to be saved.
   stateManager.update(app);
@@ -127,7 +165,8 @@ void HandleIntClockTick(uint32_t tick) {
       break;
     }
 
-        const uint16_t pulse_high_ticks = pgm_read_word_near(&CLOCK_MOD_PULSES[clock_index]);
+    const uint16_t pulse_high_ticks =
+        pgm_read_word_near(&CLOCK_MOD_PULSES[clock_index]);
     const uint32_t pulse_low_ticks = tick + max((pulse_high_ticks / 2), 1L);
 
     if (tick % pulse_high_ticks == 0) {
@@ -157,27 +196,6 @@ void HandleExtClockTick() {
   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.
 //
@@ -192,15 +210,13 @@ void HandlePlayPressed() {
       }
     } else {
       // Mute selected channel
-            auto& ch = GetSelectedChannel();
+      auto &ch = GetSelectedChannel();
       ch.toggleMute();
     }
     return;
   }
 
-    gravity.clock.IsPaused()
-        ? gravity.clock.Start()
-        : gravity.clock.Stop();
+  gravity.clock.IsPaused() ? gravity.clock.Start() : gravity.clock.Stop();
   ResetOutputs();
   app.refresh_screen = true;
 }
@@ -209,34 +225,49 @@ void HandleEncoderPressed() {
   // Check if leaving editing mode should apply a selection.
   if (app.editing_param) {
     if (app.selected_channel == 0) { // main page
-            switch (app.selected_param) {
-                case PARAM_MAIN_ENCODER_DIR:
+      // TODO: rewrite as switch
+      if (app.selected_param == PARAM_MAIN_ENCODER_DIR) {
         app.encoder_reversed = app.selected_sub_param == 1;
         gravity.encoder.SetReverseDirection(app.encoder_reversed);
-                    break;
-                case PARAM_MAIN_ROTATE_DISP:
+      }
+      if (app.selected_param == PARAM_MAIN_ROTATE_DISP) {
         app.rotate_display = app.selected_sub_param == 1;
         gravity.display.setFlipMode(app.rotate_display ? 1 : 0);
-                    break;
-                case PARAM_MAIN_SAVE_DATA:
+      }
+      if (app.selected_param == PARAM_MAIN_SAVE_DATA) {
         if (app.selected_sub_param < StateManager::MAX_SAVE_SLOTS) {
           app.selected_save_slot = app.selected_sub_param;
           stateManager.saveData(app);
         }
-                    break;
-                case PARAM_MAIN_LOAD_DATA:
+      }
+      if (app.selected_param == PARAM_MAIN_LOAD_DATA) {
         if (app.selected_sub_param < StateManager::MAX_SAVE_SLOTS) {
           app.selected_save_slot = app.selected_sub_param;
+          // Load pattern data into app state.
           stateManager.loadData(app, app.selected_save_slot);
+          // Load global performance settings if they have changed.
+          if (gravity.clock.Tempo() != app.tempo) {
+            gravity.clock.SetTempo(app.tempo);
+          }
+          // Load global settings only if clock is not active.
+          if (gravity.clock.IsPaused()) {
             InitGravity(app);
           }
-                    break;
-                case PARAM_MAIN_FACTORY_RESET:
+        }
+      }
+      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);
         }
-                    break;
       }
     }
     // Only mark dirty and reset selected_sub_param when leaving editing mode.
@@ -257,7 +288,8 @@ void HandleRotate(int val) {
 
   if (!app.editing_param) {
     // Navigation Mode
-        const int max_param = (app.selected_channel == 0) ? PARAM_MAIN_LAST : PARAM_CH_LAST;
+    const int max_param =
+        (app.selected_channel == 0) ? PARAM_MAIN_LAST : PARAM_CH_LAST;
     updateSelection(app.selected_param, val, max_param);
   } else {
     // Editing Mode
@@ -312,12 +344,18 @@ void editMainParameter(int val) {
   }
   // These changes are applied upon encoder button press.
   case PARAM_MAIN_ENCODER_DIR:
+    updateSelection(app.selected_sub_param, val, 2);
+    break;
   case PARAM_MAIN_ROTATE_DISP:
     updateSelection(app.selected_sub_param, val, 2);
     break;
   case PARAM_MAIN_SAVE_DATA:
   case PARAM_MAIN_LOAD_DATA:
-            updateSelection(app.selected_sub_param, val, StateManager::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);
@@ -326,7 +364,7 @@ void editMainParameter(int val) {
 }
 
 void editChannelParameter(int val) {
-    auto& ch = GetSelectedChannel();
+  auto &ch = GetSelectedChannel();
   switch (app.selected_param) {
   case PARAM_CH_MOD:
     ch.setClockMod(ch.getClockModIndex() + val);
@@ -343,12 +381,6 @@ void editChannelParameter(int val) {
   case PARAM_CH_SWING:
     ch.setSwing(ch.getSwing() + val);
     break;
-        case PARAM_CH_EUC_STEPS:
-            ch.setSteps(ch.getSteps() + val);
-            break;
-        case PARAM_CH_EUC_HITS:
-            ch.setHits(ch.getHits() + val);
-            break;
   case PARAM_CH_CV1_DEST: {
     byte dest = static_cast<int>(ch.getCv1Dest());
     updateSelection(dest, val, CV_DEST_LAST);
@@ -365,7 +397,7 @@ void editChannelParameter(int val) {
 }
 
 // Changes the param by the value provided.
-void updateSelection(byte& param, int change, int maxValue) {
+void updateSelection(byte &param, int change, int maxValue) {
   // Do not apply acceleration if max value is less than 25.
   if (maxValue < 25) {
     change = change > 0 ? 1 : -1;
@@ -377,7 +409,7 @@ void updateSelection(byte& param, int change, int maxValue) {
 // App Helper functions.
 //
 
-void InitGravity(AppState& app) {
+void InitGravity(AppState &app) {
   gravity.clock.SetTempo(app.tempo);
   gravity.clock.SetSource(app.selected_source);
   gravity.encoder.SetReverseDirection(app.encoder_reversed);

firmware/Gravity/app_state.h

@@ -37,7 +37,7 @@ struct AppState {
 
 extern AppState app;
 
-static Channel& GetSelectedChannel() {
+static Channel &GetSelectedChannel() {
   return app.channel[app.selected_channel - 1];
 }
 

firmware/Gravity/channel.h

@@ -15,8 +15,6 @@
 #include <Arduino.h>
 #include <libGravity.h>
 
-#include "euclidean.h"
-
 // Enums for CV Mod destination
 enum CvDestination : uint8_t {
   CV_DEST_NONE,
@@ -25,8 +23,6 @@ enum CvDestination : uint8_t {
   CV_DEST_DUTY,
   CV_DEST_OFFSET,
   CV_DEST_SWING,
-    CV_DEST_EUC_STEPS,
-    CV_DEST_EUC_HITS,
   CV_DEST_LAST,
 };
 
@@ -45,7 +41,8 @@ static const int CLOCK_MOD[MOD_CHOICE_SIZE] PROGMEM = {
 // that match the above div/mult mods.
 static const int CLOCK_MOD_PULSES[MOD_CHOICE_SIZE] PROGMEM = {
     // Divisor Pulses (96 * X)
-    12288, 6144, 3072, 2304, 1536, 1152, 1056, 960, 864, 768, 672, 576, 480, 384, 288, 192,
+    12288, 6144, 3072, 2304, 1536, 1152, 1056, 960, 864, 768, 672, 576, 480,
+    384, 288, 192,
     // Internal Clock Pulses
     96,
     // Multiplier Pulses (96 / X)
@@ -58,10 +55,8 @@ static const byte PULSE_PPQN_4_CLOCK_MOD_INDEX = MOD_CHOICE_SIZE - 6;
 static const byte PULSE_PPQN_1_CLOCK_MOD_INDEX = MOD_CHOICE_SIZE - 9;
 
 class Channel {
-   public:
-    Channel() {
-        Init();
-    }
+public:
+  Channel() { Init(); }
 
   void Init() {
     // Reset base values to their defaults
@@ -71,137 +66,107 @@ class Channel {
     base_offset = 0;
     base_swing = 50;
 
+    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;
 
-        pattern.Init(DEFAULT_PATTERN);
-
     // Calcule the clock mod pulses on init.
     _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) {
-        pattern.SetSteps(val);
-    }
-    void setHits(int val) {
-        pattern.SetHits(val);
-    }
-
-    void setCv1Dest(CvDestination dest) {
-        cv1_dest = dest;
-        _recalculatePulses();
-    }
-    void setCv2Dest(CvDestination dest) {
-        cv2_dest = dest;
-        _recalculatePulses();
-    }
+  void setCv1Dest(CvDestination dest) { cv1_dest = dest; }
+  void setCv2Dest(CvDestination dest) { cv2_dest = dest; }
   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(); }
 
-    // Getters that calculate the value with CV modulation applied.
-    int getClockModIndexWithMod(int cv1_val, int cv2_val) {
-        int clock_mod_index = _calculateMod(CV_DEST_MOD, cv1_val, cv2_val, -(MOD_CHOICE_SIZE / 2), MOD_CHOICE_SIZE / 2);
-        return constrain(base_clock_mod_index + clock_mod_index, 0, MOD_CHOICE_SIZE - 1);
+  int getProbability(bool withCvMod = false) const {
+    return withCvMod ? cvmod_probability : base_probability;
   }
-
-    int getClockModWithMod(int cv1_val, int cv2_val) {
-        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 getDutyCycle(bool withCvMod = false) const {
+    return withCvMod ? cvmod_duty_cycle : base_duty_cycle;
   }
-
-    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 getOffset(bool withCvMod = false) const {
+    return withCvMod ? cvmod_offset : base_offset;
   }
-
-    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 getSwing(bool withCvMod = false) const {
+    return withCvMod ? cvmod_swing : base_swing;
   }
-
-    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 getClockMod(bool withCvMod = false) const {
+    return pgm_read_word_near(&CLOCK_MOD[getClockModIndex(withCvMod)]);
   }
-
-    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);
+  int getClockModIndex(bool withCvMod = false) const {
+    return withCvMod ? cvmod_clock_mod_index : base_clock_mod_index;
   }
-
-    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);
+  bool isCvModActive() const {
+    return cv1_dest != CV_DEST_NONE || cv2_dest != CV_DEST_NONE;
   }
 
   void toggleMute() { mute = !mute; }
 
   /**
-     * @brief Processes a clock tick and determines if the output should be high or low.
-     * Note: this method is called from an ISR and must be kept as simple as possible.
+   * @brief Processes a clock tick and determines if the output should be high
+   * or low. Note: this method is called from an ISR and must be kept as simple
+   * as possible.
    * @param tick The current clock tick count.
    * @param output The output object to be modified.
    */
-    void processClockTick(uint32_t tick, DigitalOutput& output) {
+  void processClockTick(uint32_t tick, DigitalOutput &output) {
     // Mute check
     if (mute) {
       output.Low();
       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]);
+    const uint16_t mod_pulses =
+        pgm_read_word_near(&CLOCK_MOD_PULSES[cvmod_clock_mod_index]);
 
     // Conditionally apply swing on down beats.
     uint16_t swing_pulses = 0;
@@ -215,15 +180,6 @@ class Channel {
       // Step check
       if (current_tick_offset % mod_pulses == 0) {
         bool hit = cvmod_probability >= random(0, 100);
-                // Euclidean rhythm hit check
-                switch (pattern.NextStep()) {
-                    case Pattern::REST:  // Rest when active or fall back to probability
-                        hit = false;
-                        break;
-                    case Pattern::HIT:  // Hit if probability is true
-                        hit &= true;
-                        break;
-                }
         if (hit) {
           output.High();
         }
@@ -231,34 +187,80 @@ class Channel {
     }
 
     // Duty cycle low check
-        const uint32_t duty_cycle_end_tick = tick + _duty_pulses + _offset_pulses + swing_pulses;
+    const uint32_t duty_cycle_end_tick =
+        tick + _duty_pulses + _offset_pulses + swing_pulses;
     if (duty_cycle_end_tick % mod_pulses == 0) {
       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;
+    }
 
-   private:
-    int _calculateMod(CvDestination dest, int cv1_val, int cv2_val, int min_range, int max_range) {
-        int mod1 = (cv1_dest == dest) ? map(cv1_val, -512, 512, min_range, max_range) : 0;
-        int mod2 = (cv2_dest == dest) ? map(cv2_val, -512, 512, min_range, max_range) : 0;
+    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);
+
+    // 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) {
+    int mod1 =
+        (cv1_dest == dest) ? map(cv1_val, -512, 512, min_range, max_range) : 0;
+    int mod2 =
+        (cv2_dest == dest) ? map(cv2_val, -512, 512, min_range, max_range) : 0;
     return mod1 + mod2;
   }
 
   void _recalculatePulses() {
-        int cv1 = gravity.cv1.Read();
-        int cv2 = gravity.cv2.Read();
-        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);
+    const uint16_t mod_pulses =
+        pgm_read_word_near(&CLOCK_MOD_PULSES[cvmod_clock_mod_index]);
+    _duty_pulses =
+        max((long)((mod_pulses * (100L - cvmod_duty_cycle)) / 100L), 1L);
+    _offset_pulses = (long)((mod_pulses * (100L - cvmod_offset)) / 100L);
 
     // Calculate the down beat swing amount.
-        if (swing > 50) {
-            int shifted_swing = swing - 50;
-            _swing_pulse_amount = (long)((mod_pulses * (100L - shifted_swing)) / 100L);
+    if (cvmod_swing > 50) {
+      int shifted_swing = cvmod_swing - 50;
+      _swing_pulse_amount =
+          (long)((mod_pulses * (100L - shifted_swing)) / 100L);
     } else {
       _swing_pulse_amount = 0;
     }
@@ -271,13 +273,17 @@ class Channel {
   byte base_offset;
   byte base_swing;
 
+  // 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;
   CvDestination cv2_dest;
 
-    // Euclidean pattern
-    Pattern pattern;
-
   // Mute channel flag
   bool mute;
 

firmware/Gravity/display.h

@@ -29,17 +29,24 @@
 const uint8_t TEXT_FONT[437] U8G2_FONT_SECTION("velvetscreen") PROGMEM =
     "\64\0\2\2\3\3\2\3\4\5\5\0\0\5\0\5\0\0\221\0\0\1\230 \4\200\134%\11\255tT"
     "R\271RI(\6\252\334T\31)\7\252\134bJ\12+\7\233\345\322J\0,\5\221T\4-\5\213"
-    "f\6.\5\211T\2/\6\244\354c\33\60\10\254\354T\64\223\2\61\7\353\354\222\254\6\62\11\254l"
-    "\66J*\217\0\63\11\254l\66J\32\215\4\64\10\254l\242\34\272\0\65\11\254l\206\336h$\0\66"
-    "\11\254\354T^\61)\0\67\10\254lF\216u\4\70\11\254\354TL*&\5\71\11\254\354TL;"
+    "f\6.\5\211T\2/"
+    "\6\244\354c\33\60\10\254\354T\64\223\2\61\7\353\354\222\254\6\62\11\254l"
+    "\66J*"
+    "\217\0\63\11\254l\66J\32\215\4\64\10\254l\242\34\272\0\65\11\254l\206\336h"
+    "$\0\66"
+    "\11\254\354T^\61)\0\67\10\254lF\216u\4\70\11\254\354TL*&"
+    "\5\71\11\254\354TL;"
     ")\0:\6\231UR\0A\10\254\354T\34S\6B\11\254lV\34)\216\4C\11\254\354T\324\61"
     ")\0D\10\254lV\64G\2E\10\254l\206\36z\4F\10\254l\206^\71\3G\11\254\354TN"
-    "\63)\0H\10\254l\242\34S\6I\6\251T\206\0J\10\254\354k\231\24\0K\11\254l\242J\62"
+    "\63)"
+    "\0H\10\254l\242\34S\6I\6\251T\206\0J\10\254\354k\231\24\0K\11\254l\242J\62"
     "\225\1L\7\254lr{\4M\11\255t\362ZI\353\0N\11\255t\362TI\356\0O\10\254\354T"
-    "\64\223\2P\11\254lV\34)g\0Q\10\254\354T\264b\12R\10\254lV\34\251\31S\11\254\354"
+    "\64\223\2P\11\254lV\34)"
+    "g\0Q\10\254\354T\264b\12R\10\254lV\34\251\31S\11\254\354"
     "FF\32\215\4T\7\253dVl\1U\10\254l\242\63)\0V\11\255t\262Ne\312\21W\12\255"
     "t\262J*\251.\0X\11\254l\242L*\312\0Y\12\255tr\252\63\312(\2Z\7\253df*"
-    "\7p\10\255\364V\266\323\2q\7\255\364\216\257\5r\10\253d\242\32*\2t\6\255t\376#w\11"
+    "\7p\10\255\364V\266\323\2q\7\255\364\216\257\5r\10\253d\242\32*"
+    "\2t\6\255t\376#w\11"
     "\255\364V\245FN\13x\6\233dR\7\0\0\0\4\377\377\0";
 
 /*
@@ -47,42 +54,63 @@ 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") PROGMEM =
+const uint8_t LARGE_FONT[766] U8G2_FONT_SECTION("stk-l") =
     "\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"
-    "\214\331\354\20\11%\212\314\0\61\24z\275\245a\244\12\231\71\63b\214\220q\363\377(E\6\62\33|"
-    "\373\35ShT\20:fl\344\14\211\231\301\306T\71\202#g\371\340\201\1\63\34|\373\35ShT"
-    "\20:fl\344@r\264\263\222\344,\215\35\42\241\6\225\31\0\64 |\373-!\203\206\214!\62\204"
-    "\314\220A#\10\215\30\65b\324\210Q\306\354\354\1\213\225\363\1\65\32|\373\15\25[\214\234/\10)"
+    "\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"
+    "\214\331\354\20\11%"
+    "\212\314\0\61\24z\275\245a\244\12\231\71\63b\214\220q\363\377(E\6\62\33|"
+    "\373\35ShT\20:fl\344\14\211\231\301\306T\71\202#g\371\340\201\1\63\34|"
+    "\373\35ShT"
+    "\20:fl\344@r\264\263\222\344,\215\35\42\241\6\225\31\0\64 "
+    "|\373-!\203\206\214!\62\204"
+    "\314\220A#\10\215\30\65b\324\210Q\306\354\354\1\213\225\363\1\65\32|"
+    "\373\15\25[\214\234/\10)"
     "Y\61j\350\310Y\32;DB\15*\63\0\66\33}\33\236SiV\14;gt^\230Y\302\202\324"
-    "\71\273;EbM\252\63\0\67\23|\373\205\25\17R\316\207\344\350p\312\201#\347\35\0\70 |\373"
-    "\35ShT\20:f\331!\22D\310 :\205\206\10\11B\307\354\354\20\11\65\250\314\0\71\32|\373"
+    "\71\273;EbM\252\63\0\67\23|\373\205\25\17R\316\207\344\350p\312\201#"
+    "\347\35\0\70 |\373"
+    "\35ShT\20:f\331!\22D\310 "
+    ":\205\206\10\11B\307\354\354\20\11\65\250\314\0\71\32|\373"
     "\35ShT\20:fg\207H,Q\223r\276\30DB\15*\63\0A\26}\33\246r\247\322P\62"
-    "j\310\250\21\343\354\335\203\357\354w\3B$}\33\206Dj\226\214\42\61l\304\260\21\303F\14\33\61"
-    "\212\304\222MF\221\30v\316\236=\10\301b\11\0C\27}\33\236Si\226\20Bft\376O\211\215"
-    " Db\215\42$\0D\33}\33\206Dj\226\214\32\62l\304\260\21\343\354\177vl\304(\22K\324"
-    "$\2E\22|\373\205\17R\316KD\30\215\234_>x`\0F\20|\373\205\17R\316\227i\262\31"
-    "\71\377\22\0I\7s\333\204\77HL\15{\333\205\201\363\377\77|\360`\0N$}\33\6\201\346\314"
-    "\35;\206\12U\242D&\306\230\30cd\210\221!fF\230\31a(+\314\256\63\67\0O\26}\33"
-    "\236Si\226\214\32\61\316\376\277\33\61j\310\232Tg\0R\61\216;\6Ek\230\14#\61n\304\270"
-    "\21\343F\214\33\61n\304\60\22\243\210\60Q\224j\310\260\61\243\306\20\232\325\230QD\206\221\30\67b"
-    "\334\301\1S\42\216;\236c\211\226\220\42\61n\304\270\21c\307R\232,[\262\203\307\216\65h\16\25"
-    "\21&\253\320\0T\15}\33\206\17R\15\235\377\377\25\0U\21|\373\205a\366\377\237\215\30\64D\15"
-    "*\63\0V\26\177\371\205\221\366\377\313\21\343\206\220\42C\25\11r'\313\16\3X)~;\206\201\6"
-    "\217\221\30\66\204\20\31\42\244\206\14Cg\320$Q\222\6\315!\33\62\212\10\31BD\206\215 v\320"
-    "\302\1x\24\312\272\205A\206\216\220@c\212\224\31$S\14\262h\0\0\0\0\4\377\377\0";
+    "j\310\250\21\343\354\335\203\357\354w\3B$}"
+    "\33\206Dj\226\214\42\61l\304\260\21\303F\14\33\61"
+    "\212\304\222MF\221\30v\316\236=\10\301b\11\0C\27}"
+    "\33\236Si\226\20Bft\376O\211\215"
+    " Db\215\42$\0D\33}\33\206Dj\226\214\32\62l\304\260\21\343\354\177vl\304("
+    "\22K\324"
+    "$\2E\22|\373\205\17R\316KD\30\215\234_>x`\0F\20|"
+    "\373\205\17R\316\227i\262\31"
+    "\71\377\22\0I\7s\333\204\77HL\15{\333\205\201\363\377\77|\360`\0N$}"
+    "\33\6\201\346\314"
+    "\35;\206\12U\242D&\306\230\30cd\210\221!fF\230\31a(+\314\256\63\67\0O\26}"
+    "\33"
+    "\236Si\226\214\32\61\316\376\277\33\61j\310\232Tg\0R\61\216;\6Ek\230\14#"
+    "\61n\304\270"
+    "\21\343F\214\33\61n\304\60\22\243\210\60Q\224j\310\260\61\243\306\20\232"
+    "\325\230QD\206\221\30\67b"
+    "\334\301\1S\42\216;\236c\211\226\220\42\61n\304\270\21c\307R\232,["
+    "\262\203\307\216\65h\16\25"
+    "\21&\253\320\0T\15}\33\206\17R\15\235\377\377\25\0U\21|"
+    "\373\205a\366\377\237\215\30\64D\15"
+    "*\63\0V\26\177\371\205\221\366\377\313\21\343\206\220\42C\25\11r'"
+    "\313\16\3X)~;\206\201\6"
+    "\217\221\30\66\204\20\31\42\244\206\14Cg\320$Q\222\6\315!"
+    "\33\62\212\10\31BD\206\215 v\320"
+    "\302\1x\24\312\272\205A\206\216\220@c\212\224\31$"
+    "S\14\262h\0\0\0\0\4\377\377\0";
 
 #define play_icon_width 14
 #define play_icon_height 14
 static const unsigned char play_icon[28] PROGMEM = {
-    0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x7C, 0x00, 0xFC, 0x00, 0xFC, 0x03,
-    0xFC, 0x0F, 0xFC, 0x0F, 0xFC, 0x03, 0xFC, 0x00, 0x7C, 0x00, 0x3C, 0x00,
-    0x00, 0x00, 0x00, 0x00};
+    0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x7C, 0x00, 0xFC, 0x00,
+    0xFC, 0x03, 0xFC, 0x0F, 0xFC, 0x0F, 0xFC, 0x03, 0xFC, 0x00,
+    0x7C, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00};
 static const unsigned char pause_icon[28] PROGMEM = {
-    0x00, 0x00, 0x00, 0x00, 0x38, 0x0E, 0x38, 0x0E, 0x38, 0x0E, 0x38, 0x0E,
-    0x38, 0x0E, 0x38, 0x0E, 0x38, 0x0E, 0x38, 0x0E, 0x38, 0x0E, 0x38, 0x0E,
-    0x38, 0x0E, 0x00, 0x00};
+    0x00, 0x00, 0x00, 0x00, 0x38, 0x0E, 0x38, 0x0E, 0x38, 0x0E,
+    0x38, 0x0E, 0x38, 0x0E, 0x38, 0x0E, 0x38, 0x0E, 0x38, 0x0E,
+    0x38, 0x0E, 0x38, 0x0E, 0x38, 0x0E, 0x00, 0x00};
 
 // Constants for screen layout and fonts
 constexpr uint8_t SCREEN_CENTER_X = 32;
@@ -107,6 +135,7 @@ enum ParamsMainPage : uint8_t {
   PARAM_MAIN_ROTATE_DISP,
   PARAM_MAIN_SAVE_DATA,
   PARAM_MAIN_LOAD_DATA,
+  PARAM_MAIN_RESET_STATE,
   PARAM_MAIN_FACTORY_RESET,
   PARAM_MAIN_LAST,
 };
@@ -118,22 +147,20 @@ enum ParamsChannelPage : uint8_t {
   PARAM_CH_DUTY,
   PARAM_CH_OFFSET,
   PARAM_CH_SWING,
-    PARAM_CH_EUC_STEPS,
-    PARAM_CH_EUC_HITS,
   PARAM_CH_CV1_DEST,
   PARAM_CH_CV2_DEST,
   PARAM_CH_LAST,
 };
 
 // Helper function to draw centered text
-void drawCenteredText(const char* text, int y, const uint8_t* font) {
+void drawCenteredText(const char *text, int y, const uint8_t *font) {
   gravity.display.setFont(font);
   int textWidth = gravity.display.getStrWidth(text);
   gravity.display.drawStr(SCREEN_CENTER_X - (textWidth / 2), y, text);
 }
 
 // Helper function to draw right-aligned text
-void drawRightAlignedText(const char* text, int y) {
+void drawRightAlignedText(const char *text, int y) {
   int textWidth = gravity.display.getStrWidth(text);
   int drawX = (SCREEN_WIDTH - textWidth) - MENU_BOX_PADDING;
   gravity.display.drawStr(drawX, y, text);
@@ -148,8 +175,10 @@ void drawMainSelection() {
   gravity.display.drawLine(0, 0, 0, tickSize);
   gravity.display.drawLine(mainWidth, 0, mainWidth - tickSize, 0);
   gravity.display.drawLine(mainWidth, 0, mainWidth, tickSize);
-    gravity.display.drawLine(mainWidth, mainHeight, mainWidth, mainHeight - tickSize);
-    gravity.display.drawLine(mainWidth, mainHeight, mainWidth - tickSize, mainHeight);
+  gravity.display.drawLine(mainWidth, mainHeight, mainWidth,
+                           mainHeight - tickSize);
+  gravity.display.drawLine(mainWidth, mainHeight, mainWidth - tickSize,
+                           mainHeight);
   gravity.display.drawLine(0, mainHeight, tickSize, mainHeight);
   gravity.display.drawLine(0, mainHeight, 0, mainHeight - tickSize);
   gravity.display.setDrawColor(2);
@@ -189,7 +218,8 @@ void drawMenuItems(String menu_items[], int menu_size) {
 
   for (int i = 0; i < min(menu_size, VISIBLE_MENU_ITEMS); ++i) {
     int idx = start_index + i;
-        drawRightAlignedText(menu_items[idx].c_str(), MENU_ITEM_HEIGHT * (i + 1) - 1);
+    drawRightAlignedText(menu_items[idx].c_str(),
+                         MENU_ITEM_HEIGHT * (i + 1) - 1);
   }
 }
 
@@ -199,7 +229,7 @@ inline void hollowTick() { gravity.display.drawBox(56, 4, 4, 4); }
 
 // Display an indicator when swing percentage matches a musical note.
 void swingDivisionMark() {
-    auto& ch = GetSelectedChannel();
+  auto &ch = GetSelectedChannel();
   switch (ch.getSwing()) {
   case 58: // 1/32nd
   case 66: // 1/16th
@@ -218,7 +248,8 @@ void swingDivisionMark() {
 String displaySaveSlot(int slot) {
   if (slot >= 0 && slot < StateManager::MAX_SAVE_SLOTS / 2) {
     return String("A") + String(slot + 1);
-    } else if (slot >= StateManager::MAX_SAVE_SLOTS / 2 && slot <= StateManager::MAX_SAVE_SLOTS) {
+  } else if (slot >= StateManager::MAX_SAVE_SLOTS / 2 &&
+             slot <= StateManager::MAX_SAVE_SLOTS) {
     return String("B") + String(slot - (StateManager::MAX_SAVE_SLOTS / 2) + 1);
   }
 }
@@ -257,6 +288,9 @@ void DisplayMainPage() {
     case Clock::SOURCE_EXTERNAL_PPQN_4:
       subText = F("4 PPQN");
       break;
+    case Clock::SOURCE_EXTERNAL_PPQN_2:
+      subText = F("2 PPQN");
+      break;
     case Clock::SOURCE_EXTERNAL_PPQN_1:
       subText = F("1 PPQN");
       break;
@@ -315,8 +349,8 @@ void DisplayMainPage() {
     subText = app.selected_sub_param == 0 ? F("DEFAULT") : F("REVERSED");
     break;
   case PARAM_MAIN_ROTATE_DISP:
-            mainText = F("ROT");
-            subText = app.selected_sub_param == 0 ? F("DEFAULT") : F("FLIPPED");
+    mainText = F("DISP");
+    subText = app.selected_sub_param == 0 ? F("DEFAULT") : F("ROTATED");
     break;
   case PARAM_MAIN_SAVE_DATA:
   case PARAM_MAIN_LOAD_DATA:
@@ -334,6 +368,15 @@ 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");
@@ -349,12 +392,15 @@ 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("CLK RUN"), F("CLK RESET"), F("PULSE OUT"), F("ENCODER DIR"), F("ROTATE DISP"), F("SAVE"), F("LOAD"), F("ERASE")};
+  String menu_items[PARAM_MAIN_LAST] = {
+      F("TEMPO"),     F("RUN"),         F("RST"),         F("SOURCE"),
+      F("PULSE OUT"), F("ENCODER DIR"), F("ROTATE DISP"), F("SAVE"),
+      F("LOAD"),      F("RESET"),       F("ERASE")};
   drawMenuItems(menu_items, PARAM_MAIN_LAST);
 }
 
 void DisplayChannelPage() {
-    auto& ch = GetSelectedChannel();
+  auto &ch = GetSelectedChannel();
 
   gravity.display.setFontMode(1);
   gravity.display.setDrawColor(2);
@@ -366,12 +412,10 @@ 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 = withCvMod ? ch.getClockModWithMod(cv1, cv2) : ch.getClockMod();
+    int mod_value = ch.getClockMod(withCvMod);
     if (mod_value > 1) {
       mainText = F("/");
       mainText += String(mod_value);
@@ -384,36 +428,28 @@ void DisplayChannelPage() {
     break;
   }
   case PARAM_CH_PROB:
-            mainText = String(withCvMod ? ch.getProbabilityWithMod(cv1, cv2) : ch.getProbability()) + F("%");
+    mainText = String(ch.getProbability(withCvMod)) + F("%");
     subText = F("HIT CHANCE");
     break;
   case PARAM_CH_DUTY:
-            mainText = String(withCvMod ? ch.getDutyCycleWithMod(cv1, cv2) : ch.getDutyCycle()) + F("%");
+    mainText = String(ch.getDutyCycle(withCvMod)) + F("%");
     subText = F("PULSE WIDTH");
     break;
   case PARAM_CH_OFFSET:
-            mainText = String(withCvMod ? ch.getOffsetWithMod(cv1, cv2) : ch.getOffset()) + F("%");
+    mainText = String(ch.getOffset(withCvMod)) + F("%");
     subText = F("SHIFT HIT");
     break;
   case PARAM_CH_SWING:
-            ch.getSwing() == 50
-                ? mainText = F("OFF")
-                : mainText = String(withCvMod ? ch.getSwingWithMod(cv1, cv2) : ch.getSwing()) + F("%");
+    ch.getSwing() == 50 ? mainText = F("OFF")
+                        : mainText = String(ch.getSwing(withCvMod)) + F("%");
     subText = "DOWN BEAT";
     swingDivisionMark();
     break;
-        case PARAM_CH_EUC_STEPS:
-            mainText = String(withCvMod ? ch.getStepsWithMod(cv1, cv2) : ch.getSteps());
-            subText = "EUCLID STEPS";
-            break;
-        case PARAM_CH_EUC_HITS:
-            mainText = String(withCvMod ? ch.getHitsWithMod(cv1, cv2) : ch.getHits());
-            subText = "EUCLID HITS";
-            break;
   case PARAM_CH_CV1_DEST:
   case PARAM_CH_CV2_DEST: {
     mainText = (app.selected_param == PARAM_CH_CV1_DEST) ? F("CV1") : F("CV2");
-            switch ((app.selected_param == PARAM_CH_CV1_DEST) ? ch.getCv1Dest() : ch.getCv2Dest()) {
+    switch ((app.selected_param == PARAM_CH_CV1_DEST) ? ch.getCv1Dest()
+                                                      : ch.getCv2Dest()) {
     case CV_DEST_NONE:
       subText = F("NONE");
       break;
@@ -432,12 +468,6 @@ void DisplayChannelPage() {
     case CV_DEST_SWING:
       subText = F("SWING");
       break;
-                case CV_DEST_EUC_STEPS:
-                    subText = F("EUCLID STEPS");
-                    break;
-                case CV_DEST_EUC_HITS:
-                    subText = F("EUCLID HITS");
-                    break;
     }
     break;
   }
@@ -448,8 +478,8 @@ void DisplayChannelPage() {
 
   // Draw Channel Page menu items
   String menu_items[PARAM_CH_LAST] = {
-        F("MOD"), F("PROBABILITY"), F("DUTY"), F("OFFSET"), F("SWING"), F("EUCLID STEPS"),
-        F("EUCLID HITS"), F("CV1 MOD"), F("CV2 MOD")};
+      F("MOD"),   F("PROBABILITY"), F("DUTY"),   F("OFFSET"),
+      F("SWING"), F("CV1 MOD"),     F("CV2 MOD")};
   drawMenuItems(menu_items, PARAM_CH_LAST);
 }
 
@@ -476,7 +506,8 @@ void DisplaySelectedChannel() {
     if (i == 0) {
       gravity.display.setBitmapMode(1);
       auto icon = gravity.clock.IsPaused() ? pause_icon : play_icon;
-            gravity.display.drawXBMP(2, boxY, play_icon_width, play_icon_height, icon);
+      gravity.display.drawXBMP(2, boxY, play_icon_width, play_icon_height,
+                               icon);
     } else {
       gravity.display.setFont(TEXT_FONT);
       gravity.display.setCursor((i * boxWidth) + textOffset, SCREEN_HEIGHT - 3);
@@ -499,4 +530,24 @@ void UpdateDisplay() {
   } while (gravity.display.nextPage());
 }
 
+void Bootsplash() {
+  gravity.display.firstPage();
+  do {
+    int textWidth;
+    String loadingText = F("LOADING....");
+    gravity.display.setFont(TEXT_FONT);
+
+    textWidth = gravity.display.getStrWidth(StateManager::SKETCH_NAME);
+    gravity.display.drawStr(16 + (textWidth / 2), 20,
+                            StateManager::SKETCH_NAME);
+
+    textWidth = gravity.display.getStrWidth(StateManager::SEMANTIC_VERSION);
+    gravity.display.drawStr(16 + (textWidth / 2), 32,
+                            StateManager::SEMANTIC_VERSION);
+
+    textWidth = gravity.display.getStrWidth(loadingText.c_str());
+    gravity.display.drawStr(26 + (textWidth / 2), 44, loadingText.c_str());
+  } while (gravity.display.nextPage());
+}
+
 #endif // DISPLAY_H

firmware/Gravity/save_state.cpp

@@ -17,7 +17,9 @@
 
 // Define the constants for the current firmware.
 const char StateManager::SKETCH_NAME[] = "ALT GRAVITY";
-const char StateManager::SEMANTIC_VERSION[] = "2.0.0";  // NOTE: This should match the version in the library.properties file.
+const char StateManager::SEMANTIC_VERSION[] =
+    "V2.0.1BETA1"; // NOTE: This should match the version in the
+                   // library.properties file.
 
 // Number of available save slots.
 const byte StateManager::MAX_SAVE_SLOTS = 10;
@@ -32,55 +34,74 @@ const int StateManager::EEPROM_DATA_START_ADDR = sizeof(StateManager::Metadata);
 
 StateManager::StateManager() : _isDirty(false), _lastChangeTime(0) {}
 
-bool StateManager::initialize(AppState& app) {
+bool StateManager::initialize(AppState &app) {
+  noInterrupts();
+  bool success = false;
   if (_isDataValid()) {
     // Load global settings.
     _loadMetadata(app);
     // Load app data from the transient slot.
     _loadState(app, TRANSIENT_SLOT);
-        return true;
+    success = true;
   }
   // EEPROM does not contain save data for this firmware & version.
   else {
-        // Erase EEPROM and initialize state. Save default pattern to all save slots.
+    // Erase EEPROM and initialize state. Save default pattern to all save
+    // slots.
     factoryReset(app);
-        return false;
   }
+  interrupts();
+  return success;
 }
 
-bool StateManager::loadData(AppState& app, byte slot_index) {
+bool StateManager::loadData(AppState &app, byte slot_index) {
   // Check if slot_index is within max range + 1 for transient.
-    if (slot_index >= MAX_SAVE_SLOTS + 1) return false;
+  if (slot_index >= MAX_SAVE_SLOTS + 1)
+    return false;
 
-    // Load the state data from the specified EEPROM slot and update the app state save slot.
+  noInterrupts();
+
+  // Load the state data from the specified EEPROM slot and update the app state
+  // save slot.
   _loadState(app, slot_index);
   app.selected_save_slot = slot_index;
-    // Persist this change in the global metadata.
-    _saveMetadata(app);
+  // Persist this change in the global metadata on next update.
+  _isDirty = true;
 
+  interrupts();
   return true;
 }
 
 // Save app state to user specified save slot.
-void StateManager::saveData(const AppState& app) {
+void StateManager::saveData(const AppState &app) {
+  noInterrupts();
   // Check if slot_index is within max range + 1 for transient.
-    if (app.selected_save_slot >= MAX_SAVE_SLOTS + 1) return;
+  if (app.selected_save_slot >= MAX_SAVE_SLOTS + 1) {
+    interrupts();
+    return;
+  }
 
   _saveState(app, app.selected_save_slot);
   _saveMetadata(app);
   _isDirty = false;
+  interrupts();
 }
 
-// Save transient state if it has changed and enough time has passed since last save.
-void StateManager::update(const AppState& app) {
+// Save transient state if it has changed and enough time has passed since last
+// save.
+void StateManager::update(const AppState &app) {
   if (_isDirty && (millis() - _lastChangeTime > SAVE_DELAY_MS)) {
+    noInterrupts();
     _saveState(app, TRANSIENT_SLOT);
     _saveMetadata(app);
     _isDirty = false;
+    interrupts();
   }
 }
 
-void StateManager::reset(AppState& app) {
+void StateManager::reset(AppState &app) {
+  noInterrupts();
+
   AppState default_app;
   app.tempo = default_app.tempo;
   app.selected_param = default_app.selected_param;
@@ -98,6 +119,7 @@ void StateManager::reset(AppState& app) {
   _loadMetadata(app);
 
   _isDirty = false;
+  interrupts();
 }
 
 void StateManager::markDirty() {
@@ -106,7 +128,7 @@ void StateManager::markDirty() {
 }
 
 // Erases all data in the EEPROM by writing 0 to every address.
-void StateManager::factoryReset(AppState& app) {
+void StateManager::factoryReset(AppState &app) {
   noInterrupts();
   for (unsigned int i = 0; i < EEPROM.length(); i++) {
     EEPROM.write(i, 0);
@@ -130,11 +152,11 @@ bool StateManager::_isDataValid() {
   return name_match && version_match;
 }
 
-void StateManager::_saveState(const AppState& app, byte slot_index) {
+void StateManager::_saveState(const AppState &app, byte slot_index) {
   // Check if slot_index is within max range + 1 for transient.
-    if (app.selected_save_slot >= MAX_SAVE_SLOTS + 1) return;
+  if (app.selected_save_slot >= MAX_SAVE_SLOTS + 1)
+    return;
 
-    noInterrupts();
   static EepromData save_data;
 
   save_data.tempo = app.tempo;
@@ -150,29 +172,25 @@ void StateManager::_saveState(const AppState& app, byte slot_index) {
   // "update" only save state for the current channel since other channels
   // will not have changed when saving user edits.
   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();
-        save_ch.base_probability = ch.getProbability();
-        save_ch.base_duty_cycle = ch.getDutyCycle();
-        save_ch.base_offset = ch.getOffset();
-        save_ch.base_swing = ch.getSwing();
-        save_ch.base_euc_steps = ch.getSteps();
-        save_ch.base_euc_hits = ch.getHits();
+    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_probability = ch.getProbability(false);
+    save_ch.base_duty_cycle = ch.getDutyCycle(false);
+    save_ch.base_offset = ch.getOffset(false);
     save_ch.cv1_dest = static_cast<byte>(ch.getCv1Dest());
     save_ch.cv2_dest = static_cast<byte>(ch.getCv2Dest());
   }
 
   int address = EEPROM_DATA_START_ADDR + (slot_index * sizeof(EepromData));
   EEPROM.put(address, save_data);
-    interrupts();
 }
 
-void StateManager::_loadState(AppState& app, byte slot_index) {
+void StateManager::_loadState(AppState &app, byte slot_index) {
   // Check if slot_index is within max range + 1 for transient.
-    if (slot_index >= MAX_SAVE_SLOTS + 1) return;
+  if (slot_index >= MAX_SAVE_SLOTS + 1)
+    return;
 
-    noInterrupts();
   static EepromData load_data;
   int address = EEPROM_DATA_START_ADDR + (slot_index * sizeof(EepromData));
   EEPROM.get(address, load_data);
@@ -187,24 +205,19 @@ void StateManager::_loadState(AppState& app, byte slot_index) {
   app.cv_reset = load_data.cv_reset;
 
   for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
-        auto& ch = app.channel[i];
-        const auto& saved_ch_state = load_data.channel_data[i];
+    auto &ch = app.channel[i];
+    const auto &saved_ch_state = load_data.channel_data[i];
 
     ch.setClockMod(saved_ch_state.base_clock_mod_index);
     ch.setProbability(saved_ch_state.base_probability);
     ch.setDutyCycle(saved_ch_state.base_duty_cycle);
     ch.setOffset(saved_ch_state.base_offset);
-        ch.setSwing(saved_ch_state.base_swing);
-        ch.setSteps(saved_ch_state.base_euc_steps);
-        ch.setHits(saved_ch_state.base_euc_hits);
     ch.setCv1Dest(static_cast<CvDestination>(saved_ch_state.cv1_dest));
     ch.setCv2Dest(static_cast<CvDestination>(saved_ch_state.cv2_dest));
   }
-    interrupts();
 }
 
-void StateManager::_saveMetadata(const AppState& app) {
-    noInterrupts();
+void StateManager::_saveMetadata(const AppState &app) {
   Metadata current_meta;
   strcpy(current_meta.sketch_name, SKETCH_NAME);
   strcpy(current_meta.version, SEMANTIC_VERSION);
@@ -215,14 +228,12 @@ void StateManager::_saveMetadata(const AppState& app) {
   current_meta.rotate_display = app.rotate_display;
 
   EEPROM.put(METADATA_START_ADDR, current_meta);
-    interrupts();
 }
 
-void StateManager::_loadMetadata(AppState& app) {
-    noInterrupts();
+void StateManager::_loadMetadata(AppState &app) {
   Metadata metadata;
   EEPROM.get(METADATA_START_ADDR, metadata);
   app.selected_save_slot = metadata.selected_save_slot;
   app.encoder_reversed = metadata.encoder_reversed;
-    interrupts();
+  app.rotate_display = metadata.rotate_display;
 }

firmware/Gravity/save_state.h

@@ -19,15 +19,15 @@
 struct AppState;
 
 /**
- * @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
- * is reseved for transient state to persist state between power cycles before
- * state is explicitly saved to a user slot. Metadata is stored in the beginning
- * of the memory space which stores firmware version information to validate that
- * the data can be loaded into the current version of AppState.
+ * @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 is reseved for transient state to persist state between power
+ * cycles before state is explicitly saved to a user slot. Metadata is stored in
+ * the beginning of the memory space which stores firmware version information
+ * to validate that the data can be loaded into the current version of AppState.
  */
 class StateManager {
-   public:
+public:
   static const char SKETCH_NAME[];
   static const char SEMANTIC_VERSION[];
   static const byte MAX_SAVE_SLOTS;
@@ -36,24 +36,24 @@ class StateManager {
   StateManager();
 
   // Populate the AppState instance with values from EEPROM if they exist.
-    bool initialize(AppState& app);
+  bool initialize(AppState &app);
   // Load data from specified slot.
-    bool loadData(AppState& app, byte slot_index);
+  bool loadData(AppState &app, byte slot_index);
   // Save data to specified slot.
-    void saveData(const AppState& app);
+  void saveData(const AppState &app);
   // Reset AppState instance back to default values.
-    void reset(AppState& app);
+  void reset(AppState &app);
   // Call from main loop, check if state has changed and needs to be saved.
-    void update(const AppState& app);
+  void update(const AppState &app);
   // Indicate that state has changed and we should save.
   void markDirty();
   // Erase all data stored in the EEPROM.
-    void factoryReset(AppState& app);
+  void factoryReset(AppState &app);
 
   // This struct holds the data that identifies the firmware version.
   struct Metadata {
-        char sketch_name[12];
-        char version[5];
+    char sketch_name[16];
+    char version[16];
     // Additional global/hardware settings
     byte selected_save_slot;
     bool encoder_reversed;
@@ -64,9 +64,6 @@ class StateManager {
     byte base_probability;
     byte base_duty_cycle;
     byte base_offset;
-        byte base_swing;
-        byte base_euc_steps;
-        byte base_euc_hits;
     byte cv1_dest; // Cast the CvDestination enum as a byte for storage
     byte cv2_dest; // Cast the CvDestination enum as a byte for storage
   };
@@ -82,12 +79,12 @@ class StateManager {
     ChannelState channel_data[Gravity::OUTPUT_COUNT];
   };
 
-   private:
+private:
   bool _isDataValid();
-    void _saveMetadata(const AppState& app);
-    void _loadMetadata(AppState& app);
-    void _saveState(const AppState& app, byte slot_index);
-    void _loadState(AppState& app, byte slot_index);
+  void _saveMetadata(const AppState &app);
+  void _loadMetadata(AppState &app);
+  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;

library.properties

@@ -1,5 +1,4 @@
-name=libGravity
-version=2.0.0
+version=2.0.1beta1
 author=Adam Wonak
 maintainer=awonak <github.com/awonak>
 sentence=Hardware abstraction library for Sitka Instruments Gravity eurorack module

src/analog_input.h

@@ -18,7 +18,7 @@ const int CALIBRATED_LOW = -566;
 const int CALIBRATED_HIGH = 512;
 
 class AnalogInput {
-   public:
+public:
   static const int GATE_THRESHOLD = 0;
 
   AnalogInput() {}
@@ -43,7 +43,8 @@ class AnalogInput {
     int raw = analogRead(pin_);
     read_ = map(raw, 0, MAX_INPUT, low_, high_);
     read_ = constrain(read_ - offset_, -512, 512);
-        if (inverted_) read_ = -read_;
+    if (inverted_)
+      read_ = -read_;
   }
 
   // Set calibration values.
@@ -52,7 +53,7 @@ class AnalogInput {
 
   void AdjustCalibrationHigh(int amount) { high_ += amount; }
 
-    void SetOffset(float percent) { offset_ = -(percent)*512; }
+  void SetOffset(float percent) { offset_ = -(percent) * 512; }
 
   void SetAttenuation(float percent) {
     low_ = abs(percent) * CALIBRATED_LOW;
@@ -80,7 +81,8 @@ class AnalogInput {
    * 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.
+   * @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;
@@ -88,7 +90,7 @@ class AnalogInput {
     return is_high && !was_high;
   }
 
-   private:
+private:
   uint8_t pin_;
   int16_t read_;
   uint16_t old_read_;

src/clock.h

@@ -17,7 +17,8 @@
 #include "peripherials.h"
 #include "uClock/uClock.h"
 
-// MIDI clock, start, stop, and continue byte definitions - based on MIDI 1.0 Standards.
+// MIDI clock, start, stop, and continue byte definitions - based on MIDI 1.0
+// Standards.
 #define MIDI_CLOCK 0xF8
 #define MIDI_START 0xFA
 #define MIDI_STOP 0xFC
@@ -28,13 +29,14 @@ static ExtCallback extUserCallback = nullptr;
 static void serialEventNoop(uint8_t msg, uint8_t status) {}
 
 class Clock {
-   public:
+public:
   static constexpr int DEFAULT_TEMPO = 120;
 
   enum Source {
     SOURCE_INTERNAL,
     SOURCE_EXTERNAL_PPQN_24,
     SOURCE_EXTERNAL_PPQN_4,
+    SOURCE_EXTERNAL_PPQN_2,
     SOURCE_EXTERNAL_PPQN_1,
     SOURCE_EXTERNAL_MIDI,
     SOURCE_LAST,
@@ -42,9 +44,9 @@ class Clock {
 
   enum Pulse {
     PULSE_NONE,
-        PULSE_PPQN_24,
-        PULSE_PPQN_4,
     PULSE_PPQN_1,
+    PULSE_PPQN_4,
+    PULSE_PPQN_24,
     PULSE_LAST,
   };
 
@@ -65,7 +67,8 @@ class Clock {
     uClock.start();
   }
 
-    // Handle external clock tick and call user callback when receiving clock trigger (PPQN_4, PPQN_24, or MIDI).
+  // Handle external clock tick and call user callback when receiving clock
+  // trigger (PPQN_4, PPQN_24, or MIDI).
   void AttachExtHandler(void (*callback)()) {
     extUserCallback = callback;
     attachInterrupt(digitalPinToInterrupt(EXT_PIN), callback, RISING);
@@ -80,7 +83,8 @@ class Clock {
   void SetSource(Source source) {
     bool was_playing = !IsPaused();
     uClock.stop();
-        // If we are changing the source from MIDI, disable the serial interrupt handler.
+    // If we are changing the source from MIDI, disable the serial interrupt
+    // handler.
     if (source_ == SOURCE_EXTERNAL_MIDI) {
       NeoSerial.attachInterrupt(serialEventNoop);
     }
@@ -97,6 +101,10 @@ 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);
@@ -112,7 +120,8 @@ class Clock {
     }
   }
 
-    // Return true if the current selected source is externl (PPQN_4, PPQN_24, or MIDI).
+  // Return true if the current selected source is externl (PPQN_4, PPQN_24, or
+  // MIDI).
   bool ExternalSource() {
     return uClock.getClockMode() == uClock.EXTERNAL_CLOCK;
   }
@@ -123,41 +132,28 @@ class Clock {
   }
 
   // Returns the current BPM tempo.
-    int Tempo() {
-        return uClock.getTempo();
-    }
+  int Tempo() { return uClock.getTempo(); }
 
   // Set the clock tempo to a int between 1 and 400.
-    void SetTempo(int tempo) {
-        return uClock.setTempo(tempo);
-    }
+  void SetTempo(int tempo) { return uClock.setTempo(tempo); }
 
-    // Record an external clock tick received to process external/internal syncronization.
-    void Tick() {
-        uClock.clockMe();
-    }
+  // Record an external clock tick received to process external/internal
+  // syncronization.
+  void Tick() { uClock.clockMe(); }
 
   // Start the internal clock.
-    void Start() {
-        uClock.start();
-    }
+  void Start() { uClock.start(); }
 
   // Stop internal clock clock.
-    void Stop() {
-        uClock.stop();
-    }
+  void Stop() { uClock.stop(); }
 
   // Reset all clock counters to 0.
-    void Reset() {
-        uClock.resetCounters();
-    }
+  void Reset() { uClock.resetCounters(); }
 
   // Returns true if the clock is not running.
-    bool IsPaused() {
-        return uClock.clock_state == uClock.PAUSED;
-    }
+  bool IsPaused() { return uClock.clock_state == uClock.PAUSED; }
 
-   private:
+private:
   Source source_ = SOURCE_INTERNAL;
 
   static void onSerialEvent(uint8_t msg, uint8_t status) {
@@ -180,17 +176,11 @@ class Clock {
     }
   }
 
-    static void sendMIDIStart() {
-        NeoSerial.write(MIDI_START);
-    }
+  static void sendMIDIStart() { NeoSerial.write(MIDI_START); }
 
-    static void sendMIDIStop() {
-        NeoSerial.write(MIDI_STOP);
-    }
+  static void sendMIDIStop() { NeoSerial.write(MIDI_STOP); }
 
-    static void sendMIDIClock(uint32_t tick) {
-        NeoSerial.write(MIDI_CLOCK);
-    }
+  static void sendMIDIClock(uint32_t tick) { NeoSerial.write(MIDI_CLOCK); }
 };
 
 #endif

src/digital_output.h

@@ -16,7 +16,7 @@
 const byte DEFAULT_TRIGGER_DURATION_MS = 5;
 
 class DigitalOutput {
-   public:
+public:
   /**
    * Initializes an CV Output paired object.
    *
@@ -43,8 +43,10 @@ class DigitalOutput {
    * @param state Arduino digital HIGH or LOW values.
    */
   inline void Update(uint8_t state) {
-        if (state == HIGH) High();  // Rising
-        if (state == LOW) Low();    // Falling
+    if (state == HIGH)
+      High(); // Rising
+    if (state == LOW)
+      Low(); // Falling
   }
 
   // Sets the cv output HIGH to about 5v.
@@ -65,7 +67,8 @@ class DigitalOutput {
    * Return a bool representing the on/off state of the output.
    */
   inline void Process() {
-        // If trigger is HIGH and the trigger duration time has elapsed, set the output low.
+    // If trigger is HIGH and the trigger duration time has elapsed, set the
+    // output low.
     if (on_ && (millis() - last_triggered_) >= trigger_duration_) {
       update(LOW);
     }
@@ -78,7 +81,7 @@ class DigitalOutput {
    */
   inline bool On() { return on_; }
 
-   private:
+private:
   unsigned long last_triggered_;
   uint8_t trigger_duration_;
   uint8_t cv_pin_;