testing firmware on new Nano R4.

Reviewed-on: #28

README.md

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

examples/calibrate_analog/calibrate_analog.ino

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

examples/calibrate_analog2/calibrate_analog2.ino

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

examples/hardware_test/hardware_test.ino

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

examples/skeleton/skeleton.ino

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

examples/test_r4/encoder.h

@@ -0,0 +1,118 @@
+/**
+ * @file encoder.h
+ * @author Adam Wonak (https://github.com/awonak)
+ * @brief Class for interacting with encoders.
+ * @version 2.0.0
+ * @date 2025-08-17
+ * 
+ * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
+ *
+ */
+#ifndef ENCODER_DIR_H
+#define ENCODER_DIR_H
+
+#include <RotaryEncoder.h>
+
+#include "button.h"
+#include "peripherials.h"
+
+class Encoder {
+   protected:
+    typedef void (*CallbackFunction)(void);
+    typedef void (*RotateCallbackFunction)(int val);
+    CallbackFunction on_press;
+    RotateCallbackFunction on_press_rotate;
+    RotateCallbackFunction on_rotate;
+    int change;
+
+   public:
+    Encoder() : encoder_(ENCODER_PIN1, ENCODER_PIN2, RotaryEncoder::LatchMode::FOUR3),
+                   button_(ENCODER_SW_PIN) {
+        _instance = this;
+    }
+    ~Encoder() {}
+
+    // Set to true if the encoder read direction should be reversed.
+    void SetReverseDirection(bool reversed) {
+        reversed_ = reversed;
+    }
+    void AttachPressHandler(CallbackFunction f) {
+        on_press = f;
+    }
+
+    void AttachRotateHandler(RotateCallbackFunction f) {
+        on_rotate = f;
+    }
+
+    void AttachPressRotateHandler(RotateCallbackFunction f) {
+        on_press_rotate = f;
+    }
+
+    void Process() {
+        encoder_.tick();
+        // Get encoder position change amount.
+        int encoder_rotated = _rotate_change() != 0;
+        bool button_pressed = button_.On();
+        button_.Process();
+
+        // Handle encoder position change and button press.
+        if (button_pressed && encoder_rotated) {
+            rotated_while_held_ = true;
+            if (on_press_rotate != NULL) on_press_rotate(change);
+        } else if (!button_pressed && encoder_rotated) {
+            if (on_rotate != NULL) on_rotate(change);
+        } else if (button_.Change() == Button::CHANGE_RELEASED && !rotated_while_held_) {
+            if (on_press != NULL) on_press();
+        }
+
+        // Reset rotate while held state.
+        if (button_.Change() == Button::CHANGE_RELEASED && rotated_while_held_) {
+            rotated_while_held_ = false;
+        }
+    }
+
+    static void isr() {
+        // If the instance has been created, call its tick() method.
+        if (_instance) {
+            _instance->encoder_.tick();
+        }
+    }
+
+   private:
+    static Encoder* _instance;
+
+    int previous_pos_;
+    bool rotated_while_held_;
+    bool reversed_ = false;
+    RotaryEncoder encoder_;
+    Button button_;
+
+    // Return the number of ticks change since last polled.
+    int _rotate_change() {
+        int position = encoder_.getPosition();
+        unsigned long ms = encoder_.getMillisBetweenRotations();
+
+        // Validation (TODO: add debounce check).
+        if (previous_pos_ == position) {
+            return 0;
+        }
+
+        // Update state variables.
+        change = position - previous_pos_;
+        previous_pos_ = position;
+
+        // Encoder rotate acceleration.
+        if (ms < 16) {
+            change *= 3;
+        } else if (ms < 32) {
+            change *= 2;
+        }
+
+        if (reversed_) {
+            change = -(change);
+        }
+        return change;
+    }
+};
+
+#endif

examples/test_r4/test_r4.ino

@@ -0,0 +1,76 @@
+
+#include "peripherials.h"
+
+#include "encoder.h"
+
+
+#include <U8g2lib.h>
+U8G2_SSD1306_128X64_NONAME_1_HW_I2C display(U8G2_R2, SCL, SDA, U8X8_PIN_NONE);
+
+
+Encoder encoder;
+
+const int OUTPUT_COUNT = 6;
+int outputs[OUTPUT_COUNT] = {
+    OUT_CH1,
+    OUT_CH2,
+    OUT_CH3,
+    OUT_CH4,
+    OUT_CH5,
+    OUT_CH6,
+};
+
+volatile int idx = 0;
+
+// the setup function runs once when you press reset or power the board
+void setup() {
+    // initialize digital pin LED_BUILTIN as an output.
+    pinMode(LED_BUILTIN, OUTPUT);
+    for (int i = 0; i < OUTPUT_COUNT; i++) {
+        pinMode(outputs[i], OUTPUT);
+    }
+
+    encoder.AttachRotateHandler(rotateEncoder);
+    encoder.AttachPressHandler(press);
+
+    display.begin();
+
+}
+
+void rotateEncoder(int val) {
+    idx = (val > 0) 
+            ? constrain(idx + 1, 0 , OUTPUT_COUNT)
+            : constrain(idx - 1, 0 , OUTPUT_COUNT);
+}
+
+// the loop function runs over and over again forever
+void loop() {
+    encoder.Process();
+    UpdateDisplay();
+
+    digitalWrite(LED_BUILTIN, HIGH);  // turn the LED on (HIGH is the voltage level)
+    digitalWrite(outputs[idx], HIGH);          // turn the LED on (HIGH is the voltage level)
+    delay(500);                          // wait for a second
+    digitalWrite(LED_BUILTIN, LOW);       // turn the LED off by making the voltage LOW
+    digitalWrite(outputs[idx], LOW);           // turn the LED on (LOW is the voltage level)
+    delay(500);                          // wait for a second
+}
+
+void press() {
+    for (int i = 0; i < OUTPUT_COUNT; i++) {
+        digitalWrite(LED_BUILTIN, HIGH);  // turn the LED on (HIGH is the voltage level)
+        digitalWrite(outputs[i], HIGH);      // turn the LED on (HIGH is the voltage level)
+        delay(50);                        // wait for a second
+        digitalWrite(LED_BUILTIN, LOW);   // turn the LED off by making the voltage LOW
+        digitalWrite(outputs[i], LOW);       // turn the LED on (LOW is the voltage level)
+        delay(50);
+    }
+}
+
+
+void UpdateDisplay() {
+    display.firstPage();
+    do {
+        display.drawStr(0, 0, "Hello");
+    } while (display.nextPage());
+}

firmware/Gravity/Gravity.ino

@@ -2,7 +2,7 @@
  * @file Gravity.ino
  * @author Adam Wonak (https://github.com/awonak/)
  * @brief Alt firmware version of Gravity by Sitka Instruments.
- * @version v2.0.0 - June 2025 awonak - Full rewrite
+ * @version v2.0.0 - August 2025 awonak - Full rewrite
  * @version v1.0 - August 2023 Oleksiy H - Initial release
  * @date 2025-07-04
  *
@@ -42,7 +42,7 @@
  *
  * CV1:
  *      External analog input used to provide modulation to any channel parameter.
- * 
+ *
  * CV2:
  *      External analog input used to provide modulation to any channel parameter.
  *
@@ -66,10 +66,6 @@ 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);
@@ -91,18 +87,8 @@ 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);
-        }
-    }
+    // Check if cv run or reset is active and read cv.
+    CheckRunReset(gravity.cv1, gravity.cv2);
 
     // Check for dirty state eligible to be saved.
     stateManager.update(app);
@@ -171,6 +157,27 @@ void HandleExtClockTick() {
     app.refresh_screen = true;
 }
 
+void CheckRunReset(AnalogInput& cv1, AnalogInput& cv2) {
+    // Clock Run
+    if (app.cv_run == 1 || app.cv_run == 2) {
+        const int val = (app.cv_run == 1) ? cv1.Read() : cv2.Read();
+        if (val > AnalogInput::GATE_THRESHOLD && gravity.clock.IsPaused()) {
+            gravity.clock.Start();
+            app.refresh_screen = true;
+        } else if (val < AnalogInput::GATE_THRESHOLD && !gravity.clock.IsPaused()) {
+            gravity.clock.Stop();
+            ResetOutputs();
+            app.refresh_screen = true;
+        }
+    }
+
+    // Clock Reset
+    if ((app.cv_reset == 1 && cv1.IsRisingEdge(AnalogInput::GATE_THRESHOLD)) ||
+        (app.cv_reset == 2 && cv2.IsRisingEdge(AnalogInput::GATE_THRESHOLD))) {
+        gravity.clock.Reset();
+    }
+}
+
 //
 // UI handlers for encoder and buttons.
 //
@@ -202,37 +209,42 @@ 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_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;
-                    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);
-                }
+            switch (app.selected_param) {
+                case PARAM_MAIN_ENCODER_DIR:
+                    app.encoder_reversed = app.selected_sub_param == 1;
+                    gravity.encoder.SetReverseDirection(app.encoder_reversed);
+                    break;
+                case PARAM_MAIN_ROTATE_DISP:
+                    app.rotate_display = app.selected_sub_param == 1;
+                    gravity.display.setFlipMode(app.rotate_display ? 1 : 0);
+                    break;
+                case PARAM_MAIN_SAVE_DATA:
+                    if (app.selected_sub_param < StateManager::MAX_SAVE_SLOTS) {
+                        app.selected_save_slot = app.selected_sub_param;
+                        stateManager.saveData(app);
+                    }
+                    break;
+                case PARAM_MAIN_LOAD_DATA:
+                    if (app.selected_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 clock is not active.
+                        if (gravity.clock.IsPaused()) {
+                            InitGravity(app);
+                        }
+                    }
+                    break;
+                case PARAM_MAIN_FACTORY_RESET:
+                    if (app.selected_sub_param == 0) {  // Erase
+                        stateManager.factoryReset(app);
+                        InitGravity(app);
+                    }
+                    break;
             }
         }
         // Only mark dirty and reset selected_sub_param when leaving editing mode.
@@ -282,6 +294,14 @@ void editMainParameter(int val) {
             gravity.clock.SetTempo(gravity.clock.Tempo() + val);
             app.tempo = gravity.clock.Tempo();
             break;
+        case PARAM_MAIN_RUN:
+            updateSelection(app.selected_sub_param, val, 3);
+            app.cv_run = app.selected_sub_param;
+            break;
+        case PARAM_MAIN_RESET:
+            updateSelection(app.selected_sub_param, val, 3);
+            app.cv_reset = app.selected_sub_param;
+            break;
         case PARAM_MAIN_SOURCE: {
             byte source = static_cast<int>(app.selected_source);
             updateSelection(source, val, Clock::SOURCE_LAST);
@@ -298,16 +318,15 @@ void editMainParameter(int val) {
             }
             break;
         }
+        // These changes are applied upon encoder button press.
         case PARAM_MAIN_ENCODER_DIR:
+        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;
@@ -370,6 +389,7 @@ 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() {

firmware/Gravity/app_state.h

@@ -2,8 +2,8 @@
  * @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
+ * @version 2.0.0
+ * @date 2025-08-17
  *
  * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
  *
@@ -25,10 +25,13 @@ struct AppState {
     byte selected_channel = 0;    // 0=tempo, 1-6=output channel
     byte selected_swing = 0;
     byte selected_save_slot = 0;  // The currently active save slot.
+    byte cv_run = 0;
+    byte cv_reset = 0;
     Clock::Source selected_source = Clock::SOURCE_INTERNAL;
     Clock::Pulse selected_pulse = Clock::PULSE_PPQN_24;
     bool editing_param = false;
     bool encoder_reversed = false;
+    bool rotate_display = false;
     bool refresh_screen = true;
 };
 

firmware/Gravity/channel.h

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

firmware/Gravity/display.h

@@ -2,8 +2,8 @@
  * @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
+ * @version 2.0.0
+ * @date 2025-08-17
  *
  * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
  *
@@ -47,7 +47,7 @@ const uint8_t TEXT_FONT[437] U8G2_FONT_SECTION("velvetscreen") PROGMEM =
  * https://stncrn.github.io/u8g2-unifont-helper/
  * "%/0123456789ABCDEFILNORSTUVXx"
  */
-const uint8_t LARGE_FONT[766] U8G2_FONT_SECTION("stk-l") =
+const uint8_t LARGE_FONT[766] U8G2_FONT_SECTION("stk-l") PROGMEM =
     "\35\0\4\4\4\5\3\1\6\20\30\0\0\27\0\0\0\1\77\0\0\2\341%'\17;\226\261\245FL"
     "\64B\214\30\22\223\220)Bj\10Q\232\214\42R\206\310\210\21d\304\30\32a\254\304\270!\0/\14"
     "\272\272\275\311H\321g\343\306\1\60\37|\373\35CJT\20:fW\207\320\210\60\42\304\204\30D\247"
@@ -100,11 +100,13 @@ constexpr uint8_t CHANNEL_BOX_HEIGHT = 14;
 enum ParamsMainPage : uint8_t {
     PARAM_MAIN_TEMPO,
     PARAM_MAIN_SOURCE,
+    PARAM_MAIN_RUN,
+    PARAM_MAIN_RESET,
     PARAM_MAIN_PULSE,
     PARAM_MAIN_ENCODER_DIR,
+    PARAM_MAIN_ROTATE_DISP,
     PARAM_MAIN_SAVE_DATA,
     PARAM_MAIN_LOAD_DATA,
-    PARAM_MAIN_RESET_STATE,
     PARAM_MAIN_FACTORY_RESET,
     PARAM_MAIN_LAST,
 };
@@ -255,11 +257,42 @@ void DisplayMainPage() {
                 case Clock::SOURCE_EXTERNAL_PPQN_4:
                     subText = F("4 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) {
@@ -281,6 +314,10 @@ void DisplayMainPage() {
             mainText = F("DIR");
             subText = app.selected_sub_param == 0 ? F("DEFAULT") : F("REVERSED");
             break;
+        case PARAM_MAIN_ROTATE_DISP:
+            mainText = F("ROT");
+            subText = app.selected_sub_param == 0 ? F("DEFAULT") : F("FLIPPED");
+            break;
         case PARAM_MAIN_SAVE_DATA:
         case PARAM_MAIN_LOAD_DATA:
             if (app.selected_sub_param == StateManager::MAX_SAVE_SLOTS) {
@@ -297,15 +334,6 @@ void DisplayMainPage() {
                               : F("LOAD FROM SLOT");
             }
             break;
-        case PARAM_MAIN_RESET_STATE:
-            if (app.selected_sub_param == 0) {
-                mainText = F("RST");
-                subText = F("RESET ALL");
-            } else {
-                mainText = F("x");
-                subText = F("BACK TO MAIN");
-            }
-            break;
         case PARAM_MAIN_FACTORY_RESET:
             if (app.selected_sub_param == 0) {
                 mainText = F("DEL");
@@ -321,7 +349,7 @@ void DisplayMainPage() {
     drawCenteredText(subText.c_str(), SUB_TEXT_Y, TEXT_FONT);
 
     // Draw Main Page menu items
-    String menu_items[PARAM_MAIN_LAST] = {F("TEMPO"), F("SOURCE"), F("PULSE OUT"), F("ENCODER DIR"), F("SAVE"), F("LOAD"), F("RESET"), F("ERASE")};
+    String menu_items[PARAM_MAIN_LAST] = {F("TEMPO"), F("SOURCE"), F("CLK RUN"), F("CLK RESET"), F("PULSE OUT"), F("ENCODER DIR"), F("ROTATE DISP"), F("SAVE"), F("LOAD"), F("ERASE")};
     drawMenuItems(menu_items, PARAM_MAIN_LAST);
 }
 
@@ -338,10 +366,12 @@ void DisplayChannelPage() {
     // When editing a param, just show the base value. When not editing show
     // the value with cv mod.
     bool withCvMod = !app.editing_param;
+    int cv1 = gravity.cv1.Read();
+    int cv2 = gravity.cv2.Read();
 
     switch (app.selected_param) {
         case PARAM_CH_MOD: {
-            int mod_value = ch.getClockMod(withCvMod);
+            int mod_value = withCvMod ? ch.getClockModWithMod(cv1, cv2) : ch.getClockMod();
             if (mod_value > 1) {
                 mainText = F("/");
                 mainText += String(mod_value);
@@ -354,30 +384,30 @@ void DisplayChannelPage() {
             break;
         }
         case PARAM_CH_PROB:
-            mainText = String(ch.getProbability(withCvMod)) + F("%");
+            mainText = String(withCvMod ? ch.getProbabilityWithMod(cv1, cv2) : ch.getProbability()) + F("%");
             subText = F("HIT CHANCE");
             break;
         case PARAM_CH_DUTY:
-            mainText = String(ch.getDutyCycle(withCvMod)) + F("%");
+            mainText = String(withCvMod ? ch.getDutyCycleWithMod(cv1, cv2) : ch.getDutyCycle()) + F("%");
             subText = F("PULSE WIDTH");
             break;
         case PARAM_CH_OFFSET:
-            mainText = String(ch.getOffset(withCvMod)) + F("%");
+            mainText = String(withCvMod ? ch.getOffsetWithMod(cv1, cv2) : ch.getOffset()) + F("%");
             subText = F("SHIFT HIT");
             break;
         case PARAM_CH_SWING:
             ch.getSwing() == 50
                 ? mainText = F("OFF")
-                : mainText = String(ch.getSwing(withCvMod)) + F("%");
+                : mainText = String(withCvMod ? ch.getSwingWithMod(cv1, cv2) : ch.getSwing()) + F("%");
             subText = "DOWN BEAT";
             swingDivisionMark();
             break;
         case PARAM_CH_EUC_STEPS:
-            mainText = String(ch.getSteps(withCvMod));
+            mainText = String(withCvMod ? ch.getStepsWithMod(cv1, cv2) : ch.getSteps());
             subText = "EUCLID STEPS";
             break;
         case PARAM_CH_EUC_HITS:
-            mainText = String(ch.getHits(withCvMod));
+            mainText = String(withCvMod ? ch.getHitsWithMod(cv1, cv2) : ch.getHits());
             subText = "EUCLID HITS";
             break;
         case PARAM_CH_CV1_DEST:
@@ -465,25 +495,7 @@ void UpdateDisplay() {
             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(16 + (textWidth / 2), 20, StateManager::SKETCH_NAME);
-
-        textWidth = gravity.display.getStrWidth(StateManager::SEMANTIC_VERSION);
-        gravity.display.drawStr(16 + (textWidth / 2), 32, StateManager::SEMANTIC_VERSION);
-
-        textWidth = gravity.display.getStrWidth(loadingText.c_str());
-        gravity.display.drawStr(26 + (textWidth / 2), 44, loadingText.c_str());
+        DisplaySelectedChannel();
     } while (gravity.display.nextPage());
 }
 

firmware/Gravity/euclidean.h

@@ -2,8 +2,8 @@
  * @file euclidean.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
+ * @version 2.0.0
+ * @date 2025-08-17
  *
  * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
  *

firmware/Gravity/save_state.cpp

@@ -2,8 +2,8 @@
  * @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
+ * @version 2.0.0
+ * @date 2025-08-17
  *
  * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
  *
@@ -17,7 +17,7 @@
 
 // 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[] = "2.0.0";  // NOTE: This should match the version in the library.properties file.
 
 // Number of available save slots.
 const byte StateManager::MAX_SAVE_SLOTS = 10;
@@ -33,60 +33,74 @@ 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);
-        return true;
+        success = true;
     }
     // EEPROM does not contain save data for this firmware & version.
     else {
         // Erase EEPROM and initialize state. Save default pattern to all save slots.
         factoryReset(app);
-        return false;
     }
+    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.
-    _saveMetadata(app);
+    // Persist this change in the global metadata on next update.
+    _isDirty = true;
 
+    interrupts();
     return true;
 }
 
 // Save app state to user specified save slot.
 void StateManager::saveData(const AppState& app) {
+    noInterrupts();
     // Check if slot_index is within max range + 1 for transient.
     if (app.selected_save_slot >= MAX_SAVE_SLOTS + 1) 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();
@@ -96,6 +110,7 @@ void StateManager::reset(AppState& app) {
     _loadMetadata(app);
 
     _isDirty = false;
+    interrupts();
 }
 
 void StateManager::markDirty() {
@@ -132,7 +147,6 @@ 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;
 
-    noInterrupts();
     static EepromData save_data;
 
     save_data.tempo = app.tempo;
@@ -140,6 +154,8 @@ void StateManager::_saveState(const AppState& app, byte slot_index) {
     save_data.selected_channel = app.selected_channel;
     save_data.selected_source = static_cast<byte>(app.selected_source);
     save_data.selected_pulse = static_cast<byte>(app.selected_pulse);
+    save_data.cv_run = app.cv_run;
+    save_data.cv_reset = app.cv_reset;
 
     // TODO: break this out into a separate function. Save State should be
     // broken out into global / per-channel save methods. When saving via
@@ -148,27 +164,25 @@ void StateManager::_saveState(const AppState& app, byte slot_index) {
     for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
         const auto& ch = app.channel[i];
         auto& save_ch = save_data.channel_data[i];
-        save_ch.base_clock_mod_index = ch.getClockModIndex(false);
-        save_ch.base_probability = ch.getProbability(false);
-        save_ch.base_duty_cycle = ch.getDutyCycle(false);
-        save_ch.base_offset = ch.getOffset(false);
-        save_ch.base_swing = ch.getSwing(false);
-        save_ch.base_euc_steps = ch.getSteps(false);
-        save_ch.base_euc_hits = ch.getHits(false);
+        save_ch.base_clock_mod_index = ch.getClockModIndex();
+        save_ch.base_probability = ch.getProbability();
+        save_ch.base_duty_cycle = ch.getDutyCycle();
+        save_ch.base_offset = ch.getOffset();
+        save_ch.base_swing = ch.getSwing();
+        save_ch.base_euc_steps = ch.getSteps();
+        save_ch.base_euc_hits = ch.getHits();
         save_ch.cv1_dest = static_cast<byte>(ch.getCv1Dest());
         save_ch.cv2_dest = static_cast<byte>(ch.getCv2Dest());
     }
 
     int address = EEPROM_DATA_START_ADDR + (slot_index * sizeof(EepromData));
     EEPROM.put(address, save_data);
-    interrupts();
 }
 
 void StateManager::_loadState(AppState& app, byte slot_index) {
     // Check if slot_index is within max range + 1 for transient.
     if (slot_index >= MAX_SAVE_SLOTS + 1) return;
 
-    noInterrupts();
     static EepromData load_data;
     int address = EEPROM_DATA_START_ADDR + (slot_index * sizeof(EepromData));
     EEPROM.get(address, load_data);
@@ -179,6 +193,8 @@ void StateManager::_loadState(AppState& app, byte slot_index) {
     app.selected_channel = load_data.selected_channel;
     app.selected_source = static_cast<Clock::Source>(load_data.selected_source);
     app.selected_pulse = static_cast<Clock::Pulse>(load_data.selected_pulse);
+    app.cv_run = load_data.cv_run;
+    app.cv_reset = load_data.cv_reset;
 
     for (int i = 0; i < Gravity::OUTPUT_COUNT; i++) {
         auto& ch = app.channel[i];
@@ -194,11 +210,9 @@ void StateManager::_loadState(AppState& app, byte slot_index) {
         ch.setCv1Dest(static_cast<CvDestination>(saved_ch_state.cv1_dest));
         ch.setCv2Dest(static_cast<CvDestination>(saved_ch_state.cv2_dest));
     }
-    interrupts();
 }
 
 void StateManager::_saveMetadata(const AppState& app) {
-    noInterrupts();
     Metadata current_meta;
     strcpy(current_meta.sketch_name, SKETCH_NAME);
     strcpy(current_meta.version, SEMANTIC_VERSION);
@@ -206,16 +220,15 @@ void StateManager::_saveMetadata(const AppState& app) {
     // 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);
-    interrupts();
 }
 
 void StateManager::_loadMetadata(AppState& app) {
-    noInterrupts();
     Metadata metadata;
     EEPROM.get(METADATA_START_ADDR, metadata);
     app.selected_save_slot = metadata.selected_save_slot;
     app.encoder_reversed = metadata.encoder_reversed;
-    interrupts();
+    app.rotate_display = metadata.rotate_display;
 }

firmware/Gravity/save_state.h

@@ -2,8 +2,8 @@
  * @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
+ * @version 2.0.0
+ * @date 2025-08-17
  *
  * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
  *
@@ -57,6 +57,7 @@ class StateManager {
         // Additional global/hardware settings
         byte selected_save_slot;
         bool encoder_reversed;
+        bool rotate_display;
     };
     struct ChannelState {
         byte base_clock_mod_index;
@@ -76,6 +77,8 @@ class StateManager {
         byte selected_channel;
         byte selected_source;
         byte selected_pulse;
+        byte cv_run;
+        byte cv_reset;
         ChannelState channel_data[Gravity::OUTPUT_COUNT];
     };
 

library.properties

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

src/analog_input.h

@@ -2,8 +2,8 @@
  * @file analog_input.h
  * @author Adam Wonak (https://github.com/awonak)
  * @brief Class for interacting with analog inputs.
- * @version 0.1
- * @date 2025-05-23
+ * @version 2.0.0
+ * @date 2025-08-17
  *
  * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
  *
@@ -19,6 +19,8 @@ const int CALIBRATED_HIGH = 512;
 
 class AnalogInput {
    public:
+    static const int GATE_THRESHOLD = 0;
+
     AnalogInput() {}
     ~AnalogInput() {}
 
@@ -74,6 +76,18 @@ class AnalogInput {
      */
     inline float Voltage() { return ((read_ / 512.0) * 5.0); }
 
+    /**
+     * Checks for a rising edge transition across a threshold.
+     *
+     * @param threshold The value that the input must cross.
+     * @return True if the value just crossed the threshold from below, false otherwise.
+     */
+    inline bool IsRisingEdge(int16_t threshold) const {
+        bool was_high = old_read_ > threshold;
+        bool is_high = read_ > threshold;
+        return is_high && !was_high;
+    }
+
    private:
     uint8_t pin_;
     int16_t read_;

src/button.h

@@ -2,8 +2,8 @@
  * @file button.h
  * @author Adam Wonak (https://github.com/awonak)
  * @brief Wrapper class for interacting with trigger / gate inputs.
- * @version 0.1
- * @date 2025-04-20
+ * @version 2.0.0
+ * @date 2025-08-17
   *
  * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
  *

src/clock.h

@@ -2,8 +2,8 @@
  * @file clock.h
  * @author Adam Wonak (https://github.com/awonak)
  * @brief Wrapper Class for clock timing functions.
- * @version 0.1
- * @date 2025-05-04
+ * @version 2.0.0
+ * @date 2025-08-17
  * 
  * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
  *
@@ -12,20 +12,12 @@
 #ifndef CLOCK_H
 #define CLOCK_H
 
-#include <NeoHWSerial.h>
 
 #include "peripherials.h"
 #include "uClock/uClock.h"
 
-// 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
-#define MIDI_CONTINUE 0xFB
-
 typedef void (*ExtCallback)(void);
 static ExtCallback extUserCallback = nullptr;
-static void serialEventNoop(uint8_t msg, uint8_t status) {}
 
 class Clock {
    public:
@@ -35,32 +27,25 @@ class Clock {
         SOURCE_INTERNAL,
         SOURCE_EXTERNAL_PPQN_24,
         SOURCE_EXTERNAL_PPQN_4,
+        SOURCE_EXTERNAL_PPQN_1,
         SOURCE_EXTERNAL_MIDI,
         SOURCE_LAST,
     };
 
     enum Pulse {
         PULSE_NONE,
-        PULSE_PPQN_1,
-        PULSE_PPQN_4,
         PULSE_PPQN_24,
+        PULSE_PPQN_4,
+        PULSE_PPQN_1,
         PULSE_LAST,
     };
 
     void Init() {
-        NeoSerial.begin(31250);
-
         // Initialize the clock library
         uClock.init();
         uClock.setClockMode(uClock.INTERNAL_CLOCK);
         uClock.setOutputPPQN(uClock.PPQN_96);
         uClock.setTempo(DEFAULT_TEMPO);
-
-        // MIDI events.
-        uClock.setOnClockStart(sendMIDIStart);
-        uClock.setOnClockStop(sendMIDIStop);
-        uClock.setOnSync24(sendMIDIClock);
-
         uClock.start();
     }
 
@@ -79,10 +64,6 @@ class Clock {
     void SetSource(Source source) {
         bool was_playing = !IsPaused();
         uClock.stop();
-        // If we are changing the source from MIDI, disable the serial interrupt handler.
-        if (source_ == SOURCE_EXTERNAL_MIDI) {
-            NeoSerial.attachInterrupt(serialEventNoop);
-        }
         source_ = source;
         switch (source) {
             case SOURCE_INTERNAL:
@@ -96,10 +77,11 @@ class Clock {
                 uClock.setClockMode(uClock.EXTERNAL_CLOCK);
                 uClock.setInputPPQN(uClock.PPQN_4);
                 break;
-            case SOURCE_EXTERNAL_MIDI:
+            case SOURCE_EXTERNAL_PPQN_1:
                 uClock.setClockMode(uClock.EXTERNAL_CLOCK);
-                uClock.setInputPPQN(uClock.PPQN_24);
-                NeoSerial.attachInterrupt(onSerialEvent);
+                uClock.setInputPPQN(uClock.PPQN_1);
+                break;
+            case SOURCE_EXTERNAL_MIDI:
                 break;
         }
         if (was_playing) {
@@ -155,37 +137,6 @@ class Clock {
    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/clock_midi.h

@@ -0,0 +1,197 @@
+/**
+ * @file clock.h
+ * @author Adam Wonak (https://github.com/awonak)
+ * @brief Wrapper Class for clock timing functions.
+ * @version 2.0.0
+ * @date 2025-08-17
+ * 
+ * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
+ *
+ */
+
+#ifndef CLOCK_H
+#define CLOCK_H
+
+
+#include <NeoHWSerial.h>
+
+#include "peripherials.h"
+#include "uClock/uClock.h"
+
+// 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
+#define MIDI_CONTINUE 0xFB
+
+typedef void (*ExtCallback)(void);
+static ExtCallback extUserCallback = nullptr;
+static void serialEventNoop(uint8_t msg, uint8_t status) {}
+
+class Clock {
+   public:
+    static constexpr int DEFAULT_TEMPO = 120;
+
+    enum Source {
+        SOURCE_INTERNAL,
+        SOURCE_EXTERNAL_PPQN_24,
+        SOURCE_EXTERNAL_PPQN_4,
+        SOURCE_EXTERNAL_PPQN_1,
+        SOURCE_EXTERNAL_MIDI,
+        SOURCE_LAST,
+    };
+
+    enum Pulse {
+        PULSE_NONE,
+        PULSE_PPQN_24,
+        PULSE_PPQN_4,
+        PULSE_PPQN_1,
+        PULSE_LAST,
+    };
+
+    void Init() {
+        NeoSerial.begin(31250);
+
+        // Initialize the clock library
+        uClock.init();
+        uClock.setClockMode(uClock.INTERNAL_CLOCK);
+        uClock.setOutputPPQN(uClock.PPQN_96);
+        uClock.setTempo(DEFAULT_TEMPO);
+
+        // MIDI events.
+        uClock.setOnClockStart(sendMIDIStart);
+        uClock.setOnClockStop(sendMIDIStop);
+        uClock.setOnSync24(sendMIDIClock);
+
+        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) {
+            case SOURCE_INTERNAL:
+                uClock.setClockMode(uClock.INTERNAL_CLOCK);
+                break;
+            case SOURCE_EXTERNAL_PPQN_24:
+                uClock.setClockMode(uClock.EXTERNAL_CLOCK);
+                uClock.setInputPPQN(uClock.PPQN_24);
+                break;
+            case SOURCE_EXTERNAL_PPQN_4:
+                uClock.setClockMode(uClock.EXTERNAL_CLOCK);
+                uClock.setInputPPQN(uClock.PPQN_4);
+                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();
+        }
+    }
+
+    // Return true if the current selected source is externl (PPQN_4, PPQN_24, or MIDI).
+    bool ExternalSource() {
+        return uClock.getClockMode() == uClock.EXTERNAL_CLOCK;
+    }
+
+    // Return true if the current selected source is the internal master clock.
+    bool InternalSource() {
+        return uClock.getClockMode() == uClock.INTERNAL_CLOCK;
+    }
+
+    // Returns the current BPM tempo.
+    int Tempo() {
+        return uClock.getTempo();
+    }
+
+    // Set the clock tempo to a int between 1 and 400.
+    void SetTempo(int tempo) {
+        return uClock.setTempo(tempo);
+    }
+
+    // Record an external clock tick received to process external/internal syncronization.
+    void Tick() {
+        uClock.clockMe();
+    }
+
+    // Start the internal clock.
+    void Start() {
+        uClock.start();
+    }
+
+    // Stop internal clock clock.
+    void Stop() {
+        uClock.stop();
+    }
+
+    // Reset all clock counters to 0.
+    void Reset() {
+        uClock.resetCounters();
+    }
+
+    // Returns true if the clock is not 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

@@ -2,8 +2,8 @@
  * @file digital_output.h
  * @author Adam Wonak (https://github.com/awonak)
  * @brief Class for interacting with trigger / gate outputs.
- * @version 0.1
- * @date 2025-04-17
+ * @version 2.0.0
+ * @date 2025-08-17
  * 
  * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
  *
@@ -82,7 +82,6 @@ class DigitalOutput {
     unsigned long last_triggered_;
     uint8_t trigger_duration_;
     uint8_t cv_pin_;
-    uint8_t led_pin_;
     bool on_;
 
     void update(uint8_t state) {

src/encoder.h

@@ -1,9 +1,9 @@
 /**
- * @file encoder_dir.h
+ * @file encoder.h
  * @author Adam Wonak (https://github.com/awonak)
  * @brief Class for interacting with encoders.
- * @version 0.1
- * @date 2025-04-19
+ * @version 2.0.0
+ * @date 2025-08-17
  * 
  * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
  *

src/libGravity.cpp

@@ -2,8 +2,8 @@
  * @file libGravity.cpp
  * @author Adam Wonak (https://github.com/awonak)
  * @brief Library for building custom scripts for the Sitka Instruments Gravity module.
- * @version 0.1
- * @date 2025-04-19
+ * @version 2.0.0
+ * @date 2025-08-17
  * 
  * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
  *
@@ -33,6 +33,7 @@ void Gravity::initInputs() {
     cv1.Init(CV1_PIN);
     cv2.Init(CV2_PIN);
 
+#if defined(ARDUINO_ARCH_AVR)
     // Pin Change Interrupts for Encoder.
     // Thanks to https://dronebotworkshop.com/interrupts/
 
@@ -42,6 +43,14 @@ void Gravity::initInputs() {
     PCMSK2 |= B00010000;
     // Select PCINT11 Bit3 (Pin D17/A3)
     PCMSK1 |= B00001000;
+#endif
+#if defined(ARDUINO_NANO_R4)
+  pinMode(ENCODER_PIN1, INPUT_PULLDOWN);
+  pinMode(ENCODER_PIN2, INPUT_PULLDOWN);
+  attachInterrupt(digitalPinToInterrupt(ENCODER_PIN1), Encoder::isr, CHANGE);
+  attachInterrupt(digitalPinToInterrupt(ENCODER_PIN2), Encoder::isr, CHANGE);
+#endif
+
 }
 
 void Gravity::initOutputs() {
@@ -74,6 +83,7 @@ void Gravity::Process() {
     }
 }
 
+#if defined(ARDUINO_ARCH_AVR)
 // Pin Change Interrupt on Port D (D4).
 ISR(PCINT2_vect) {
     Encoder::isr();
@@ -82,6 +92,8 @@ ISR(PCINT2_vect) {
 ISR(PCINT1_vect) {
     Encoder::isr();
 };
+#endif
+
 
 // Global instance
 Gravity gravity;

src/libGravity.h

@@ -2,8 +2,8 @@
  * @file libGravity.h
  * @author Adam Wonak (https://github.com/awonak)
  * @brief Library for building custom scripts for the Sitka Instruments Gravity module.
- * @version 0.1
- * @date 2025-04-19
+ * @version 2.0.0
+ * @date 2025-08-17
  * 
  * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
  *

src/peripherials.h

@@ -2,8 +2,8 @@
  * @file peripherials.h
  * @author Adam Wonak (https://github.com/awonak)
  * @brief Arduino pin definitions for the Sitka Instruments Gravity module.
- * @version 0.1
- * @date 2025-04-19
+ * @version 2.0.0
+ * @date 2025-08-17
  * 
  * @copyright MIT - (c) 2025 - Adam Wonak - adam.wonak@gmail.com
  *
@@ -24,8 +24,8 @@
 
 // Clock and CV Inputs
 #define EXT_PIN 2
-#define CV1_PIN A7
-#define CV2_PIN A6
+#define CV1_PIN 21 // A7
+#define CV2_PIN 20 // A6
 #define PULSE_OUT_PIN 3
 
 // Button pins

src/uClock/platforms/renesas.h

@@ -0,0 +1,72 @@
+#pragma once
+
+/**
+ * @file nano_r4.h
+ * @author Gemini (Based on the uClock AVR implementation)
+ * @brief uClock platform support for the Arduino Nano R4 (Renesas RA4M1).
+ *
+ * This file implements the timer initialization and control functions
+ * required by uClock using the FspTimer library, which provides a high-level
+ * interface to the General PWM Timers (GPT) on the Renesas RA4M1
+ * microcontroller. This approach replaces the direct register manipulation
+ * used for AVR platforms.
+ */
+
+#include <Arduino.h>
+#include <FspTimer.h>
+
+// ATOMIC macro for defining critical sections where interrupts are disabled.
+#define ATOMIC(X) noInterrupts(); X; interrupts();
+
+// Forward declaration of the uClock's main handler function. This function
+// must be defined in the main uClock library code and will be called by the timer interrupt.
+void uClockHandler();
+
+// Create an FspTimer instance for uClock.
+// We use GPT channel 6, as it is less likely to conflict with the default
+// analogWrite() (PWM) functionality on the Nano R4's pins.
+FspTimer uClockTimer;
+
+/**
+ * @brief Initializes the hardware timer for uClock.
+ *
+ * This function configures and starts a hardware timer (GPT6) to fire
+ * periodically. It attaches the uClockHandler as the interrupt service routine.
+ * The initial tempo is set to a default of 120 BPM (48 Hz tick rate).
+ *
+ * @param init_clock This parameter is unused on this platform but is kept
+ * for API compatibility with other uClock platforms.
+ */
+void initTimer(uint32_t init_clock)
+{
+    ATOMIC(
+        // Configure the timer to be a periodic interrupt source.
+        // The frequency/period arguments here are placeholders, as the actual
+        // period is set precisely with the setPeriod() call below.
+        uClockTimer.begin(TIMER_MODE_PERIODIC, GPT_TIMER, 6, 1.0f, STANDARD_PWM_FREQ_HZ);
+
+        // Set the timer's period to the provided BPM period in microseconds.
+        uClockTimer.set_period(init_clock);
+
+        // Start the timer to begin generating ticks.
+        uClockTimer.start();
+    )
+}
+
+/**
+ * @brief Sets the timer's interval in microseconds.
+ *
+ * This function dynamically updates the timer's period to match the specified
+ * interval, which effectively changes the clock's tempo. The FspTimer library
+ * automatically handles the complex low-level prescaler and counter adjustments.
+ *
+ * @param us_interval The desired interval between clock ticks in microseconds.
+ */
+void setTimer(uint32_t us_interval)
+{
+    // Atomically update the timer's period. The FspTimer library abstracts
+    // away the manual prescaler math required on AVR platforms.
+    ATOMIC(
+        uClockTimer.set_period(us_interval);
+    )
+}

src/uClock/uClock.cpp

@@ -32,7 +32,13 @@
  * DEALINGS IN THE SOFTWARE.
  */
 #include "uClock.h"
+
+#if defined(ARDUINO_ARCH_AVR)
 #include "platforms/avr.h"
+#endif
+#if defined(ARDUINO_NANO_R4)
+#include "platforms/renesas.h"
+#endif
 
 //
 // Platform specific timer setup/control