Merge pull request 'Introduce Dual Window Comparators with cv calibration' (#30) from comparator into main

Reviewed-on: #30

README.md

@@ -2,6 +2,12 @@
 
 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.
 
+## Quick Start
+
+You can flash the firmware to your module using the [Web Installer](https://awonak.github.io/alt-gravity/). This website also provides demo videos and documentation for each firmware version.
+
+https://awonak.github.io/alt-gravity/
+
 ## Installation
 
 Download or git clone this repository into your Arduino > libraries folder.

firmware/Comparator/Comparator.ino

@@ -0,0 +1,435 @@
+#include <EEPROM.h>
+#include <libGravity.h>
+
+// EEPROM addrs
+const int EEPROM_INIT_ADDR = 0;
+const int EEPROM_CV1_LOW = 1;
+const int EEPROM_CV1_HIGH = 3;
+const int EEPROM_CV1_OFFSET = 5;
+const int EEPROM_CV2_LOW = 7;
+const int EEPROM_CV2_HIGH = 9;
+const int EEPROM_CV2_OFFSET = 11;
+const int EEPROM_COMP1_SHIFT = 13;
+const int EEPROM_COMP1_SIZE = 15;
+const int EEPROM_COMP2_SHIFT = 17;
+const int EEPROM_COMP2_SIZE = 19;
+const byte EEPROM_INIT_FLAG = 0xAB; // Update flag to re-init
+
+// EEPROM Delay Save
+const unsigned long SAVE_DELAY_MS = 5000;
+bool eeprom_needs_save = false;
+unsigned long last_param_change = 0;
+
+enum AppMode { MODE_COMPARATOR, MODE_CALIBRATION };
+AppMode current_mode = MODE_COMPARATOR;
+byte cal_selected_param = 0; // 0=CV1 Low, 1=CV1 Offset, 2=CV1 High, 3=CV2 Low,
+                             // 4=CV2 Offset, 5=CV2 High
+
+// UI Parameters
+enum Parameter { COMP1_SHIFT, COMP1_SIZE, COMP2_SHIFT, COMP2_SIZE };
+
+Parameter selected_param = COMP1_SHIFT;
+
+int comp1_shift = 0;  // Range: -512 to 512
+int comp1_size = 512; // Range: 0 to 1024
+
+int comp2_shift = 0;  // Range: -512 to 512
+int comp2_size = 512; // Range: 0 to 1024
+
+bool prev_gate1 = false;
+bool prev_gate2 = false;
+bool ff_state = false;
+bool needs_redraw = true;
+int last_cv1_draw = -1000;
+int last_cv2_draw = -1000;
+
+unsigned long last_redraw = 0;
+bool prev_both_buttons = false;
+
+// Calibration Methods
+void LoadCalibration() {
+  if (EEPROM.read(EEPROM_INIT_ADDR) == EEPROM_INIT_FLAG) {
+    int val = 0;
+    EEPROM.get(EEPROM_CV1_LOW, val);
+    gravity.cv1.SetCalibrationLow(val);
+    EEPROM.get(EEPROM_CV1_HIGH, val);
+    gravity.cv1.SetCalibrationHigh(val);
+    EEPROM.get(EEPROM_CV1_OFFSET, val);
+    gravity.cv1.AdjustOffset(val - gravity.cv1.GetOffset());
+    EEPROM.get(EEPROM_CV2_LOW, val);
+    gravity.cv2.SetCalibrationLow(val);
+    EEPROM.get(EEPROM_CV2_HIGH, val);
+    gravity.cv2.SetCalibrationHigh(val);
+    EEPROM.get(EEPROM_CV2_OFFSET, val);
+    gravity.cv2.AdjustOffset(val - gravity.cv2.GetOffset());
+
+    EEPROM.get(EEPROM_COMP1_SHIFT, comp1_shift);
+    EEPROM.get(EEPROM_COMP1_SIZE, comp1_size);
+    EEPROM.get(EEPROM_COMP2_SHIFT, comp2_shift);
+    EEPROM.get(EEPROM_COMP2_SIZE, comp2_size);
+  }
+}
+
+void SaveCalibration() {
+  EEPROM.update(EEPROM_INIT_ADDR, EEPROM_INIT_FLAG);
+  int val;
+  val = gravity.cv1.GetCalibrationLow();
+  EEPROM.put(EEPROM_CV1_LOW, val);
+  val = gravity.cv1.GetCalibrationHigh();
+  EEPROM.put(EEPROM_CV1_HIGH, val);
+  val = gravity.cv1.GetOffset();
+  EEPROM.put(EEPROM_CV1_OFFSET, val);
+  val = gravity.cv2.GetCalibrationLow();
+  EEPROM.put(EEPROM_CV2_LOW, val);
+  val = gravity.cv2.GetCalibrationHigh();
+  EEPROM.put(EEPROM_CV2_HIGH, val);
+  val = gravity.cv2.GetOffset();
+  EEPROM.put(EEPROM_CV2_OFFSET, val);
+
+  EEPROM.put(EEPROM_COMP1_SHIFT, comp1_shift);
+  EEPROM.put(EEPROM_COMP1_SIZE, comp1_size);
+  EEPROM.put(EEPROM_COMP2_SHIFT, comp2_shift);
+  EEPROM.put(EEPROM_COMP2_SIZE, comp2_size);
+}
+
+// Handlers
+void OnPlayPress() {
+  if (gravity.shift_button.On())
+    return; // ignore if holding both
+  if (current_mode == MODE_CALIBRATION) {
+    cal_selected_param = (cal_selected_param < 3) ? cal_selected_param + 3
+                                                  : cal_selected_param - 3;
+    needs_redraw = true;
+    return;
+  }
+  if (selected_param == COMP1_SHIFT)
+    selected_param = COMP2_SHIFT;
+  else if (selected_param == COMP1_SIZE)
+    selected_param = COMP2_SIZE;
+  else if (selected_param == COMP2_SHIFT)
+    selected_param = COMP1_SHIFT;
+  else if (selected_param == COMP2_SIZE)
+    selected_param = COMP1_SIZE;
+  needs_redraw = true;
+}
+
+void OnShiftPress() {
+  if (gravity.play_button.On())
+    return; // ignore if holding both
+  if (current_mode == MODE_CALIBRATION) {
+    cal_selected_param =
+        (cal_selected_param / 3) * 3 + ((cal_selected_param + 1) % 3);
+    needs_redraw = true;
+    return;
+  }
+  if (selected_param == COMP1_SHIFT)
+    selected_param = COMP1_SIZE;
+  else if (selected_param == COMP1_SIZE)
+    selected_param = COMP1_SHIFT;
+  else if (selected_param == COMP2_SHIFT)
+    selected_param = COMP2_SIZE;
+  else if (selected_param == COMP2_SIZE)
+    selected_param = COMP2_SHIFT;
+  needs_redraw = true;
+}
+
+void OnEncoderRotate(int val) {
+  if (current_mode == MODE_CALIBRATION) {
+    AnalogInput *cv = (cal_selected_param > 2) ? &gravity.cv2 : &gravity.cv1;
+    // Scale val up so tuning is practical without excessive encoder interrupts
+    int cal_adj = val * 8;
+    switch (cal_selected_param % 3) {
+    case 0:
+      cv->AdjustCalibrationLow(cal_adj);
+      break;
+    case 1:
+      cv->AdjustOffset(cal_adj);
+      break;
+    case 2:
+      cv->AdjustCalibrationHigh(cal_adj);
+      break;
+    }
+    needs_redraw = true;
+    return;
+  }
+
+  int amount = val * 16;
+  switch (selected_param) {
+  case COMP1_SHIFT:
+    comp1_shift = constrain(comp1_shift + amount, -512, 512);
+    break;
+  case COMP1_SIZE:
+    comp1_size = constrain(comp1_size + amount, 0, 1024);
+    break;
+  case COMP2_SHIFT:
+    comp2_shift = constrain(comp2_shift + amount, -512, 512);
+    break;
+  case COMP2_SIZE:
+    comp2_size = constrain(comp2_size + amount, 0, 1024);
+    break;
+  }
+
+  eeprom_needs_save = true;
+  last_param_change = millis();
+  needs_redraw = true;
+}
+
+void DisplayCalibrationPoint(AnalogInput *cv, const char *title, int index) {
+  int barWidth = 100, barHeight = 10, textHeight = 10;
+  int half = barWidth / 2;
+  int offsetX = 16, offsetY = (32 * index);
+
+  gravity.display.setDrawColor(1);
+  int value = cv->Read();
+
+  gravity.display.setCursor(0, offsetY + textHeight);
+  gravity.display.print(title);
+  if (value >= 0)
+    gravity.display.print(" ");
+  gravity.display.print(value);
+
+  gravity.display.setCursor(92, offsetY + textHeight);
+  if (cv->Voltage() >= 0)
+    gravity.display.print(" ");
+  gravity.display.print(cv->Voltage(), 1);
+  gravity.display.print(F("V"));
+
+  gravity.display.drawFrame(offsetX, textHeight + offsetY + 2, barWidth,
+                            barHeight);
+  if (value > 0) {
+    int x = constrain(map(value, 0, 512, 0, half), 0, half);
+    gravity.display.drawBox(half + offsetX, textHeight + offsetY + 2, x,
+                            barHeight);
+  } else {
+    int x = constrain(map(abs(value), 0, 512, 0, half), 0, half);
+    gravity.display.drawBox((half + offsetX) - x, textHeight + offsetY + 2, x,
+                            barHeight);
+  }
+
+  if (cal_selected_param / 3 == index) {
+    int left = offsetX + (half * (cal_selected_param % 3) - 2);
+    int top = barHeight + textHeight + offsetY + 12;
+    gravity.display.drawStr(left, top, "^");
+  }
+}
+
+void UpdateCalibrationDisplay() {
+  gravity.display.setFontMode(0);
+  gravity.display.setDrawColor(1);
+  gravity.display.setFont(u8g2_font_profont11_tf);
+  DisplayCalibrationPoint(&gravity.cv1, "CV1: ", 0);
+  DisplayCalibrationPoint(&gravity.cv2, "CV2: ", 1);
+}
+
+// UpdateDisplay
+void UpdateDisplay(int cv1_val, int cv2_val) {
+  // Comp 1 graphics (Left)
+  int c1_h = max((comp1_size * 3) / 64, 1);
+  int c1_center = 26 - ((comp1_shift * 3) / 64);
+  int c1_y = c1_center - (c1_h / 2);
+  gravity.display.drawFrame(20, c1_y, 44, c1_h);
+
+  // CV 1 Indicator (Filled Box, 50% width, from 0V center)
+  int cv1_y = constrain(26 - ((cv1_val * 3) / 64), 2, 50);
+  if (cv1_val >= 0) {
+    gravity.display.drawBox(31, cv1_y, 22, 26 - cv1_y);
+  } else {
+    gravity.display.drawBox(31, 26, 22, cv1_y - 26);
+  }
+
+  // Comp 2 graphics (Right)
+  int c2_h = max((comp2_size * 3) / 64, 1);
+  int c2_center = 26 - ((comp2_shift * 3) / 64);
+  int c2_y = c2_center - (c2_h / 2);
+  gravity.display.drawFrame(74, c2_y, 44, c2_h);
+
+  // CV 2 Indicator (Filled Box, 50% width, from 0V center)
+  int cv2_y = constrain(26 - ((cv2_val * 3) / 64), 2, 50);
+  if (cv2_val >= 0) {
+    gravity.display.drawBox(85, cv2_y, 22, 26 - cv2_y);
+  } else {
+    gravity.display.drawBox(85, 26, 22, cv2_y - 26);
+  }
+
+  // Restore solid drawing for labels
+  gravity.display.setDrawColor(1);
+  gravity.display.setFont(u8g2_font_5x7_tf);
+  gravity.display.setCursor(0, 7);
+  gravity.display.print("+5V");
+  gravity.display.setCursor(6, 29);
+  gravity.display.print("0V");
+  gravity.display.setCursor(0, 51);
+  gravity.display.print("-5V");
+
+  gravity.display.setDrawColor(2); // XOR mode
+
+  // Draw center divider and dotted lines in XOR
+  for (int x = 20; x < 128; x += 4) {
+    gravity.display.drawPixel(x, 2);  // +5V
+    gravity.display.drawPixel(x, 26); // 0V
+    gravity.display.drawPixel(x, 50); // -5V
+  }
+  for (int y = 0; y <= 50; y += 4) {
+    gravity.display.drawPixel(69, y); // Center divider
+  }
+
+  // Restore draw color to default (solid)
+  gravity.display.setDrawColor(1);
+
+  // Bottom text area
+  gravity.display.setDrawColor(0);
+  gravity.display.drawBox(0, 52, 128, 12);
+  gravity.display.setDrawColor(1);
+  gravity.display.drawHLine(0, 52, 128);
+
+  gravity.display.setFont(u8g2_font_6x10_tf);
+  gravity.display.setCursor(2, 62);
+
+  char text[32];
+  switch (selected_param) {
+  case COMP1_SHIFT:
+    snprintf(text, sizeof(text), "> Comp 1 Shift: %d", comp1_shift);
+    break;
+  case COMP1_SIZE:
+    snprintf(text, sizeof(text), "> Comp 1 Size: %d", comp1_size);
+    break;
+  case COMP2_SHIFT:
+    snprintf(text, sizeof(text), "> Comp 2 Shift: %d", comp2_shift);
+    break;
+  case COMP2_SIZE:
+    snprintf(text, sizeof(text), "> Comp 2 Size: %d", comp2_size);
+    break;
+  }
+  gravity.display.print(text);
+}
+
+void setup() {
+  gravity.Init();
+  LoadCalibration();
+
+  // Speed up ADC conversions
+  ADCSRA &= ~(bit(ADPS2) | bit(ADPS1) | bit(ADPS0));
+  ADCSRA |= bit(ADPS2);
+
+  gravity.play_button.AttachPressHandler(OnPlayPress);
+  gravity.shift_button.AttachPressHandler(OnShiftPress);
+  gravity.encoder.AttachRotateHandler(OnEncoderRotate);
+}
+
+void loop() {
+  gravity.Process();
+
+  bool both_pressed = gravity.play_button.On() && gravity.shift_button.On();
+  if (both_pressed && !prev_both_buttons) {
+    if (current_mode == MODE_COMPARATOR) {
+      current_mode = MODE_CALIBRATION;
+      cal_selected_param = 0;
+
+      // Turn off all outputs to prevent phantom gates while tuning
+      for (int i = 0; i < 6; i++) {
+        gravity.outputs[i].Update(LOW);
+      }
+    } else {
+      SaveCalibration();
+      current_mode = MODE_COMPARATOR;
+    }
+    needs_redraw = true;
+  }
+  prev_both_buttons = both_pressed;
+
+  int cv1_val = gravity.cv1.Read();
+  int cv2_val = gravity.cv2.Read();
+
+  if (current_mode == MODE_COMPARATOR) {
+    int c1_lower = comp1_shift - (comp1_size / 2);
+    int c1_upper = comp1_shift + (comp1_size / 2);
+
+    int c2_lower = comp2_shift - (comp2_size / 2);
+    int c2_upper = comp2_shift + (comp2_size / 2);
+
+    const int HYSTERESIS = 4; // Margin to prevent noise bouncing at threshold
+
+    bool gate1 = prev_gate1;
+    if (gate1) {
+      if (cv1_val < c1_lower - HYSTERESIS || cv1_val > c1_upper + HYSTERESIS) {
+        gate1 = false;
+      }
+    } else {
+      if (cv1_val >= c1_lower + HYSTERESIS &&
+          cv1_val <= c1_upper - HYSTERESIS) {
+        gate1 = true;
+      }
+    }
+
+    bool gate2 = prev_gate2;
+    if (gate2) {
+      if (cv2_val < c2_lower - HYSTERESIS || cv2_val > c2_upper + HYSTERESIS) {
+        gate2 = false;
+      }
+    } else {
+      if (cv2_val >= c2_lower + HYSTERESIS &&
+          cv2_val <= c2_upper - HYSTERESIS) {
+        gate2 = true;
+      }
+    }
+
+    bool logic_and = gate1 && gate2;
+    bool logic_or = gate1 || gate2;
+    bool logic_xor = gate1 ^ gate2;
+
+    static bool prev_logic_xor = false;
+    if (logic_xor && !prev_logic_xor) {
+      ff_state = !ff_state;
+    }
+    prev_logic_xor = logic_xor;
+
+    gravity.outputs[0].Update(gate1 ? HIGH : LOW);
+    gravity.outputs[1].Update(gate2 ? HIGH : LOW);
+    gravity.outputs[2].Update(logic_and ? HIGH : LOW);
+    gravity.outputs[3].Update(logic_or ? HIGH : LOW);
+    gravity.outputs[4].Update(logic_xor ? HIGH : LOW);
+    gravity.outputs[5].Update(ff_state ? HIGH : LOW);
+
+    prev_gate1 = gate1;
+    prev_gate2 = gate2;
+  }
+
+  if (eeprom_needs_save && (millis() - last_param_change > SAVE_DELAY_MS)) {
+    SaveCalibration();
+    eeprom_needs_save = false;
+  }
+
+  if (current_mode == MODE_COMPARATOR) {
+    if (abs(cv1_val - last_cv1_draw) > 12 ||
+        abs(cv2_val - last_cv2_draw) > 12) {
+      needs_redraw = true;
+    }
+  } else if (current_mode == MODE_CALIBRATION) {
+    // Need frequent redraws in calibration to see the live target input
+    if (abs(cv1_val - last_cv1_draw) >= 2 ||
+        abs(cv2_val - last_cv2_draw) >= 2) {
+      needs_redraw = true;
+    }
+  }
+
+  // Unroll the display loop so it doesn't block the logic loop
+  static bool is_drawing = false;
+
+  if (needs_redraw && !is_drawing && (millis() - last_redraw >= 30)) {
+    needs_redraw = false;
+    is_drawing = true;
+    last_redraw = millis();
+    gravity.display.firstPage();
+  }
+
+  if (is_drawing) {
+    if (current_mode == MODE_COMPARATOR) {
+      last_cv1_draw = cv1_val;
+      last_cv2_draw = cv2_val;
+      UpdateDisplay(cv1_val, cv2_val);
+    } else {
+      UpdateCalibrationDisplay();
+    }
+    is_drawing = gravity.display.nextPage();
+  }
+}

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 v2.0.1beta1 - February 2026 awonak
- * @version v1.0 - August 2023 Oleksiy H - Initial release
+ * @date 2026-02-21
- * @date 2025-07-04
  *
- * @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.
  *
  */
 
@@ -63,53 +65,75 @@ StateManager stateManager;
 //
 
 void setup() {
-    // Start Gravity.
+  // Start Gravity.
-    gravity.Init();
+  gravity.Init();
 
-    // Show bootsplash when initializing firmware.
+  // Show bootsplash when initializing firmware.
-    Bootsplash();
+  Bootsplash();
-    delay(2000);
+  delay(2000);
 
-    // Initialize the state manager. This will load settings from EEPROM
+  // Initialize the state manager. This will load settings from EEPROM
-    stateManager.initialize(app);
+  stateManager.initialize(app);
-    InitGravity(app);
+  InitGravity(app);
 
-    // Clock handlers.
+  // Clock handlers.
-    gravity.clock.AttachIntHandler(HandleIntClockTick);
+  gravity.clock.AttachIntHandler(HandleIntClockTick);
-    gravity.clock.AttachExtHandler(HandleExtClockTick);
+  gravity.clock.AttachExtHandler(HandleExtClockTick);
 
-    // Encoder rotate and press handlers.
+  // Encoder rotate and press handlers.
-    gravity.encoder.AttachPressHandler(HandleEncoderPressed);
+  gravity.encoder.AttachPressHandler(HandleEncoderPressed);
-    gravity.encoder.AttachRotateHandler(HandleRotate);
+  gravity.encoder.AttachRotateHandler(HandleRotate);
-    gravity.encoder.AttachPressRotateHandler(HandlePressedRotate);
+  gravity.encoder.AttachPressRotateHandler(HandlePressedRotate);
 
-    // Button press handlers.
+  // Button press handlers.
-    gravity.play_button.AttachPressHandler(HandlePlayPressed);
+  gravity.play_button.AttachPressHandler(HandlePlayPressed);
 }
 
 void loop() {
-    // Process change in state of inputs and outputs.
+  // Process change in state of inputs and outputs.
-    gravity.Process();
+  gravity.Process();
 
-    // Read CVs and call the update function for each channel.
+  // Read CVs and call the update function for each channel.
-    int cv1 = gravity.cv1.Read();
+  int cv1 = gravity.cv1.Read();
-    int cv2 = gravity.cv2.Read();
+  int cv2 = gravity.cv2.Read();
 
-    for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
+  for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
-        auto& ch = app.channel[i];
+    auto &ch = app.channel[i];
-        // Only apply CV to the channel when the current channel has cv
+    // Only apply CV to the channel when the current channel has cv
-        // mod configured.
+    // mod configured.
-        if (ch.isCvModActive()) {
+    if (ch.isCvModActive()) {
-            ch.applyCvMod(cv1, cv2);
+      ch.applyCvMod(cv1, cv2);
-        }
     }
+  }
 
-    // Check for dirty state eligible to be saved.
+  // Clock Run
-    stateManager.update(app);
+  if (app.cv_run == 1 || app.cv_run == 2) {
-
+    auto &cv = app.cv_run == 1 ? gravity.cv1 : gravity.cv2;
-    if (app.refresh_screen) {
+    int val = cv.Read();
-        UpdateDisplay();
+    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();
+  }
 }
 
 //
@@ -117,58 +141,59 @@ void loop() {
 //
 
 void HandleIntClockTick(uint32_t tick) {
-    bool refresh = false;
+  bool refresh = false;
-    for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
+  for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
-        app.channel[i].processClockTick(tick, gravity.outputs[i]);
+    app.channel[i].processClockTick(tick, gravity.outputs[i]);
 
-        if (app.channel[i].isCvModActive()) {
+    if (app.channel[i].isCvModActive()) {
-            refresh = true;
+      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;
     }
 
-    // Pulse Out gate
+    const uint16_t pulse_high_ticks =
-    if (app.selected_pulse != Clock::PULSE_NONE) {
+        pgm_read_word_near(&CLOCK_MOD_PULSES[clock_index]);
-        int clock_index;
+    const uint32_t pulse_low_ticks = tick + max((pulse_high_ticks / 2), 1L);
-        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]);
+    if (tick % pulse_high_ticks == 0) {
-        const uint32_t pulse_low_ticks = tick + max((pulse_high_ticks / 2), 1L);
+      gravity.pulse.High();
-
+    } else if (pulse_low_ticks % pulse_high_ticks == 0) {
-        if (tick % pulse_high_ticks == 0) {
+      gravity.pulse.Low();
-            gravity.pulse.High();
-        } else if (pulse_low_ticks % pulse_high_ticks == 0) {
-            gravity.pulse.Low();
-        }
     }
+  }
 
-    if (!app.editing_param) {
+  if (!app.editing_param) {
-        app.refresh_screen |= refresh;
+    app.refresh_screen |= refresh;
-    }
+  }
 }
 
 void HandleExtClockTick() {
-    switch (app.selected_source) {
+  switch (app.selected_source) {
-        case Clock::SOURCE_INTERNAL:
+  case Clock::SOURCE_INTERNAL:
-        case Clock::SOURCE_EXTERNAL_MIDI:
+  case Clock::SOURCE_EXTERNAL_MIDI:
-            // Use EXT as Reset when not used for clock source.
+    // Use EXT as Reset when not used for clock source.
-            ResetOutputs();
+    ResetOutputs();
-            gravity.clock.Reset();
+    gravity.clock.Reset();
-            break;
+    break;
-        default:
+  default:
-            // Register EXT cv clock tick.
+    // Register EXT cv clock tick.
-            gravity.clock.Tick();
+    gravity.clock.Tick();
-    }
+  }
-    app.refresh_screen = true;
+  app.refresh_screen = true;
 }
 
 //
@@ -176,204 +201,223 @@ void HandleExtClockTick() {
 //
 
 void HandlePlayPressed() {
-    // Check if SHIFT is pressed to mute all/current channel.
+  // Check if SHIFT is pressed to mute all/current channel.
-    if (gravity.shift_button.On()) {
+  if (gravity.shift_button.On()) {
-        if (app.selected_channel == 0) {
+    if (app.selected_channel == 0) {
-            // Mute all channels
+      // Mute all channels
-            for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
+      for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
-                app.channel[i].toggleMute();
+        app.channel[i].toggleMute();
-            }
+      }
-        } else {
+    } else {
-            // Mute selected channel
+      // Mute selected channel
-            auto& ch = GetSelectedChannel();
+      auto &ch = GetSelectedChannel();
-            ch.toggleMute();
+      ch.toggleMute();
-        }
-        return;
     }
+    return;
+  }
 
-    gravity.clock.IsPaused()
+  gravity.clock.IsPaused() ? gravity.clock.Start() : gravity.clock.Stop();
-        ? gravity.clock.Start()
+  ResetOutputs();
-        : gravity.clock.Stop();
+  app.refresh_screen = true;
-    ResetOutputs();
-    app.refresh_screen = true;
 }
 
 void HandleEncoderPressed() {
-    // Check if leaving editing mode should apply a selection.
+  // Check if leaving editing mode should apply a selection.
-    if (app.editing_param) {
+  if (app.editing_param) {
-        if (app.selected_channel == 0) {  // main page
+    if (app.selected_channel == 0) { // main page
-            // TODO: rewrite as switch
+      // TODO: rewrite as switch
-            if (app.selected_param == PARAM_MAIN_ENCODER_DIR) {
+      if (app.selected_param == PARAM_MAIN_ENCODER_DIR) {
-                app.encoder_reversed = app.selected_sub_param == 1;
+        app.encoder_reversed = app.selected_sub_param == 1;
-                gravity.encoder.SetReverseDirection(app.encoder_reversed);
+        gravity.encoder.SetReverseDirection(app.encoder_reversed);
-            }
+      }
-            if (app.selected_param == PARAM_MAIN_SAVE_DATA) {
+      if (app.selected_param == PARAM_MAIN_ROTATE_DISP) {
-                if (app.selected_sub_param < StateManager::MAX_SAVE_SLOTS) {
+        app.rotate_display = app.selected_sub_param == 1;
-                    app.selected_save_slot = app.selected_sub_param;
+        gravity.display.setFlipMode(app.rotate_display ? 1 : 0);
-                    stateManager.saveData(app);
+      }
-                }
+      if (app.selected_param == PARAM_MAIN_SAVE_DATA) {
-            }
+        if (app.selected_sub_param < StateManager::MAX_SAVE_SLOTS) {
-            if (app.selected_param == PARAM_MAIN_LOAD_DATA) {
+          app.selected_save_slot = app.selected_sub_param;
-                if (app.selected_sub_param < StateManager::MAX_SAVE_SLOTS) {
+          stateManager.saveData(app);
-                    app.selected_save_slot = app.selected_sub_param;
-                    stateManager.loadData(app, app.selected_save_slot);
-                    InitGravity(app);
-                }
-            }
-            if (app.selected_param == PARAM_MAIN_RESET_STATE) {
-                if (app.selected_sub_param == 0) {  // Reset
-                    stateManager.reset(app);
-                    InitGravity(app);
-                }
-            }
-            if (app.selected_param == PARAM_MAIN_FACTORY_RESET) {
-                if (app.selected_sub_param == 0) {  // Erase
-                    // Show bootsplash during slow erase operation.
-                    Bootsplash();
-                    stateManager.factoryReset(app);
-                    InitGravity(app);
-                }
-            }
         }
-        // Only mark dirty and reset selected_sub_param when leaving editing mode.
+      }
-        stateManager.markDirty();
+      if (app.selected_param == PARAM_MAIN_LOAD_DATA) {
-        app.selected_sub_param = 0;
+        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.editing_param = !app.editing_param;
-    app.refresh_screen = true;
+  app.refresh_screen = true;
 }
 
 void HandleRotate(int val) {
-    // Shift & Rotate check
+  // Shift & Rotate check
-    if (gravity.shift_button.On()) {
+  if (gravity.shift_button.On()) {
-        HandlePressedRotate(val);
+    HandlePressedRotate(val);
-        return;
+    return;
-    }
+  }
 
-    if (!app.editing_param) {
+  if (!app.editing_param) {
-        // Navigation Mode
+    // Navigation Mode
-        const int max_param = (app.selected_channel == 0) ? PARAM_MAIN_LAST : PARAM_CH_LAST;
+    const int max_param =
-        updateSelection(app.selected_param, val, 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 {
-        // Editing Mode
+      editChannelParameter(val);
-        if (app.selected_channel == 0) {
-            editMainParameter(val);
-        } else {
-            editChannelParameter(val);
-        }
     }
-    app.refresh_screen = true;
+  }
+  app.refresh_screen = true;
 }
 
 void HandlePressedRotate(int val) {
-    updateSelection(app.selected_channel, val, Gravity::OUTPUT_COUNT + 1);
+  updateSelection(app.selected_channel, val, Gravity::OUTPUT_COUNT + 1);
-    app.selected_param = 0;
+  app.selected_param = 0;
-    stateManager.markDirty();
+  stateManager.markDirty();
-    app.refresh_screen = true;
+  app.refresh_screen = true;
 }
 
 void editMainParameter(int val) {
-    switch (static_cast<ParamsMainPage>(app.selected_param)) {
+  switch (static_cast<ParamsMainPage>(app.selected_param)) {
-        case PARAM_MAIN_TEMPO:
+  case PARAM_MAIN_TEMPO:
-            if (gravity.clock.ExternalSource()) {
+    if (gravity.clock.ExternalSource()) {
-                break;
+      break;
-            }
-            gravity.clock.SetTempo(gravity.clock.Tempo() + val);
-            app.tempo = gravity.clock.Tempo();
-            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;
-        }
-        case PARAM_MAIN_ENCODER_DIR:
-            updateSelection(app.selected_sub_param, val, 2);
-            break;
-        case PARAM_MAIN_SAVE_DATA:
-        case PARAM_MAIN_LOAD_DATA:
-            updateSelection(app.selected_sub_param, val, 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;
     }
+    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();
+  auto &ch = GetSelectedChannel();
-    switch (app.selected_param) {
+  switch (app.selected_param) {
-        case PARAM_CH_MOD:
+  case PARAM_CH_MOD:
-            ch.setClockMod(ch.getClockModIndex() + val);
+    ch.setClockMod(ch.getClockModIndex() + val);
-            break;
+    break;
-        case PARAM_CH_PROB:
+  case PARAM_CH_PROB:
-            ch.setProbability(ch.getProbability() + val);
+    ch.setProbability(ch.getProbability() + val);
-            break;
+    break;
-        case PARAM_CH_DUTY:
+  case PARAM_CH_DUTY:
-            ch.setDutyCycle(ch.getDutyCycle() + val);
+    ch.setDutyCycle(ch.getDutyCycle() + val);
-            break;
+    break;
-        case PARAM_CH_OFFSET:
+  case PARAM_CH_OFFSET:
-            ch.setOffset(ch.getOffset() + val);
+    ch.setOffset(ch.getOffset() + val);
-            break;
+    break;
-        case PARAM_CH_SWING:
+  case PARAM_CH_SWING:
-            ch.setSwing(ch.getSwing() + val);
+    ch.setSwing(ch.getSwing() + val);
-            break;
+    break;
-        case PARAM_CH_EUC_STEPS:
+  case PARAM_CH_CV1_DEST: {
-            ch.setSteps(ch.getSteps() + val);
+    byte dest = static_cast<int>(ch.getCv1Dest());
-            break;
+    updateSelection(dest, val, CV_DEST_LAST);
-        case PARAM_CH_EUC_HITS:
+    ch.setCv1Dest(static_cast<CvDestination>(dest));
-            ch.setHits(ch.getHits() + val);
+    break;
-            break;
+  }
-        case PARAM_CH_CV1_DEST: {
+  case PARAM_CH_CV2_DEST: {
-            byte dest = static_cast<int>(ch.getCv1Dest());
+    byte dest = static_cast<int>(ch.getCv2Dest());
-            updateSelection(dest, val, CV_DEST_LAST);
+    updateSelection(dest, val, CV_DEST_LAST);
-            ch.setCv1Dest(static_cast<CvDestination>(dest));
+    ch.setCv2Dest(static_cast<CvDestination>(dest));
-            break;
+    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) {
+void updateSelection(byte &param, int change, int maxValue) {
-    // Do not apply acceleration if max value is less than 25.
+  // Do not apply acceleration if max value is less than 25.
-    if (maxValue < 25) {
+  if (maxValue < 25) {
-        change = change > 0 ? 1 : -1;
+    change = change > 0 ? 1 : -1;
-    }
+  }
-    param = constrain(param + change, 0, maxValue - 1);
+  param = constrain(param + change, 0, maxValue - 1);
 }
 
 //
 // App Helper functions.
 //
 
-void InitGravity(AppState& app) {
+void InitGravity(AppState &app) {
-    gravity.clock.SetTempo(app.tempo);
+  gravity.clock.SetTempo(app.tempo);
-    gravity.clock.SetSource(app.selected_source);
+  gravity.clock.SetSource(app.selected_source);
-    gravity.encoder.SetReverseDirection(app.encoder_reversed);
+  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++) {
+  for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
-        gravity.outputs[i].Low();
+    gravity.outputs[i].Low();
-    }
+  }
 }

firmware/Gravity/app_state.h

@@ -18,24 +18,27 @@
 
 // Global state for settings and app behavior.
 struct AppState {
-    int tempo = Clock::DEFAULT_TEMPO;
+  int tempo = Clock::DEFAULT_TEMPO;
-    Channel channel[Gravity::OUTPUT_COUNT];
+  Channel channel[Gravity::OUTPUT_COUNT];
-    byte selected_param = 0;
+  byte selected_param = 0;
-    byte selected_sub_param = 0;  // Temporary value for editing params.
+  byte selected_sub_param = 0; // Temporary value for editing params.
-    byte selected_channel = 0;    // 0=tempo, 1-6=output channel
+  byte selected_channel = 0;   // 0=tempo, 1-6=output channel
-    byte selected_swing = 0;
+  byte selected_swing = 0;
-    byte selected_save_slot = 0;  // The currently active save slot.
+  byte selected_save_slot = 0; // The currently active save slot.
-    Clock::Source selected_source = Clock::SOURCE_INTERNAL;
+  byte cv_run = 0;
-    Clock::Pulse selected_pulse = Clock::PULSE_PPQN_24;
+  byte cv_reset = 0;
-    bool editing_param = false;
+  Clock::Source selected_source = Clock::SOURCE_INTERNAL;
-    bool encoder_reversed = false;
+  Clock::Pulse selected_pulse = Clock::PULSE_PPQN_24;
-    bool refresh_screen = true;
+  bool editing_param = false;
+  bool encoder_reversed = false;
+  bool rotate_display = false;
+  bool refresh_screen = true;
 };
 
 extern AppState app;
 
-static Channel& GetSelectedChannel() {
+static Channel &GetSelectedChannel() {
-    return app.channel[app.selected_channel - 1];
+  return app.channel[app.selected_channel - 1];
 }
 
-#endif  // APP_STATE_H
+#endif // APP_STATE_H

firmware/Gravity/channel.h

@@ -15,19 +15,15 @@
 #include <Arduino.h>
 #include <libGravity.h>
 
-#include "euclidean.h"
-
 // Enums for CV Mod destination
 enum CvDestination : uint8_t {
-    CV_DEST_NONE,
+  CV_DEST_NONE,
-    CV_DEST_MOD,
+  CV_DEST_MOD,
-    CV_DEST_PROB,
+  CV_DEST_PROB,
-    CV_DEST_DUTY,
+  CV_DEST_DUTY,
-    CV_DEST_OFFSET,
+  CV_DEST_OFFSET,
-    CV_DEST_SWING,
+  CV_DEST_SWING,
-    CV_DEST_EUC_STEPS,
+  CV_DEST_LAST,
-    CV_DEST_EUC_HITS,
-    CV_DEST_LAST,
 };
 
 static const byte MOD_CHOICE_SIZE = 25;
@@ -45,274 +41,256 @@ 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)
     48, 32, 24, 16, 12, 8, 6, 4};
 
-static const byte DEFAULT_CLOCK_MOD_INDEX = 16;  // x1 or 96 PPQN.
+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:
+public:
-    Channel() {
+  Channel() { Init(); }
-        Init();
+
+  void Init() {
+    // Reset base values to their defaults
+    base_clock_mod_index = DEFAULT_CLOCK_MOD_INDEX;
+    base_probability = 100;
+    base_duty_cycle = 50;
+    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;
+
+    // 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();
+    }
+  }
+
+  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();
+    }
+  }
+
+  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(bool withCvMod = false) const {
+    return withCvMod ? cvmod_probability : base_probability;
+  }
+  int getDutyCycle(bool withCvMod = false) const {
+    return withCvMod ? cvmod_duty_cycle : base_duty_cycle;
+  }
+  int getOffset(bool withCvMod = false) const {
+    return withCvMod ? cvmod_offset : base_offset;
+  }
+  int getSwing(bool withCvMod = false) const {
+    return withCvMod ? cvmod_swing : base_swing;
+  }
+  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;
+  }
+
+  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;
     }
 
-    void Init() {
+    const uint16_t mod_pulses =
-        // Reset base values to their defaults
+        pgm_read_word_near(&CLOCK_MOD_PULSES[cvmod_clock_mod_index]);
-        base_clock_mod_index = DEFAULT_CLOCK_MOD_INDEX;
-        base_probability = 100;
-        base_duty_cycle = 50;
-        base_offset = 0;
-        base_swing = 50;
-        base_euc_steps = 1;
-        base_euc_hits = 1;
 
-        cvmod_clock_mod_index = base_clock_mod_index;
+    // Conditionally apply swing on down beats.
-        cvmod_probability = base_probability;
+    uint16_t swing_pulses = 0;
-        cvmod_duty_cycle = base_duty_cycle;
+    if (_swing_pulse_amount > 0 && (tick / mod_pulses) % 2 == 1) {
-        cvmod_offset = base_offset;
+      swing_pulses = _swing_pulse_amount;
-        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();
     }
 
-    // Setters (Set the BASE value)
+    // Duty cycle high check logic
-
+    const uint32_t current_tick_offset = tick + _offset_pulses + swing_pulses;
-    void setClockMod(int index) {
+    if (!output.On()) {
-        base_clock_mod_index = constrain(index, 0, MOD_CHOICE_SIZE - 1);
+      // Step check
-        if (!isCvModActive()) {
+      if (current_tick_offset % mod_pulses == 0) {
-            cvmod_clock_mod_index = base_clock_mod_index;
+        bool hit = cvmod_probability >= random(0, 100);
-            _recalculatePulses();
+        if (hit) {
+          output.High();
         }
+      }
     }
 
-    void setProbability(int prob) {
+    // Duty cycle low check
-        base_probability = constrain(prob, 0, 100);
+    const uint32_t duty_cycle_end_tick =
-        if (!isCvModActive()) {
+        tick + _duty_pulses + _offset_pulses + swing_pulses;
-            cvmod_probability = base_probability;
+    if (duty_cycle_end_tick % mod_pulses == 0) {
-            _recalculatePulses();
+      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;
     }
 
-    void setDutyCycle(int duty) {
+    int dest_mod = _calculateMod(CV_DEST_MOD, cv1_val, cv2_val,
-        base_duty_cycle = constrain(duty, 1, 99);
+                                 -(MOD_CHOICE_SIZE / 2), MOD_CHOICE_SIZE / 2);
-        if (!isCvModActive()) {
+    cvmod_clock_mod_index = constrain(base_clock_mod_index + dest_mod, 0, 100);
-            cvmod_duty_cycle = base_duty_cycle;
+
-            _recalculatePulses();
+    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() {
+    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 (cvmod_swing > 50) {
+      int shifted_swing = cvmod_swing - 50;
+      _swing_pulse_amount =
+          (long)((mod_pulses * (100L - shifted_swing)) / 100L);
+    } else {
+      _swing_pulse_amount = 0;
     }
+  }
 
-    void setOffset(int off) {
+  // User-settable base values.
-        base_offset = constrain(off, 0, 99);
+  byte base_clock_mod_index;
-        if (!isCvModActive()) {
+  byte base_probability;
-            cvmod_offset = base_offset;
+  byte base_duty_cycle;
-            _recalculatePulses();
+  byte base_offset;
-        }
+  byte base_swing;
-    }
-    void setSwing(int val) {
-        base_swing = constrain(val, 50, 95);
-        if (!isCvModActive()) {
-            cvmod_swing = base_swing;
-            _recalculatePulses();
-        }
-    }
 
-    // Euclidean
+  // Base value with cv mod applied.
-    void setSteps(int val) {
+  byte cvmod_clock_mod_index;
-        base_euc_steps = constrain(val, 1, MAX_PATTERN_LEN);
+  byte cvmod_probability;
-        if (cv1_dest != CV_DEST_EUC_STEPS && cv2_dest != CV_DEST_EUC_STEPS) {
+  byte cvmod_duty_cycle;
-            pattern.SetSteps(val);
+  byte cvmod_offset;
-        }
+  byte cvmod_swing;
-    }
-    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; }
+  // CV mod configuration
-    void setCv2Dest(CvDestination dest) { cv2_dest = dest; }
+  CvDestination cv1_dest;
-    CvDestination getCv1Dest() const { return cv1_dest; }
+  CvDestination cv2_dest;
-    CvDestination getCv2Dest() const { return cv2_dest; }
 
-    // Getters (Get the BASE value for editing or cv modded value for display)
+  // Mute channel flag
+  bool mute;
 
-    int getProbability(bool withCvMod = false) const { return withCvMod ? cvmod_probability : base_probability; }
+  // Pre-calculated pulse values for ISR performance
-    int getDutyCycle(bool withCvMod = false) const { return withCvMod ? cvmod_duty_cycle : base_duty_cycle; }
+  uint16_t _duty_pulses;
-    int getOffset(bool withCvMod = false) const { return withCvMod ? cvmod_offset : base_offset; }
+  uint16_t _offset_pulses;
-    int getSwing(bool withCvMod = false) const { return withCvMod ? cvmod_swing : base_swing; }
+  uint16_t _swing_pulse_amount;
-    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]);
-
-        // Conditionally apply swing on down beats.
-        uint16_t swing_pulses = 0;
-        if (_swing_pulse_amount > 0 && (tick / mod_pulses) % 2 == 1) {
-            swing_pulses = _swing_pulse_amount;
-        }
-
-        // Duty cycle high check logic
-        const uint32_t current_tick_offset = tick + _offset_pulses + swing_pulses;
-        if (!output.On()) {
-            // 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();
-                }
-            }
-        }
-
-        // Duty cycle low check
-        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;
-        }
-
-        int dest_mod = _calculateMod(CV_DEST_MOD, cv1_val, cv2_val, -(MOD_CHOICE_SIZE / 2), MOD_CHOICE_SIZE / 2);
-        cvmod_clock_mod_index = constrain(base_clock_mod_index + dest_mod, 0, 100);
-
-        int prob_mod = _calculateMod(CV_DEST_PROB, cv1_val, cv2_val, -50, 50);
-        cvmod_probability = constrain(base_probability + prob_mod, 0, 100);
-
-        int duty_mod = _calculateMod(CV_DEST_DUTY, cv1_val, cv2_val, -50, 50);
-        cvmod_duty_cycle = constrain(base_duty_cycle + duty_mod, 1, 99);
-
-        int offset_mod = _calculateMod(CV_DEST_OFFSET, cv1_val, cv2_val, -50, 50);
-        cvmod_offset = constrain(base_offset + offset_mod, 0, 99);
-
-        int swing_mod = _calculateMod(CV_DEST_SWING, cv1_val, cv2_val, -25, 25);
-        cvmod_swing = constrain(base_swing + swing_mod, 50, 95);
-
-        int step_mod = _calculateMod(CV_DEST_EUC_STEPS, cv1_val, cv2_val, 0, MAX_PATTERN_LEN);
-        pattern.SetSteps(base_euc_steps + step_mod);
-
-        int hit_mod = _calculateMod(CV_DEST_EUC_HITS, cv1_val, cv2_val, 0, 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 * (100L - cvmod_duty_cycle)) / 100L), 1L);
-        _offset_pulses = (long)((mod_pulses * (100L - cvmod_offset)) / 100L);
-
-        // Calculate the down beat swing amount.
-        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;
-        }
-    }
-
-    // User-settable base values.
-    byte base_clock_mod_index;
-    byte base_probability;
-    byte base_duty_cycle;
-    byte base_offset;
-    byte base_swing;
-    byte base_euc_steps;
-    byte base_euc_hits;
-
-    // Base value with cv mod applied.
-    byte cvmod_clock_mod_index;
-    byte cvmod_probability;
-    byte cvmod_duty_cycle;
-    byte cvmod_offset;
-    byte cvmod_swing;
-
-    // CV mod configuration
-    CvDestination cv1_dest;
-    CvDestination cv2_dest;
-
-    // Euclidean pattern
-    Pattern pattern;
-
-    // Mute channel flag
-    bool mute;
-
-    // Pre-calculated pulse values for ISR performance
-    uint16_t _duty_pulses;
-    uint16_t _offset_pulses;
-    uint16_t _swing_pulse_amount;
 };
 
-#endif  // CHANNEL_H
+#endif // CHANNEL_H

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"
+    "f\6.\5\211T\2/"
-    "\66J*\217\0\63\11\254l\66J\32\215\4\64\10\254l\242\34\272\0\65\11\254l\206\336h$\0\66"
+    "\6\244\354c\33\60\10\254\354T\64\223\2\61\7\353\354\222\254\6\62\11\254l"
-    "\11\254\354T^\61)\0\67\10\254lF\216u\4\70\11\254\354TL*&\5\71\11\254\354TL;"
+    "\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";
 
 /*
@@ -49,40 +56,61 @@ const uint8_t TEXT_FONT[437] U8G2_FONT_SECTION("velvetscreen") 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"
+    "\64B\214\30\22\223\220)"
-    "\272\272\275\311H\321g\343\306\1\60\37|\373\35CJT\20:fW\207\320\210\60\42\304\204\30D\247"
+    "Bj\10Q\232\214\42R\206\310\210\21d\304\30\32a\254\304\270!\0/\14"
-    "\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|"
+    "\272\272\275\311H\321g\343\306\1\60\37|\373\35CJT\20:"
-    "\373\35ShT\20:fl\344\14\211\231\301\306T\71\202#g\371\340\201\1\63\34|\373\35ShT"
+    "fW\207\320\210\60\42\304\204\30D\247"
-    "\20:fl\344@r\264\263\222\344,\215\35\42\241\6\225\31\0\64 |\373-!\203\206\214!\62\204"
+    "\214\331\354\20\11%"
-    "\314\220A#\10\215\30\65b\324\210Q\306\354\354\1\213\225\363\1\65\32|\373\15\25[\214\234/\10)"
+    "\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"
+    "\71\273;EbM\252\63\0\67\23|\373\205\25\17R\316\207\344\350p\312\201#"
-    "\35ShT\20:f\331!\22D\310 :\205\206\10\11B\307\354\354\20\11\65\250\314\0\71\32|\373"
+    "\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"
+    "j\310\250\21\343\354\335\203\357\354w\3B$}"
-    "\212\304\222MF\221\30v\316\236=\10\301b\11\0C\27}\33\236Si\226\20Bft\376O\211\215"
+    "\33\206Dj\226\214\42\61l\304\260\21\303F\14\33\61"
-    " Db\215\42$\0D\33}\33\206Dj\226\214\32\62l\304\260\21\343\354\177vl\304(\22K\324"
+    "\212\304\222MF\221\30v\316\236=\10\301b\11\0C\27}"
-    "$\2E\22|\373\205\17R\316KD\30\215\234_>x`\0F\20|\373\205\17R\316\227i\262\31"
+    "\33\236Si\226\20Bft\376O\211\215"
-    "\71\377\22\0I\7s\333\204\77HL\15{\333\205\201\363\377\77|\360`\0N$}\33\6\201\346\314"
+    " Db\215\42$\0D\33}\33\206Dj\226\214\32\62l\304\260\21\343\354\177vl\304("
-    "\35;\206\12U\242D&\306\230\30cd\210\221!fF\230\31a(+\314\256\63\67\0O\26}\33"
+    "\22K\324"
-    "\236Si\226\214\32\61\316\376\277\33\61j\310\232Tg\0R\61\216;\6Ek\230\14#\61n\304\270"
+    "$\2E\22|\373\205\17R\316KD\30\215\234_>x`\0F\20|"
-    "\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"
+    "\373\205\17R\316\227i\262\31"
-    "\334\301\1S\42\216;\236c\211\226\220\42\61n\304\270\21c\307R\232,[\262\203\307\216\65h\16\25"
+    "\71\377\22\0I\7s\333\204\77HL\15{\333\205\201\363\377\77|\360`\0N$}"
-    "\21&\253\320\0T\15}\33\206\17R\15\235\377\377\25\0U\21|\373\205a\366\377\237\215\30\64D\15"
+    "\33\6\201\346\314"
-    "*\63\0V\26\177\371\205\221\366\377\313\21\343\206\220\42C\25\11r'\313\16\3X)~;\206\201\6"
+    "\35;\206\12U\242D&\306\230\30cd\210\221!fF\230\31a(+\314\256\63\67\0O\26}"
-    "\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"
+    "\33"
-    "\302\1x\24\312\272\205A\206\216\220@c\212\224\31$S\14\262h\0\0\0\0\4\377\377\0";
+    "\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,
+    0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x7C, 0x00, 0xFC, 0x00,
-    0xFC, 0x0F, 0xFC, 0x0F, 0xFC, 0x03, 0xFC, 0x00, 0x7C, 0x00, 0x3C, 0x00,
+    0xFC, 0x03, 0xFC, 0x0F, 0xFC, 0x0F, 0xFC, 0x03, 0xFC, 0x00,
-    0x00, 0x00, 0x00, 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,
+    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, 0x38, 0x0E, 0x38, 0x0E, 0x38, 0x0E,
-    0x38, 0x0E, 0x00, 0x00};
+    0x38, 0x0E, 0x38, 0x0E, 0x38, 0x0E, 0x00, 0x00};
 
 // Constants for screen layout and fonts
 constexpr uint8_t SCREEN_CENTER_X = 32;
@@ -98,97 +126,101 @@ constexpr uint8_t CHANNEL_BOX_HEIGHT = 14;
 
 // Menu items for editing global parameters.
 enum ParamsMainPage : uint8_t {
-    PARAM_MAIN_TEMPO,
+  PARAM_MAIN_TEMPO,
-    PARAM_MAIN_SOURCE,
+  PARAM_MAIN_SOURCE,
-    PARAM_MAIN_PULSE,
+  PARAM_MAIN_RUN,
-    PARAM_MAIN_ENCODER_DIR,
+  PARAM_MAIN_RESET,
-    PARAM_MAIN_SAVE_DATA,
+  PARAM_MAIN_PULSE,
-    PARAM_MAIN_LOAD_DATA,
+  PARAM_MAIN_ENCODER_DIR,
-    PARAM_MAIN_RESET_STATE,
+  PARAM_MAIN_ROTATE_DISP,
-    PARAM_MAIN_FACTORY_RESET,
+  PARAM_MAIN_SAVE_DATA,
-    PARAM_MAIN_LAST,
+  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_MOD,
-    PARAM_CH_PROB,
+  PARAM_CH_PROB,
-    PARAM_CH_DUTY,
+  PARAM_CH_DUTY,
-    PARAM_CH_OFFSET,
+  PARAM_CH_OFFSET,
-    PARAM_CH_SWING,
+  PARAM_CH_SWING,
-    PARAM_CH_EUC_STEPS,
+  PARAM_CH_CV1_DEST,
-    PARAM_CH_EUC_HITS,
+  PARAM_CH_CV2_DEST,
-    PARAM_CH_CV1_DEST,
+  PARAM_CH_LAST,
-    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);
+  gravity.display.setFont(font);
-    int textWidth = gravity.display.getStrWidth(text);
+  int textWidth = gravity.display.getStrWidth(text);
-    gravity.display.drawStr(SCREEN_CENTER_X - (textWidth / 2), y, 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 textWidth = gravity.display.getStrWidth(text);
-    int drawX = (SCREEN_WIDTH - textWidth) - MENU_BOX_PADDING;
+  int drawX = (SCREEN_WIDTH - textWidth) - MENU_BOX_PADDING;
-    gravity.display.drawStr(drawX, y, text);
+  gravity.display.drawStr(drawX, y, text);
 }
 
 void drawMainSelection() {
-    gravity.display.setDrawColor(1);
+  gravity.display.setDrawColor(1);
-    const int tickSize = 3;
+  const int tickSize = 3;
-    const int mainWidth = SCREEN_WIDTH / 2;
+  const int mainWidth = SCREEN_WIDTH / 2;
-    const int mainHeight = 49;
+  const int mainHeight = 49;
-    gravity.display.drawLine(0, 0, tickSize, 0);
+  gravity.display.drawLine(0, 0, tickSize, 0);
-    gravity.display.drawLine(0, 0, 0, tickSize);
+  gravity.display.drawLine(0, 0, 0, tickSize);
-    gravity.display.drawLine(mainWidth, 0, mainWidth - tickSize, 0);
+  gravity.display.drawLine(mainWidth, 0, mainWidth - tickSize, 0);
-    gravity.display.drawLine(mainWidth, 0, mainWidth, tickSize);
+  gravity.display.drawLine(mainWidth, 0, mainWidth, tickSize);
-    gravity.display.drawLine(mainWidth, mainHeight, mainWidth, mainHeight - tickSize);
+  gravity.display.drawLine(mainWidth, mainHeight, mainWidth,
-    gravity.display.drawLine(mainWidth, mainHeight, mainWidth - tickSize, mainHeight);
+                           mainHeight - tickSize);
-    gravity.display.drawLine(0, mainHeight, tickSize, mainHeight);
+  gravity.display.drawLine(mainWidth, mainHeight, mainWidth - tickSize,
-    gravity.display.drawLine(0, mainHeight, 0, mainHeight - tickSize);
+                           mainHeight);
-    gravity.display.setDrawColor(2);
+  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
+  // Draw menu items
-    gravity.display.setFont(TEXT_FONT);
+  gravity.display.setFont(TEXT_FONT);
 
-    // Draw selected menu item box
+  // Draw selected menu item box
-    int selectedBoxY = 0;
+  int selectedBoxY = 0;
-    if (menu_size >= VISIBLE_MENU_ITEMS && app.selected_param == menu_size - 1) {
+  if (menu_size >= VISIBLE_MENU_ITEMS && app.selected_param == menu_size - 1) {
-        selectedBoxY = MENU_ITEM_HEIGHT * min(2, app.selected_param);
+    selectedBoxY = MENU_ITEM_HEIGHT * min(2, app.selected_param);
-    } else if (app.selected_param > 0) {
+  } else if (app.selected_param > 0) {
-        selectedBoxY = MENU_ITEM_HEIGHT;
+    selectedBoxY = MENU_ITEM_HEIGHT;
-    }
+  }
 
-    int boxX = MENU_BOX_WIDTH + 1;
+  int boxX = MENU_BOX_WIDTH + 1;
-    int boxY = selectedBoxY + 2;
+  int boxY = selectedBoxY + 2;
-    int boxWidth = MENU_BOX_WIDTH - 1;
+  int boxWidth = MENU_BOX_WIDTH - 1;
-    int boxHeight = MENU_ITEM_HEIGHT + 1;
+  int boxHeight = MENU_ITEM_HEIGHT + 1;
 
-    if (app.editing_param) {
+  if (app.editing_param) {
-        gravity.display.drawBox(boxX, boxY, boxWidth, boxHeight);
+    gravity.display.drawBox(boxX, boxY, boxWidth, boxHeight);
-        drawMainSelection();
+    drawMainSelection();
-    } else {
+  } else {
-        gravity.display.drawFrame(boxX, boxY, boxWidth, boxHeight);
+    gravity.display.drawFrame(boxX, boxY, boxWidth, boxHeight);
-    }
+  }
 
-    // Draw the visible menu items
+  // Draw the visible menu items
-    int start_index = 0;
+  int start_index = 0;
-    if (menu_size >= VISIBLE_MENU_ITEMS && app.selected_param == menu_size - 1) {
+  if (menu_size >= VISIBLE_MENU_ITEMS && app.selected_param == menu_size - 1) {
-        start_index = menu_size - VISIBLE_MENU_ITEMS;
+    start_index = menu_size - VISIBLE_MENU_ITEMS;
-    } else if (app.selected_param > 0) {
+  } else if (app.selected_param > 0) {
-        start_index = app.selected_param - 1;
+    start_index = app.selected_param - 1;
-    }
+  }
 
-    for (int i = 0; i < min(menu_size, VISIBLE_MENU_ITEMS); ++i) {
+  for (int i = 0; i < min(menu_size, VISIBLE_MENU_ITEMS); ++i) {
-        int idx = start_index + 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);
+  }
 }
 
 // Visual indicators for main section of screen.
@@ -197,294 +229,325 @@ 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()) {
+  switch (ch.getSwing()) {
-        case 58:  // 1/32nd
+  case 58: // 1/32nd
-        case 66:  // 1/16th
+  case 66: // 1/16th
-        case 75:  // 1/8th
+  case 75: // 1/8th
-            solidTick();
+    solidTick();
-            break;
+    break;
-        case 54:  // 1/32nd tripplet
+  case 54: // 1/32nd tripplet
-        case 62:  // 1/16th tripplet
+  case 62: // 1/16th tripplet
-        case 71:  // 1/8th tripplet
+  case 71: // 1/8th tripplet
-            hollowTick();
+    hollowTick();
-            break;
+    break;
-    }
+  }
 }
 
 // Human friendly display value for save slot.
 String displaySaveSlot(int slot) {
-    if (slot >= 0 && slot < StateManager::MAX_SAVE_SLOTS / 2) {
+  if (slot >= 0 && slot < StateManager::MAX_SAVE_SLOTS / 2) {
-        return String("A") + String(slot + 1);
+    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 &&
-        return String("B") + String(slot - (StateManager::MAX_SAVE_SLOTS / 2) + 1);
+             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.setFontMode(1);
-    gravity.display.setDrawColor(2);
+  gravity.display.setDrawColor(2);
-    gravity.display.setFont(TEXT_FONT);
+  gravity.display.setFont(TEXT_FONT);
 
-    // Display selected editable value
+  // Display selected editable value
-    String mainText;
+  String mainText;
-    String subText;
+  String subText;
 
-    switch (app.selected_param) {
+  switch (app.selected_param) {
-        case PARAM_MAIN_TEMPO:
+  case PARAM_MAIN_TEMPO:
-            // Serial MIDI is too unstable to display bpm in real time.
+    // Serial MIDI is too unstable to display bpm in real time.
-            if (app.selected_source == Clock::SOURCE_EXTERNAL_MIDI) {
+    if (app.selected_source == Clock::SOURCE_EXTERNAL_MIDI) {
-                mainText = F("EXT");
+      mainText = F("EXT");
-            } else {
+    } else {
-                mainText = String(gravity.clock.Tempo());
+      mainText = String(gravity.clock.Tempo());
-            }
-            subText = F("BPM");
-            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_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_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;
     }
+    subText = F("BPM");
+    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_RUN:
+    mainText = F("RUN");
+    switch (app.cv_run) {
+    case 0:
+      subText = F("NONE");
+      break;
+    case 1:
+      subText = F("CV 1");
+      break;
+    case 2:
+      subText = F("CV 2");
+      break;
+    }
+    break;
+  case PARAM_MAIN_RESET:
+    mainText = F("RST");
+    switch (app.cv_reset) {
+    case 0:
+      subText = F("NONE");
+      break;
+    case 1:
+      subText = F("CV 1");
+      break;
+    case 2:
+      subText = F("CV 2");
+      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(mainText.c_str(), MAIN_TEXT_Y, LARGE_FONT);
-    drawCenteredText(subText.c_str(), SUB_TEXT_Y, TEXT_FONT);
+  drawCenteredText(subText.c_str(), SUB_TEXT_Y, TEXT_FONT);
 
-    // Draw Main Page menu items
+  // Draw Main Page menu items
-    String menu_items[PARAM_MAIN_LAST] = {F("TEMPO"), F("SOURCE"), F("PULSE OUT"), F("ENCODER DIR"), F("SAVE"), F("LOAD"), F("RESET"), F("ERASE")};
+  String menu_items[PARAM_MAIN_LAST] = {
-    drawMenuItems(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.setFontMode(1);
-    gravity.display.setDrawColor(2);
+  gravity.display.setDrawColor(2);
 
-    // Display selected editable value
+  // Display selected editable value
-    String mainText;
+  String mainText;
-    String subText;
+  String subText;
 
-    // When editing a param, just show the base value. When not editing show
+  // When editing a param, just show the base value. When not editing show
-    // the value with cv mod.
+  // the value with cv mod.
-    bool withCvMod = !app.editing_param;
+  bool withCvMod = !app.editing_param;
 
-    switch (app.selected_param) {
+  switch (app.selected_param) {
-        case PARAM_CH_MOD: {
+  case PARAM_CH_MOD: {
-            int mod_value = ch.getClockMod(withCvMod);
+    int mod_value = ch.getClockMod(withCvMod);
-            if (mod_value > 1) {
+    if (mod_value > 1) {
-                mainText = F("/");
+      mainText = F("/");
-                mainText += String(mod_value);
+      mainText += String(mod_value);
-                subText = F("DIVIDE");
+      subText = F("DIVIDE");
-            } else {
+    } else {
-                mainText = F("x");
+      mainText = F("x");
-                mainText += String(abs(mod_value));
+      mainText += String(abs(mod_value));
-                subText = F("MULTIPLY");
+      subText = F("MULTIPLY");
-            }
-            break;
-        }
-        case PARAM_CH_PROB:
-            mainText = String(ch.getProbability(withCvMod)) + F("%");
-            subText = F("HIT CHANCE");
-            break;
-        case PARAM_CH_DUTY:
-            mainText = String(ch.getDutyCycle(withCvMod)) + F("%");
-            subText = F("PULSE WIDTH");
-            break;
-        case PARAM_CH_OFFSET:
-            mainText = String(ch.getOffset(withCvMod)) + F("%");
-            subText = F("SHIFT HIT");
-            break;
-        case PARAM_CH_SWING:
-            ch.getSwing() == 50
-                ? mainText = F("OFF")
-                : mainText = String(ch.getSwing(withCvMod)) + F("%");
-            subText = "DOWN BEAT";
-            swingDivisionMark();
-            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_PROB:
-                    subText = F("PROBABILITY");
-                    break;
-                case CV_DEST_DUTY:
-                    subText = F("DUTY CYCLE");
-                    break;
-                case CV_DEST_OFFSET:
-                    subText = F("OFFSET");
-                    break;
-                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;
-        }
     }
+    break;
+  }
+  case PARAM_CH_PROB:
+    mainText = String(ch.getProbability(withCvMod)) + F("%");
+    subText = F("HIT CHANCE");
+    break;
+  case PARAM_CH_DUTY:
+    mainText = String(ch.getDutyCycle(withCvMod)) + F("%");
+    subText = F("PULSE WIDTH");
+    break;
+  case PARAM_CH_OFFSET:
+    mainText = String(ch.getOffset(withCvMod)) + F("%");
+    subText = F("SHIFT HIT");
+    break;
+  case PARAM_CH_SWING:
+    ch.getSwing() == 50 ? mainText = F("OFF")
+                        : mainText = String(ch.getSwing(withCvMod)) + F("%");
+    subText = "DOWN BEAT";
+    swingDivisionMark();
+    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_PROB:
+      subText = F("PROBABILITY");
+      break;
+    case CV_DEST_DUTY:
+      subText = F("DUTY CYCLE");
+      break;
+    case CV_DEST_OFFSET:
+      subText = F("OFFSET");
+      break;
+    case CV_DEST_SWING:
+      subText = F("SWING");
+      break;
+    }
+    break;
+  }
+  }
 
-    drawCenteredText(mainText.c_str(), MAIN_TEXT_Y, LARGE_FONT);
+  drawCenteredText(mainText.c_str(), MAIN_TEXT_Y, LARGE_FONT);
-    drawCenteredText(subText.c_str(), SUB_TEXT_Y, TEXT_FONT);
+  drawCenteredText(subText.c_str(), SUB_TEXT_Y, TEXT_FONT);
 
-    // Draw Channel Page menu items
+  // Draw Channel Page menu items
-    String menu_items[PARAM_CH_LAST] = {
+  String menu_items[PARAM_CH_LAST] = {
-        F("MOD"), F("PROBABILITY"), F("DUTY"), F("OFFSET"), F("SWING"), F("EUCLID STEPS"),
+      F("MOD"),   F("PROBABILITY"), F("DUTY"),   F("OFFSET"),
-        F("EUCLID HITS"), F("CV1 MOD"), F("CV2 MOD")};
+      F("SWING"), F("CV1 MOD"),     F("CV2 MOD")};
-    drawMenuItems(menu_items, PARAM_CH_LAST);
+  drawMenuItems(menu_items, PARAM_CH_LAST);
 }
 
 void DisplaySelectedChannel() {
-    int boxX = CHANNEL_BOX_WIDTH;
+  int boxX = CHANNEL_BOX_WIDTH;
-    int boxY = CHANNEL_BOXES_Y;
+  int boxY = CHANNEL_BOXES_Y;
-    int boxWidth = CHANNEL_BOX_WIDTH;
+  int boxWidth = CHANNEL_BOX_WIDTH;
-    int boxHeight = CHANNEL_BOX_HEIGHT;
+  int boxHeight = CHANNEL_BOX_HEIGHT;
-    int textOffset = 7;  // Half of font width
+  int textOffset = 7; // Half of font width
 
-    // Draw top and right side of frame.
+  // Draw top and right side of frame.
-    gravity.display.drawHLine(1, boxY, SCREEN_WIDTH - 2);
+  gravity.display.drawHLine(1, boxY, SCREEN_WIDTH - 2);
-    gravity.display.drawVLine(SCREEN_WIDTH - 2, boxY, boxHeight);
+  gravity.display.drawVLine(SCREEN_WIDTH - 2, boxY, boxHeight);
 
-    for (int i = 0; i < Gravity::OUTPUT_COUNT + 1; i++) {
+  for (int i = 0; i < Gravity::OUTPUT_COUNT + 1; i++) {
-        // Draw box frame or filled selected box.
+    // Draw box frame or filled selected box.
-        gravity.display.setDrawColor(1);
+    gravity.display.setDrawColor(1);
-        (app.selected_channel == i)
+    (app.selected_channel == i)
-            ? gravity.display.drawBox(i * boxWidth, boxY, boxWidth, boxHeight)
+        ? gravity.display.drawBox(i * boxWidth, boxY, boxWidth, boxHeight)
-            : gravity.display.drawVLine(i * boxWidth, boxY, boxHeight);
+        : gravity.display.drawVLine(i * boxWidth, boxY, boxHeight);
 
-        // Draw clock status icon or each channel number.
+    // Draw clock status icon or each channel number.
-        gravity.display.setDrawColor(2);
+    gravity.display.setDrawColor(2);
-        if (i == 0) {
+    if (i == 0) {
-            gravity.display.setBitmapMode(1);
+      gravity.display.setBitmapMode(1);
-            auto icon = gravity.clock.IsPaused() ? pause_icon : play_icon;
+      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,
-        } else {
+                               icon);
-            gravity.display.setFont(TEXT_FONT);
+    } else {
-            gravity.display.setCursor((i * boxWidth) + textOffset, SCREEN_HEIGHT - 3);
+      gravity.display.setFont(TEXT_FONT);
-            gravity.display.print(i);
+      gravity.display.setCursor((i * boxWidth) + textOffset, SCREEN_HEIGHT - 3);
-        }
+      gravity.display.print(i);
     }
+  }
 }
 
 void UpdateDisplay() {
-    app.refresh_screen = false;
+  app.refresh_screen = false;
-    gravity.display.firstPage();
+  gravity.display.firstPage();
-    do {
+  do {
-        if (app.selected_channel == 0) {
+    if (app.selected_channel == 0) {
-            DisplayMainPage();
+      DisplayMainPage();
-        } else {
+    } else {
-            DisplayChannelPage();
+      DisplayChannelPage();
-        }
+    }
-        // Global channel select UI.
+    // Global channel select UI.
-            DisplaySelectedChannel();
+    DisplaySelectedChannel();
-    } while (gravity.display.nextPage());
+  } while (gravity.display.nextPage());
 }
 
 void Bootsplash() {
-    gravity.display.firstPage();
+  gravity.display.firstPage();
-    do {
+  do {
-        int textWidth;
+    int textWidth;
-        String loadingText = F("LOADING....");
+    String loadingText = F("LOADING....");
-        gravity.display.setFont(TEXT_FONT);
+    gravity.display.setFont(TEXT_FONT);
 
-        textWidth = gravity.display.getStrWidth(StateManager::SKETCH_NAME);
+    textWidth = gravity.display.getStrWidth(StateManager::SKETCH_NAME);
-        gravity.display.drawStr(16 + (textWidth / 2), 20, StateManager::SKETCH_NAME);
+    gravity.display.drawStr(16 + (textWidth / 2), 20,
+                            StateManager::SKETCH_NAME);
 
-        textWidth = gravity.display.getStrWidth(StateManager::SEMANTIC_VERSION);
+    textWidth = gravity.display.getStrWidth(StateManager::SEMANTIC_VERSION);
-        gravity.display.drawStr(16 + (textWidth / 2), 32, StateManager::SEMANTIC_VERSION);
+    gravity.display.drawStr(16 + (textWidth / 2), 32,
+                            StateManager::SEMANTIC_VERSION);
 
-        textWidth = gravity.display.getStrWidth(loadingText.c_str());
+    textWidth = gravity.display.getStrWidth(loadingText.c_str());
-        gravity.display.drawStr(26 + (textWidth / 2), 44, loadingText.c_str());
+    gravity.display.drawStr(26 + (textWidth / 2), 44, loadingText.c_str());
-    } while (gravity.display.nextPage());
+  } while (gravity.display.nextPage());
 }
 
-#endif  // DISPLAY_H
+#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[] = "V2.0.0BETA3";  // 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,190 +34,206 @@ 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) {
-    if (_isDataValid()) {
+  noInterrupts();
-        // Load global settings.
+  bool success = false;
-        _loadMetadata(app);
+  if (_isDataValid()) {
-        // Load app data from the transient slot.
+    // Load global settings.
-        _loadState(app, TRANSIENT_SLOT);
+    _loadMetadata(app);
-        return true;
+    // Load app data from the transient slot.
-    }
+    _loadState(app, TRANSIENT_SLOT);
-    // EEPROM does not contain save data for this firmware & version.
+    success = true;
-    else {
+  }
-        // Erase EEPROM and initialize state. Save default pattern to all save slots.
+  // EEPROM does not contain save data for this firmware & version.
-        factoryReset(app);
+  else {
-        return false;
+    // 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) {
+bool StateManager::loadData(AppState &app, byte slot_index) {
-    // Check if slot_index is within max range + 1 for transient.
+  // 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();
-    _loadState(app, slot_index);
-    app.selected_save_slot = slot_index;
-    // Persist this change in the global metadata.
-    _saveMetadata(app);
 
-    return true;
+  // 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) {
+void StateManager::saveData(const AppState &app) {
-    // Check if slot_index is within max range + 1 for transient.
+  noInterrupts();
-    if (app.selected_save_slot >= MAX_SAVE_SLOTS + 1) return;
+  // 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);
+  _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();
+  }
 }
 
-// Save transient state if it has changed and enough time has passed since last save.
+void StateManager::reset(AppState &app) {
-void StateManager::update(const AppState& app) {
+  noInterrupts();
-    if (_isDirty && (millis() - _lastChangeTime > SAVE_DELAY_MS)) {
-        _saveState(app, TRANSIENT_SLOT);
-        _saveMetadata(app);
-        _isDirty = false;
-    }
-}
 
-void StateManager::reset(AppState& app) {
+  AppState default_app;
-    AppState default_app;
+  app.tempo = default_app.tempo;
-    app.tempo = default_app.tempo;
+  app.selected_param = default_app.selected_param;
-    app.selected_param = default_app.selected_param;
+  app.selected_channel = default_app.selected_channel;
-    app.selected_channel = default_app.selected_channel;
+  app.selected_source = default_app.selected_source;
-    app.selected_source = default_app.selected_source;
+  app.selected_pulse = default_app.selected_pulse;
-    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++) {
+  for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
-        app.channel[i].Init();
+    app.channel[i].Init();
-    }
+  }
 
-    // Load global settings from Metadata
+  // Load global settings from Metadata
-    _loadMetadata(app);
+  _loadMetadata(app);
 
-    _isDirty = false;
+  _isDirty = false;
+  interrupts();
 }
 
 void StateManager::markDirty() {
-    _isDirty = true;
+  _isDirty = true;
-    _lastChangeTime = millis();
+  _lastChangeTime = millis();
 }
 
 // Erases all data in the EEPROM by writing 0 to every address.
-void StateManager::factoryReset(AppState& app) {
+void StateManager::factoryReset(AppState &app) {
-    noInterrupts();
+  noInterrupts();
-    for (unsigned int i = 0; i < EEPROM.length(); i++) {
+  for (unsigned int i = 0; i < EEPROM.length(); i++) {
-        EEPROM.write(i, 0);
+    EEPROM.write(i, 0);
-    }
+  }
-    // Initialize eeprom and save default patter to all save slots.
+  // Initialize eeprom and save default patter to all save slots.
-    _saveMetadata(app);
+  _saveMetadata(app);
-    reset(app);
+  reset(app);
-    for (int i = 0; i < MAX_SAVE_SLOTS; i++) {
+  for (int i = 0; i < MAX_SAVE_SLOTS; i++) {
-        app.selected_save_slot = i;
+    app.selected_save_slot = i;
-        _saveState(app, i);
+    _saveState(app, i);
-    }
+  }
-    _saveState(app, TRANSIENT_SLOT);
+  _saveState(app, TRANSIENT_SLOT);
-    interrupts();
+  interrupts();
 }
 
 bool StateManager::_isDataValid() {
-    Metadata metadata;
+  Metadata metadata;
-    EEPROM.get(METADATA_START_ADDR, metadata);
+  EEPROM.get(METADATA_START_ADDR, metadata);
-    bool name_match = (strcmp(metadata.sketch_name, SKETCH_NAME) == 0);
+  bool name_match = (strcmp(metadata.sketch_name, SKETCH_NAME) == 0);
-    bool version_match = (strcmp(metadata.version, SEMANTIC_VERSION) == 0);
+  bool version_match = (strcmp(metadata.version, SEMANTIC_VERSION) == 0);
-    return name_match && version_match;
+  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.
+  // 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;
-    static EepromData save_data;
 
-    save_data.tempo = app.tempo;
+  save_data.tempo = app.tempo;
-    save_data.selected_param = app.selected_param;
+  save_data.selected_param = app.selected_param;
-    save_data.selected_channel = app.selected_channel;
+  save_data.selected_channel = app.selected_channel;
-    save_data.selected_source = static_cast<byte>(app.selected_source);
+  save_data.selected_source = static_cast<byte>(app.selected_source);
-    save_data.selected_pulse = static_cast<byte>(app.selected_pulse);
+  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
+  // TODO: break this out into a separate function. Save State should be
-    // broken out into global / per-channel save methods. When saving via
+  // broken out into global / per-channel save methods. When saving via
-    // "update" only save state for the current channel since other channels
+  // "update" only save state for the current channel since other channels
-    // will not have changed when saving user edits.
+  // will not have changed when saving user edits.
-    for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
+  for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
-        const auto& ch = app.channel[i];
+    const auto &ch = app.channel[i];
-        auto& save_ch = save_data.channel_data[i];
+    auto &save_ch = save_data.channel_data[i];
-        save_ch.base_clock_mod_index = ch.getClockModIndex(false);
+    save_ch.base_clock_mod_index = ch.getClockModIndex(false);
-        save_ch.base_probability = ch.getProbability(false);
+    save_ch.base_probability = ch.getProbability(false);
-        save_ch.base_duty_cycle = ch.getDutyCycle(false);
+    save_ch.base_duty_cycle = ch.getDutyCycle(false);
-        save_ch.base_offset = ch.getOffset(false);
+    save_ch.base_offset = ch.getOffset(false);
-        save_ch.base_swing = ch.getSwing(false);
+    save_ch.cv1_dest = static_cast<byte>(ch.getCv1Dest());
-        save_ch.base_euc_steps = ch.getSteps(false);
+    save_ch.cv2_dest = static_cast<byte>(ch.getCv2Dest());
-        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));
+  int address = EEPROM_DATA_START_ADDR + (slot_index * sizeof(EepromData));
-    EEPROM.put(address, save_data);
+  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.
+  // 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;
-    static EepromData load_data;
+  int address = EEPROM_DATA_START_ADDR + (slot_index * sizeof(EepromData));
-    int address = EEPROM_DATA_START_ADDR + (slot_index * sizeof(EepromData));
+  EEPROM.get(address, load_data);
-    EEPROM.get(address, load_data);
 
-    // Restore app state from loaded data.
+  // Restore app state from loaded data.
-    app.tempo = load_data.tempo;
+  app.tempo = load_data.tempo;
-    app.selected_param = load_data.selected_param;
+  app.selected_param = load_data.selected_param;
-    app.selected_channel = load_data.selected_channel;
+  app.selected_channel = load_data.selected_channel;
-    app.selected_source = static_cast<Clock::Source>(load_data.selected_source);
+  app.selected_source = static_cast<Clock::Source>(load_data.selected_source);
-    app.selected_pulse = static_cast<Clock::Pulse>(load_data.selected_pulse);
+  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++) {
+  for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
-        auto& ch = app.channel[i];
+    auto &ch = app.channel[i];
-        const auto& saved_ch_state = load_data.channel_data[i];
+    const auto &saved_ch_state = load_data.channel_data[i];
 
-        ch.setClockMod(saved_ch_state.base_clock_mod_index);
+    ch.setClockMod(saved_ch_state.base_clock_mod_index);
-        ch.setProbability(saved_ch_state.base_probability);
+    ch.setProbability(saved_ch_state.base_probability);
-        ch.setDutyCycle(saved_ch_state.base_duty_cycle);
+    ch.setDutyCycle(saved_ch_state.base_duty_cycle);
-        ch.setOffset(saved_ch_state.base_offset);
+    ch.setOffset(saved_ch_state.base_offset);
-        ch.setSwing(saved_ch_state.base_swing);
+    ch.setCv1Dest(static_cast<CvDestination>(saved_ch_state.cv1_dest));
-        ch.setSteps(saved_ch_state.base_euc_steps);
+    ch.setCv2Dest(static_cast<CvDestination>(saved_ch_state.cv2_dest));
-        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) {
+void StateManager::_saveMetadata(const AppState &app) {
-    noInterrupts();
+  Metadata current_meta;
-    Metadata current_meta;
+  strcpy(current_meta.sketch_name, SKETCH_NAME);
-    strcpy(current_meta.sketch_name, SKETCH_NAME);
+  strcpy(current_meta.version, SEMANTIC_VERSION);
-    strcpy(current_meta.version, SEMANTIC_VERSION);
 
-    // Global user settings
+  // Global user settings
-    current_meta.selected_save_slot = app.selected_save_slot;
+  current_meta.selected_save_slot = app.selected_save_slot;
-    current_meta.encoder_reversed = app.encoder_reversed;
+  current_meta.encoder_reversed = app.encoder_reversed;
+  current_meta.rotate_display = app.rotate_display;
 
-    EEPROM.put(METADATA_START_ADDR, current_meta);
+  EEPROM.put(METADATA_START_ADDR, current_meta);
-    interrupts();
 }
 
-void StateManager::_loadMetadata(AppState& app) {
+void StateManager::_loadMetadata(AppState &app) {
-    noInterrupts();
+  Metadata metadata;
-    Metadata metadata;
+  EEPROM.get(METADATA_START_ADDR, metadata);
-    EEPROM.get(METADATA_START_ADDR, metadata);
+  app.selected_save_slot = metadata.selected_save_slot;
-    app.selected_save_slot = metadata.selected_save_slot;
+  app.encoder_reversed = metadata.encoder_reversed;
-    app.encoder_reversed = metadata.encoder_reversed;
+  app.rotate_display = metadata.rotate_display;
-    interrupts();
 }

firmware/Gravity/save_state.h

@@ -19,79 +19,79 @@
 struct AppState;
 
 /**
- * @brief Manages saving and loading of the application state to and from EEPROM.
+ * @brief Manages saving and loading of the application state to and from
- * The number of user slots is defined by MAX_SAVE_SLOTS, and one additional slot
+ * EEPROM. The number of user slots is defined by MAX_SAVE_SLOTS, and one
- * is reseved for transient state to persist state between power cycles before
+ * additional slot is reseved for transient state to persist state between power
- * state is explicitly saved to a user slot. Metadata is stored in the beginning
+ * cycles before state is explicitly saved to a user slot. Metadata is stored in
- * of the memory space which stores firmware version information to validate that
+ * the beginning of the memory space which stores firmware version information
- * the data can be loaded into the current version of AppState.
+ * 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 SKETCH_NAME[];
-    static const char SEMANTIC_VERSION[];
+  static const char SEMANTIC_VERSION[];
-    static const byte MAX_SAVE_SLOTS;
+  static const byte MAX_SAVE_SLOTS;
-    static const byte TRANSIENT_SLOT;
+  static const byte TRANSIENT_SLOT;
 
-    StateManager();
+  StateManager();
 
-    // Populate the AppState instance with values from EEPROM if they exist.
+  // Populate the AppState instance with values from EEPROM if they exist.
-    bool initialize(AppState& app);
+  bool initialize(AppState &app);
-    // Load data from specified slot.
+  // Load data from specified slot.
-    bool loadData(AppState& app, byte slot_index);
+  bool loadData(AppState &app, byte slot_index);
-    // Save data to specified slot.
+  // Save data to specified slot.
-    void saveData(const AppState& app);
+  void saveData(const AppState &app);
-    // Reset AppState instance back to default values.
+  // 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.
+  // 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.
+  // Indicate that state has changed and we should save.
-    void markDirty();
+  void markDirty();
-    // Erase all data stored in the EEPROM.
+  // 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.
+  // This struct holds the data that identifies the firmware version.
-    struct Metadata {
+  struct Metadata {
-        char sketch_name[16];
+    char sketch_name[16];
-        char version[16];
+    char version[16];
-        // Additional global/hardware settings
+    // Additional global/hardware settings
-        byte selected_save_slot;
+    byte selected_save_slot;
-        bool encoder_reversed;
+    bool encoder_reversed;
-    };
+    bool rotate_display;
-    struct ChannelState {
+  };
-        byte base_clock_mod_index;
+  struct ChannelState {
-        byte base_probability;
+    byte base_clock_mod_index;
-        byte base_duty_cycle;
+    byte base_probability;
-        byte base_offset;
+    byte base_duty_cycle;
-        byte base_swing;
+    byte base_offset;
-        byte base_euc_steps;
+    byte cv1_dest; // Cast the CvDestination enum as a byte for storage
-        byte base_euc_hits;
+    byte cv2_dest; // Cast the CvDestination enum as a byte for storage
-        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 {
-    // This struct holds all the parameters we want to save.
+    int tempo;
-    struct EepromData {
+    byte selected_param;
-        int tempo;
+    byte selected_channel;
-        byte selected_param;
+    byte selected_source;
-        byte selected_channel;
+    byte selected_pulse;
-        byte selected_source;
+    byte cv_run;
-        byte selected_pulse;
+    byte cv_reset;
-        ChannelState channel_data[Gravity::OUTPUT_COUNT];
+    ChannelState channel_data[Gravity::OUTPUT_COUNT];
-    };
+  };
 
-   private:
+private:
-    bool _isDataValid();
+  bool _isDataValid();
-    void _saveMetadata(const AppState& app);
+  void _saveMetadata(const AppState &app);
-    void _loadMetadata(AppState& app);
+  void _loadMetadata(AppState &app);
-    void _saveState(const AppState& app, byte slot_index);
+  void _saveState(const AppState &app, byte slot_index);
-    void _loadState(AppState& app, byte slot_index);
+  void _loadState(AppState &app, byte slot_index);
 
-    static const unsigned long SAVE_DELAY_MS;
+  static const unsigned long SAVE_DELAY_MS;
-    static const int METADATA_START_ADDR;
+  static const int METADATA_START_ADDR;
-    static const int EEPROM_DATA_START_ADDR;
+  static const int EEPROM_DATA_START_ADDR;
 
-    bool _isDirty;
+  bool _isDirty;
-    unsigned long _lastChangeTime;
+  unsigned long _lastChangeTime;
 };
 
-#endif  // SAVE_STATE_H
+#endif // SAVE_STATE_H

library.properties

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

src/README.md

@@ -1,343 +0,0 @@
-# libGravity API Reference
-
-This document provides API documentation for `libGravity`, a library for building custom scripts for the Sitka Instruments Gravity module.
-
-## `Gravity` Class
-
-The `Gravity` class is the main hardware abstraction wrapper for the module. It provides a central point of access to all of the module's hardware components like the display, clock, inputs, and outputs.
-
-A global instance of this class, `gravity`, is created for you to use in your scripts.
-
-```cpp
-// Global instance
-extern Gravity gravity;
-```
-
-### Public Methods
-
-#### `void Init()`
-
-Initializes the Arduino and all the Gravity hardware components. This should be called once in your `setup()` function.
-
-#### `void Process()`
-
-Performs a polling check for state changes on all inputs and outputs. This should be called repeatedly in your main `loop()` function to ensure all components are responsive.
-
-### Public Properties
-
-  * `U8G2_SSD1306_128X64_NONAME_1_HW_I2C display`
-      * OLED display object from the `U8g2lib` library. Use this to draw to the screen.
-  * `Clock clock`
-      * The main clock source wrapper. See the [Clock Class](https://www.google.com/search?q=%23clock-class) documentation for details.
-  * `DigitalOutput outputs[OUTPUT_COUNT]`
-      * An array of `DigitalOutput` objects, where `OUTPUT_COUNT` is 6. Each element corresponds to one of the six gate/trigger outputs.
-  * `DigitalOutput pulse`
-      * A `DigitalOutput` object for the MIDI Expander module's pulse output.
-  * `Encoder encoder`
-      * The rotary encoder with a built-in push button. See the [Encoder Class](https://www.google.com/search?q=%23encoder-class) documentation for details.
-  * `Button shift_button`
-      * A `Button` object for the 'Shift' button.
-  * `Button play_button`
-      * A `Button` object for the 'Play' button.
-  * `AnalogInput cv1`
-      * An `AnalogInput` object for the CV1 input jack.
-  * `AnalogInput cv2`
-      * An `AnalogInput` object for the CV2 input jack.
-
-## `AnalogInput` Class
-
-This class handles reading and processing the analog CV inputs. It includes features for calibration, offsetting, and attenuation.
-
-### Public Methods
-
-#### `void Init(uint8_t pin)`
-
-Initializes the analog input on a specific pin.
-
-  * **Parameters:**
-      * `pin`: The GPIO pin for the analog input.
-
-#### `void Process()`
-
-Reads the raw value from the ADC, applies calibration, offset, and attenuation/inversion. This must be called regularly in the main loop.
-
-#### `void AdjustCalibrationLow(int amount)`
-
-Adjusts the low calibration point to fine-tune the input mapping.
-
-  * **Parameters:**
-      * `amount`: The amount to add to the current low calibration value.
-
-#### `void AdjustCalibrationHigh(int amount)`
-
-Adjusts the high calibration point to fine-tune the input mapping.
-
-  * **Parameters:**
-      * `amount`: The amount to add to the current high calibration value.
-
-#### `void SetOffset(float percent)`
-
-Sets a DC offset for the input signal.
-
-  * **Parameters:**
-      * `percent`: A percentage (e.g., `0.5` for 50%) to shift the signal.
-
-#### `void SetAttenuation(float percent)`
-
-Sets the attenuation (scaling) of the input signal. A negative percentage will also invert the signal.
-
-  * **Parameters:**
-      * `percent`: The attenuation level, typically from `0.0` to `1.0`.
-
-#### `int16_t Read()`
-
-Gets the current processed value of the analog input.
-
-  * **Returns:** The read value, scaled to a range of +/-512.
-
-#### `float Voltage()`
-
-Gets the analog read value as a voltage.
-
-  * **Returns:** A `float` representing the calculated voltage (-5.0V to +5.0V).
-
-## `Button` Class
-
-A wrapper class for handling digital inputs like push buttons, including debouncing and long-press detection.
-
-### Enums
-
-#### `enum ButtonChange`
-
-Constants representing a change in the button's state.
-
-  * `CHANGE_UNCHANGED`
-  * `CHANGE_PRESSED`
-  * `CHANGE_RELEASED` (a normal, short press)
-  * `CHANGE_RELEASED_LONG` (a long press)
-
-### Public Methods
-
-#### `void Init(uint8_t pin)`
-
-Initializes the button on a specific GPIO pin.
-
-  * **Parameters:**
-      * `pin`: The GPIO pin for the button.
-
-#### `void AttachPressHandler(void (*f)())`
-
-Attaches a callback function to be executed on a short button press.
-
-  * **Parameters:**
-      * `f`: The function to call.
-
-#### `void AttachLongPressHandler(void (*f)())`
-
-Attaches a callback function to be executed on a long button press.
-
-  * **Parameters:**
-      * `f`: The function to call.
-
-#### `void Process()`
-
-Reads the button's state and handles debouncing and press detection. Call this repeatedly in the main loop.
-
-#### `ButtonChange Change()`
-
-Gets the last state change of the button.
-
-  * **Returns:** A `ButtonChange` enum value indicating the last detected change.
-
-#### `bool On()`
-
-Checks the current physical state of the button.
-
-  * **Returns:** `true` if the button is currently being held down, `false` otherwise.
-
-## `Clock` Class
-
-A wrapper for all clock and timing functions, supporting internal, external, and MIDI clock sources.
-
-### Enums
-
-#### `enum Source`
-
-Defines the possible clock sources.
-
-  * `SOURCE_INTERNAL`
-  * `SOURCE_EXTERNAL_PPQN_24` (24 pulses per quarter note)
-  * `SOURCE_EXTERNAL_PPQN_4` (4 pulses per quarter note)
-  * `SOURCE_EXTERNAL_MIDI`
-
-#### `enum Pulse`
-
-Defines the possible pulse-per-quarter-note rates for the pulse output.
-
-  * `PULSE_NONE`
-  * `PULSE_PPQN_1`
-  * `PULSE_PPQN_4`
-  * `PULSE_PPQN_24`
-
-### Public Methods
-
-#### `void Init()`
-
-Initializes the clock, sets up MIDI serial, and sets default values.
-
-#### `void AttachExtHandler(void (*callback)())`
-
-Attaches a user-defined callback to the external clock input. This is triggered by a rising edge on the external clock pin or by an incoming MIDI clock message.
-
-  * **Parameters:**
-      * `callback`: The function to call on an external clock event.
-
-#### `void AttachIntHandler(void (*callback)(uint32_t))`
-
-Sets a callback function that is triggered at the high-resolution internal clock rate (PPQN\_96). This is the main internal timing callback.
-
-  * **Parameters:**
-      * `callback`: The function to call on every internal clock tick. It receives the tick count as a `uint32_t` parameter.
-
-#### `void SetSource(Source source)`
-
-Sets the clock's driving source.
-
-  * **Parameters:**
-      * `source`: The new clock source from the `Source` enum.
-
-#### `bool ExternalSource()`
-
-Checks if the clock source is external.
-
-  * **Returns:** `true` if the source is external (PPQN or MIDI).
-
-#### `bool InternalSource()`
-
-Checks if the clock source is internal.
-
-  * **Returns:** `true` if the source is the internal master clock.
-
-#### `int Tempo()`
-
-Gets the current tempo.
-
-  * **Returns:** The current tempo in beats per minute (BPM).
-
-#### `void SetTempo(int tempo)`
-
-Sets the clock tempo when in internal mode.
-
-  * **Parameters:**
-      * `tempo`: The new tempo in BPM.
-
-#### `void Tick()`
-
-Manually triggers a clock tick. This should be called from your external clock handler to drive the internal timing when in an external clock mode.
-
-#### `void Start()`
-
-Starts the clock.
-
-#### `void Stop()`
-
-Stops (pauses) the clock.
-
-#### `void Reset()`
-
-Resets all clock counters to zero.
-
-#### `bool IsPaused()`
-
-Checks if the clock is currently paused.
-
-  * **Returns:** `true` if the clock is stopped.
-
-## `DigitalOutput` Class
-
-This class is used to control the digital gate/trigger outputs.
-
-### Public Methods
-
-#### `void Init(uint8_t cv_pin)`
-
-Initializes a digital output on a specific pin.
-
-  * **Parameters:**
-      * `cv_pin`: The GPIO pin for the CV/Gate output.
-
-#### `void SetTriggerDuration(uint8_t duration_ms)`
-
-Sets the duration for triggers. When `Trigger()` is called, the output will remain high for this duration.
-
-  * **Parameters:**
-      * `duration_ms`: The trigger duration in milliseconds.
-
-#### `void Update(uint8_t state)`
-
-Sets the output state directly.
-
-  * **Parameters:**
-      * `state`: `HIGH` or `LOW`.
-
-#### `void High()`
-
-Sets the output to HIGH (approx. 5V).
-
-#### `void Low()`
-
-Sets the output to LOW (0V).
-
-#### `void Trigger()`
-
-Begins a trigger. The output goes HIGH and will automatically be set LOW after the configured trigger duration has elapsed (handled by `Process()`).
-
-#### `void Process()`
-
-Handles the timing for triggers. If an output was triggered, this method checks if the duration has elapsed and sets the output LOW if necessary. Call this in the main loop.
-
-#### `bool On()`
-
-Returns the current on/off state of the output.
-
-  * **Returns:** `true` if the output is currently HIGH.
-
-## `Encoder` Class
-
-Handles all interaction with the rotary encoder, including rotation, button presses, and rotation while pressed.
-
-**Header:** `encoder_dir.h`
-
-### Public Methods
-
-#### `void SetReverseDirection(bool reversed)`
-
-Sets the direction of the encoder.
-
-  * **Parameters:**
-      * `reversed`: Set to `true` to reverse the direction of rotation.
-
-#### `void AttachPressHandler(void (*f)())`
-
-Attaches a callback for a simple press-and-release of the encoder button.
-
-  * **Parameters:**
-      * `f`: The function to call on a button press.
-
-#### `void AttachRotateHandler(void (*f)(int val))`
-
-Attaches a callback for when the encoder is rotated (while the button is not pressed).
-
-  * **Parameters:**
-      * `f`: The callback function. It receives an `int` representing the change in position (can be positive or negative).
-
-#### `void AttachPressRotateHandler(void (*f)(int val))`
-
-Attaches a callback for when the encoder is rotated while the button is being held down.
-
-  * **Parameters:**
-      * `f`: The callback function. It receives an `int` representing the change in position.
-
-#### `void Process()`
-
-Processes encoder and button events. This method must be called repeatedly in the main loop to check for state changes and dispatch the appropriate callbacks.

src/analog_input.h

@@ -11,107 +11,107 @@
 #ifndef ANALOG_INPUT_H
 #define ANALOG_INPUT_H
 
-const int MAX_INPUT = (1 << 10) - 1;  // Max 10 bit analog read resolution.
+const int MAX_INPUT = (1 << 10) - 1; // Max 10 bit analog read resolution.
 
-// Estimated default calibration value
+// estimated default calibration value
-// TODO: This should be set by metadata via calibration.
 const int CALIBRATED_LOW = -566;
 const int CALIBRATED_HIGH = 512;
 
-/**
- * @brief Class for interacting with analog inputs (CV).
- */
 class AnalogInput {
-   public:
+public:
-    AnalogInput() {}
+  static const int GATE_THRESHOLD = 0;
-    ~AnalogInput() {}
 
-    /**
+  AnalogInput() {}
-     * @brief Initializes an analog input object.
+  ~AnalogInput() {}
-     *
-     * @param pin The GPIO pin for the analog input.
-     */
-    void Init(uint8_t pin) {
-        pinMode(pin, INPUT);
-        pin_ = pin;
-    }
 
-    /**
+  /**
-     * @brief Reads and processes the analog input.
+   * Initializes a analog input object.
-     *
+   *
-     * This method reads the raw value from the ADC, applies the current
+   * @param pin gpio pin for the analog input.
-     * calibration, offset, and attenuation/inversion settings. It should be
+   */
-     * called regularly in the main loop to update the input's state.
+  void Init(uint8_t pin) {
-     */
+    pinMode(pin, INPUT);
-    void Process() {
+    pin_ = pin;
-        old_read_ = read_;
+  }
-        int raw = analogRead(pin_);
-        read_ = map(raw, 0, MAX_INPUT, low_, high_);
-        read_ = constrain(read_ - offset_, -512, 512);
-        if (inverted_) read_ = -read_;
-    }
 
-    /**
+  /**
-     * @brief Adjusts the low calibration point.
+   * Read the value of the analog input and set instance state.
-     *
+   *
-     * This is used to fine-tune the mapping of the raw analog input to the output range.
+   */
-     *
+  void Process() {
-     * @param amount The amount to add to the current low calibration value.
+    old_read_ = read_;
-     */
+    int raw = analogRead(pin_);
-    void AdjustCalibrationLow(int amount) { low_ += amount; }
+    read_ = map(raw, 0, MAX_INPUT, low_, high_);
+    // Cast to long to avoid AVR 16-bit integer overflow prior to constraining
+    read_ = constrain((long)read_ - (long)offset_, -512, 512);
+    if (inverted_)
+      read_ = -read_;
+  }
 
-    /**
+  // Set calibration values.
-     * @brief Adjusts the high calibration point.
-     *
-     * This is used to fine-tune the mapping of the raw analog input to the output range.
-     *
-     * @param amount The amount to add to the current high calibration value.
-     */
-    void AdjustCalibrationHigh(int amount) { high_ += amount; }
 
-    /**
+  void AdjustCalibrationLow(int amount) { low_ += amount; }
-     * @brief Sets a DC offset for the input.
-     *
-     * @param percent A percentage (e.g., 0.5 for 50%) to shift the signal.
-     */
-    void SetOffset(float percent) { offset_ = -(percent)*512; }
 
-    /**
+  void AdjustCalibrationHigh(int amount) { high_ += amount; }
-     * @brief Sets the attenuation (scaling) of the input signal.
-     *
-     * This scales the input signal. A negative percentage will also invert the signal.
-     *
-     * @param percent The attenuation level, typically from 0.0 to 1.0.
-     */
-    void SetAttenuation(float percent) {
-        low_ = abs(percent) * CALIBRATED_LOW;
-        high_ = abs(percent) * CALIBRATED_HIGH;
-        inverted_ = percent < 0;
-    }
 
-    /**
+  void SetCalibrationLow(int low) { low_ = low; }
-     * @brief Get the current processed value of the analog input.
-     *
-     * @return The read value within a range of +/-512.
-     */
-    inline int16_t Read() { return read_; }
 
-    /**
+  void SetCalibrationHigh(int high) { high_ = high; }
-     * @brief Return the analog read value as a voltage.
-     *
-     * @return A float representing the calculated voltage (-5.0 to +5.0).
-     */
-    inline float Voltage() { return ((read_ / 512.0) * 5.0); }
 
-   private:
+  int GetCalibrationLow() const { return low_; }
-    uint8_t pin_;
+
-    int16_t read_;
+  int GetCalibrationHigh() const { return high_; }
-    uint16_t old_read_;
+
-    // calibration values.
+  void SetOffset(float percent) { offset_ = -(percent) * 512; }
-    int offset_ = 0;
+
-    int low_ = CALIBRATED_LOW;
+  void AdjustOffset(int amount) { offset_ += amount; }
-    int high_ = CALIBRATED_HIGH;
+
-    bool inverted_ = false;
+  int GetOffset() const { return offset_; }
+
+  void SetAttenuation(float percent) {
+    low_ = abs(percent) * CALIBRATED_LOW;
+    high_ = abs(percent) * CALIBRATED_HIGH;
+    inverted_ = percent < 0;
+  }
+
+  /**
+   * Get the current value of the analog input within a range of +/-512.
+   *
+   * @return read value within a range of +/-512.
+   *
+   */
+  inline int16_t Read() { return read_; }
+
+  /**
+   * Return the analog read value as voltage.
+   *
+   * @return A float representing the voltage (-5.0 to +5.0).
+   *
+   */
+  inline float Voltage() { return ((read_ / 512.0) * 5.0); }
+
+  /**
+   * Checks for a rising edge transition across a threshold.
+   *
+   * @param threshold The value that the input must cross.
+   * @return True if the value just crossed the threshold from below, false
+   * otherwise.
+   */
+  inline bool IsRisingEdge(int16_t threshold) const {
+    bool was_high = old_read_ > threshold;
+    bool is_high = read_ > threshold;
+    return is_high && !was_high;
+  }
+
+private:
+  uint8_t pin_;
+  int16_t read_;
+  uint16_t old_read_;
+  // calibration values.
+  int offset_ = 0;
+  int low_ = CALIBRATED_LOW;
+  int high_ = CALIBRATED_HIGH;
+  bool inverted_ = false;
 };
 
-#endif
+#endif

src/button.h

@@ -4,7 +4,7 @@
  * @brief Wrapper class for interacting with trigger / gate inputs.
  * @version 0.1
  * @date 2025-04-20
- *
+  *
  * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
  *
  */
@@ -13,14 +13,14 @@
 
 #include <Arduino.h>
 
+const uint8_t DEBOUNCE_MS = 10;
+const uint16_t LONG_PRESS_DURATION_MS = 750;
+
 class Button {
    protected:
     typedef void (*CallbackFunction)(void);
 
    public:
-    static const uint8_t DEBOUNCE_MS = 10;
-    static const uint16_t LONG_PRESS_DURATION_MS = 750;
-
     // Enum constants for active change in button state.
     enum ButtonChange {
         CHANGE_UNCHANGED,
@@ -84,7 +84,7 @@ class Button {
                 if (on_long_press_ != NULL) on_long_press_();
             }
         }
-
+        
         // Update variables for next loop
         last_press_ = (pressed || released) ? millis() : last_press_;
         old_read_ = 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
@@ -27,223 +28,159 @@ typedef void (*ExtCallback)(void);
 static ExtCallback extUserCallback = nullptr;
 static void serialEventNoop(uint8_t msg, uint8_t status) {}
 
-/**
- * @brief Wrapper Class for clock timing functions.
- */
 class Clock {
-   public:
+public:
-    static constexpr int DEFAULT_TEMPO = 120;
+  static constexpr int DEFAULT_TEMPO = 120;
 
-    enum Source {
+  enum Source {
-        SOURCE_INTERNAL,
+    SOURCE_INTERNAL,
-        SOURCE_EXTERNAL_PPQN_24,
+    SOURCE_EXTERNAL_PPQN_24,
-        SOURCE_EXTERNAL_PPQN_4,
+    SOURCE_EXTERNAL_PPQN_4,
-        SOURCE_EXTERNAL_MIDI,
+    SOURCE_EXTERNAL_PPQN_2,
-        SOURCE_LAST,
+    SOURCE_EXTERNAL_PPQN_1,
-    };
+    SOURCE_EXTERNAL_MIDI,
+    SOURCE_LAST,
+  };
 
-    enum Pulse {
+  enum Pulse {
-        PULSE_NONE,
+    PULSE_NONE,
-        PULSE_PPQN_1,
+    PULSE_PPQN_1,
-        PULSE_PPQN_4,
+    PULSE_PPQN_4,
-        PULSE_PPQN_24,
+    PULSE_PPQN_24,
-        PULSE_LAST,
+    PULSE_LAST,
-    };
+  };
 
-    /**
+  void Init() {
-     * @brief Initializes the clock, MIDI serial, and sets default values.
+    NeoSerial.begin(31250);
-     */
-    void Init() {
-        NeoSerial.begin(31250);
 
-        // Initialize the clock library
+    // Initialize the clock library
-        uClock.init();
+    uClock.init();
-        uClock.setClockMode(uClock.INTERNAL_CLOCK);
+    uClock.setClockMode(uClock.INTERNAL_CLOCK);
-        uClock.setOutputPPQN(uClock.PPQN_96);
+    uClock.setOutputPPQN(uClock.PPQN_96);
-        uClock.setTempo(DEFAULT_TEMPO);
+    uClock.setTempo(DEFAULT_TEMPO);
 
-        // MIDI events.
+    // MIDI events.
-        uClock.setOnClockStart(sendMIDIStart);
+    uClock.setOnClockStart(sendMIDIStart);
-        uClock.setOnClockStop(sendMIDIStop);
+    uClock.setOnClockStop(sendMIDIStop);
-        uClock.setOnSync24(sendMIDIClock);
+    uClock.setOnSync24(sendMIDIClock);
 
-        uClock.start();
+    uClock.start();
+  }
+
+  // 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);
+  }
+
+  // Internal PPQN96 callback for all clock timer operations.
+  void AttachIntHandler(void (*callback)(uint32_t)) {
+    uClock.setOnOutputPPQN(callback);
+  }
+
+  // Set the source of the clock mode.
+  void SetSource(Source source) {
+    bool was_playing = !IsPaused();
+    uClock.stop();
+    // If we are changing the source from MIDI, disable the serial interrupt
+    // handler.
+    if (source_ == SOURCE_EXTERNAL_MIDI) {
+      NeoSerial.attachInterrupt(serialEventNoop);
     }
-
+    source_ = source;
-    /**
+    switch (source) {
-     * @brief Attach a handler for external clock ticks.
+    case SOURCE_INTERNAL:
-     *
+      uClock.setClockMode(uClock.INTERNAL_CLOCK);
-     * This function attaches a user-defined callback to the external clock input pin interrupt.
+      break;
-     * It is also called for incoming MIDI clock events.
+    case SOURCE_EXTERNAL_PPQN_24:
-     *
+      uClock.setClockMode(uClock.EXTERNAL_CLOCK);
-     * @param callback Function to call on an external clock event.
+      uClock.setInputPPQN(uClock.PPQN_24);
-     */
+      break;
-    void AttachExtHandler(void (*callback)()) {
+    case SOURCE_EXTERNAL_PPQN_4:
-        extUserCallback = callback;
+      uClock.setClockMode(uClock.EXTERNAL_CLOCK);
-        attachInterrupt(digitalPinToInterrupt(EXT_PIN), callback, RISING);
+      uClock.setInputPPQN(uClock.PPQN_4);
+      break;
+    case SOURCE_EXTERNAL_PPQN_2:
+      uClock.setClockMode(uClock.EXTERNAL_CLOCK);
+      uClock.setInputPPQN(uClock.PPQN_2);
+      break;
+    case SOURCE_EXTERNAL_PPQN_1:
+      uClock.setClockMode(uClock.EXTERNAL_CLOCK);
+      uClock.setInputPPQN(uClock.PPQN_1);
+      break;
+    case SOURCE_EXTERNAL_MIDI:
+      uClock.setClockMode(uClock.EXTERNAL_CLOCK);
+      uClock.setInputPPQN(uClock.PPQN_24);
+      NeoSerial.attachInterrupt(onSerialEvent);
+      break;
     }
-
+    if (was_playing) {
-    /**
+      uClock.start();
-     * @brief Attach a handler for the internal high-resolution clock.
-     *
-     * Sets a callback function that is triggered at the internal PPQN_96 rate. This is the
-     * main internal timing callback for all clock operations.
-     *
-     * @param callback Function to call on every internal clock tick. It receives the tick count as a parameter.
-     */
-    void AttachIntHandler(void (*callback)(uint32_t)) {
-        uClock.setOnOutputPPQN(callback);
     }
+  }
 
-    /**
+  // Return true if the current selected source is externl (PPQN_4, PPQN_24, or
-     * @brief Set the source of the clock.
+  // MIDI).
-     *
+  bool ExternalSource() {
-     * @param source The new source for driving the clock. See the `Source` enum.
+    return uClock.getClockMode() == uClock.EXTERNAL_CLOCK;
-     */
+  }
-    void SetSource(Source source) {
+
-        bool was_playing = !IsPaused();
+  // Return true if the current selected source is the internal master clock.
-        uClock.stop();
+  bool InternalSource() {
-        // If we are changing the source from MIDI, disable the serial interrupt handler.
+    return uClock.getClockMode() == uClock.INTERNAL_CLOCK;
-        if (source_ == SOURCE_EXTERNAL_MIDI) {
+  }
-            NeoSerial.attachInterrupt(serialEventNoop);
+
-        }
+  // Returns the current BPM tempo.
-        source_ = source;
+  int Tempo() { return uClock.getTempo(); }
-        switch (source) {
+
-            case SOURCE_INTERNAL:
+  // Set the clock tempo to a int between 1 and 400.
-                uClock.setClockMode(uClock.INTERNAL_CLOCK);
+  void SetTempo(int tempo) { return uClock.setTempo(tempo); }
-                break;
+
-            case SOURCE_EXTERNAL_PPQN_24:
+  // Record an external clock tick received to process external/internal
-                uClock.setClockMode(uClock.EXTERNAL_CLOCK);
+  // syncronization.
-                uClock.setInputPPQN(uClock.PPQN_24);
+  void Tick() { uClock.clockMe(); }
-                break;
+
-            case SOURCE_EXTERNAL_PPQN_4:
+  // Start the internal clock.
-                uClock.setClockMode(uClock.EXTERNAL_CLOCK);
+  void Start() { uClock.start(); }
-                uClock.setInputPPQN(uClock.PPQN_4);
+
-                break;
+  // Stop internal clock clock.
-            case SOURCE_EXTERNAL_MIDI:
+  void Stop() { uClock.stop(); }
-                uClock.setClockMode(uClock.EXTERNAL_CLOCK);
+
-                uClock.setInputPPQN(uClock.PPQN_24);
+  // Reset all clock counters to 0.
-                NeoSerial.attachInterrupt(onSerialEvent);
+  void Reset() { uClock.resetCounters(); }
-                break;
+
-        }
+  // Returns true if the clock is not running.
-        if (was_playing) {
+  bool IsPaused() { return uClock.clock_state == uClock.PAUSED; }
-            uClock.start();
+
-        }
+private:
+  Source source_ = SOURCE_INTERNAL;
+
+  static void onSerialEvent(uint8_t msg, uint8_t status) {
+    // Note: uClock start and stop will echo to MIDI.
+    switch (msg) {
+    case MIDI_CLOCK:
+      if (extUserCallback) {
+        extUserCallback();
+      }
+      break;
+    case MIDI_STOP:
+      uClock.stop();
+      sendMIDIStop();
+      break;
+    case MIDI_START:
+    case MIDI_CONTINUE:
+      uClock.start();
+      sendMIDIStart();
+      break;
     }
+  }
 
-    /**
+  static void sendMIDIStart() { NeoSerial.write(MIDI_START); }
-     * @brief Checks if the clock source is external.
-     *
-     * @return true if the current source is external (PPQN_4, PPQN_24, or MIDI).
-     * @return false if the source is internal.
-     */
-    bool ExternalSource() {
-        return uClock.getClockMode() == uClock.EXTERNAL_CLOCK;
-    }
 
-    /**
+  static void sendMIDIStop() { NeoSerial.write(MIDI_STOP); }
-     * @brief Checks if the clock source is internal.
-     *
-     * @return true if the current source is the internal master clock.
-     * @return false if the source is external.
-     */
-    bool InternalSource() {
-        return uClock.getClockMode() == uClock.INTERNAL_CLOCK;
-    }
 
-    /**
+  static void sendMIDIClock(uint32_t tick) { NeoSerial.write(MIDI_CLOCK); }
-     * @brief Gets the current tempo.
-     *
-     * @return int The current tempo in beats per minute (BPM).
-     */
-    int Tempo() {
-        return uClock.getTempo();
-    }
-
-    /**
-     * @brief Set the clock tempo.
-     *
-     * @param tempo The new tempo in beats per minute (BPM).
-     */
-    void SetTempo(int tempo) {
-        return uClock.setTempo(tempo);
-    }
-
-    /**
-     * @brief Manually trigger a clock tick.
-     *
-     * This should be called when in an external clock mode to register an incoming
-     * clock pulse and drive the internal timing.
-     */
-    void Tick() {
-        uClock.clockMe();
-    }
-
-    /**
-     * @brief Starts the clock.
-     */
-    void Start() {
-        uClock.start();
-    }
-
-    /**
-     * @brief Stops (pauses) the clock.
-     */
-    void Stop() {
-        uClock.stop();
-    }
-
-    /**
-     * @brief Resets all clock counters to zero.
-     */
-    void Reset() {
-        uClock.resetCounters();
-    }
-
-    /**
-     * @brief Checks if the clock is currently paused.
-     *
-     * @return true if the clock is stopped/paused.
-     * @return false if the clock is running.
-     */
-    bool IsPaused() {
-        return uClock.clock_state == uClock.PAUSED;
-    }
-
-   private:
-    Source source_ = SOURCE_INTERNAL;
-
-    static void onSerialEvent(uint8_t msg, uint8_t status) {
-        // Note: uClock start and stop will echo to MIDI.
-        switch (msg) {
-            case MIDI_CLOCK:
-                if (extUserCallback) {
-                    extUserCallback();
-                }
-                break;
-            case MIDI_STOP:
-                uClock.stop();
-                sendMIDIStop();
-                break;
-            case MIDI_START:
-            case MIDI_CONTINUE:
-                uClock.start();
-                sendMIDIStart();
-                break;
-        }
-    }
-
-    static void sendMIDIStart() {
-        NeoSerial.write(MIDI_START);
-    }
-
-    static void sendMIDIStop() {
-        NeoSerial.write(MIDI_STOP);
-    }
-
-    static void sendMIDIClock(uint32_t tick) {
-        NeoSerial.write(MIDI_CLOCK);
-    }
 };
 
 #endif

src/digital_output.h

@@ -4,7 +4,7 @@
  * @brief Class for interacting with trigger / gate outputs.
  * @version 0.1
  * @date 2025-04-17
- * 
+ *
  * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
  *
  */
@@ -13,82 +13,84 @@
 
 #include <Arduino.h>
 
+const byte DEFAULT_TRIGGER_DURATION_MS = 5;
+
 class DigitalOutput {
-   public:
+public:
-    static const byte DEFAULT_TRIGGER_DURATION_MS = 5;
+  /**
+   * Initializes an CV Output paired object.
+   *
+   * @param cv_pin gpio pin for the cv output
+   */
+  void Init(uint8_t cv_pin) {
+    pinMode(cv_pin, OUTPUT); // Gate/Trigger Output
+    cv_pin_ = cv_pin;
+    trigger_duration_ = DEFAULT_TRIGGER_DURATION_MS;
+  }
 
-    /**
+  /**
-     * Initializes an CV Output paired object.
+   * Set the trigger duration in miliseconds.
-     *
+   *
-     * @param cv_pin gpio pin for the cv output
+   * @param duration_ms trigger duration in miliseconds
-     */
+   */
-    void Init(uint8_t cv_pin) {
+  void SetTriggerDuration(uint8_t duration_ms) {
-        pinMode(cv_pin, OUTPUT);  // Gate/Trigger Output
+    trigger_duration_ = duration_ms;
-        cv_pin_ = cv_pin;
+  }
-        trigger_duration_ = DEFAULT_TRIGGER_DURATION_MS;
+
+  /**
+   * Turn the CV and LED on or off according to the input state.
+   *
+   * @param state Arduino digital HIGH or LOW values.
+   */
+  inline void Update(uint8_t state) {
+    if (state == HIGH)
+      High(); // Rising
+    if (state == LOW)
+      Low(); // Falling
+  }
+
+  // Sets the cv output HIGH to about 5v.
+  inline void High() { update(HIGH); }
+
+  // Sets the cv output LOW to 0v.
+  inline void Low() { update(LOW); }
+
+  /**
+   * Begin a Trigger period for this output.
+   */
+  inline void Trigger() {
+    update(HIGH);
+    last_triggered_ = millis();
+  }
+
+  /**
+   * 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 (on_ && (millis() - last_triggered_) >= trigger_duration_) {
+      update(LOW);
     }
+  }
 
-    /**
+  /**
-     * Set the trigger duration in miliseconds.
+   * Return a bool representing the on/off state of the output.
-     *
+   *
-     * @param duration_ms trigger duration in miliseconds
+   * @return true if current cv state is high, false if current cv state is low
-     */
+   */
-    void SetTriggerDuration(uint8_t duration_ms) {
+  inline bool On() { return on_; }
-        trigger_duration_ = duration_ms;
-    }
 
-    /**
+private:
-     * Turn the CV and LED on or off according to the input state.
+  unsigned long last_triggered_;
-     *
+  uint8_t trigger_duration_;
-     * @param state Arduino digital HIGH or LOW values.
+  uint8_t cv_pin_;
-     */
+  bool on_;
-    inline void Update(uint8_t state) {
-        if (state == HIGH) High();  // Rising
-        if (state == LOW) Low();    // Falling
-    }
 
-    // Sets the cv output HIGH to about 5v.
+  void update(uint8_t state) {
-    inline void High() { update(HIGH); }
+    digitalWrite(cv_pin_, state);
-
+    on_ = state == HIGH;
-    // Sets the cv output LOW to 0v.
+  }
-    inline void Low() { update(LOW); }
-
-    /**
-     * Begin a Trigger period for this output.
-     */
-    inline void Trigger() {
-        update(HIGH);
-        last_triggered_ = millis();
-    }
-
-    /**
-     * 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 (on_ && (millis() - last_triggered_) >= trigger_duration_) {
-            update(LOW);
-        }
-    }
-
-    /**
-     * Return a bool representing the on/off state of the output.
-     *
-     * @return true if current cv state is high, false if current cv state is low
-     */
-    inline bool On() { return on_; }
-
-   private:
-    unsigned long last_triggered_;
-    uint8_t trigger_duration_;
-    uint8_t cv_pin_;
-    uint8_t led_pin_;
-    bool on_;
-
-    void update(uint8_t state) {
-        digitalWrite(cv_pin_, state);
-        on_ = state == HIGH;
-    }
 };
 
 #endif

src/encoder.h

@@ -4,11 +4,10 @@
  * @brief Class for interacting with encoders.
  * @version 0.1
  * @date 2025-04-19
- *
+ * 
  * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
  *
  */
-
 #ifndef ENCODER_DIR_H
 #define ENCODER_DIR_H
 
@@ -17,9 +16,6 @@
 #include "button.h"
 #include "peripherials.h"
 
-/**
- * @brief Class for interacting with a rotary encoder that has a push button.
- */
 class Encoder {
    protected:
     typedef void (*CallbackFunction)(void);
@@ -36,57 +32,22 @@ class Encoder {
     }
     ~Encoder() {}
 
-    /**
+    // Set to true if the encoder read direction should be reversed.
-     * @brief Set the direction of the encoder.
-     *
-     * @param reversed Set to true to reverse the direction of rotation.
-     */
     void SetReverseDirection(bool reversed) {
         reversed_ = reversed;
     }
-
-    /**
-     * @brief Attach a handler for the encoder button press.
-     *
-     * This callback is triggered on a simple press and release of the button,
-     * without any rotation occurring during the press.
-     *
-     * @param f The callback function to execute when a button press.
-     */
     void AttachPressHandler(CallbackFunction f) {
         on_press = f;
     }
 
-    /**
-     * @brief Attach a handler for encoder rotation.
-     *
-     * This callback is triggered when the encoder is rotated while the button is not pressed.
-     *
-     * @param f The callback function to execute on rotation. It receives an integer
-     * representing the change in position (can be positive or negative).
-     */
     void AttachRotateHandler(RotateCallbackFunction f) {
         on_rotate = f;
     }
 
-    /**
-     * @brief Attach a handler for rotation while the button is pressed.
-     *
-     * This callback is triggered when the encoder is rotated while the button is being held down.
-     *
-     * @param f The callback function to execute. It receives an integer
-     * representing the change in position.
-     */
     void AttachPressRotateHandler(RotateCallbackFunction f) {
         on_press_rotate = f;
     }
 
-    /**
-     * @brief Processes encoder and button events.
-     *
-     * This method should be called repeatedly in the main loop to check for state
-     * changes (rotation, button presses) and dispatch the appropriate callbacks.
-     */
     void Process() {
         // Get encoder position change amount.
         int encoder_rotated = _rotate_change() != 0;
@@ -130,6 +91,7 @@ class Encoder {
         int position = encoder_.getPosition();
         unsigned long ms = encoder_.getMillisBetweenRotations();
 
+        // Validation (TODO: add debounce check).
         if (previous_pos_ == position) {
             return 0;
         }