awonak/libGravity
1
1
Fork 0
Code Issues Pull Requests Packages Releases 2 Activity

Add menu options for using cv input as Clock Run/Reset #25

Merged
awonak merged 4 commits from run-reset into main 2025-08-10 00:25:07 +00:00
Conversation 0 Commits 4 Files Changed 7 +97 -5
7 changed files with 97 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit c3c5196b58 - Show all commits

9
firmware/Gravity/Gravity.ino
View File

@ -238,12 +238,6 @@ void HandleEncoderPressed() {
InitGravity(app); 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_param == PARAM_MAIN_FACTORY_RESET) {
if (app.selected_sub_param == 0) { // Erase if (app.selected_sub_param == 0) { // Erase
// Show bootsplash during slow erase operation. // Show bootsplash during slow erase operation.
@ -331,9 +325,6 @@ void editMainParameter(int val) {
case PARAM_MAIN_LOAD_DATA: case PARAM_MAIN_LOAD_DATA:
updateSelection(app.selected_sub_param, val, StateManager::MAX_SAVE_SLOTS + 1); updateSelection(app.selected_sub_param, val, StateManager::MAX_SAVE_SLOTS + 1);
break; break;
case PARAM_MAIN_RESET_STATE:
updateSelection(app.selected_sub_param, val, 2);
break;
case PARAM_MAIN_FACTORY_RESET: case PARAM_MAIN_FACTORY_RESET:
updateSelection(app.selected_sub_param, val, 2); updateSelection(app.selected_sub_param, val, 2);
break; break;

190
firmware/Gravity/channel.h
View File

@ -70,14 +70,6 @@ class Channel {
base_duty_cycle = 50; base_duty_cycle = 50;
base_offset = 0; base_offset = 0;
base_swing = 50; 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; cv1_dest = CV_DEST_NONE;
cv2_dest = CV_DEST_NONE; cv2_dest = CV_DEST_NONE;
@ -88,78 +80,100 @@ class Channel {
_recalculatePulses(); _recalculatePulses();
} }
bool isCvModActive() const { return cv1_dest != CV_DEST_NONE || cv2_dest != CV_DEST_NONE; }
// Setters (Set the BASE value) // Setters (Set the BASE value)
void setClockMod(int index) { void setClockMod(int index) {
base_clock_mod_index = constrain(index, 0, MOD_CHOICE_SIZE - 1); 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) { void setProbability(int prob) {
base_probability = constrain(prob, 0, 100); base_probability = constrain(prob, 0, 100);
if (!isCvModActive()) {
cvmod_probability = base_probability;
_recalculatePulses();
}
} }
void setDutyCycle(int duty) { void setDutyCycle(int duty) {
base_duty_cycle = constrain(duty, 1, 99); base_duty_cycle = constrain(duty, 1, 99);
if (!isCvModActive()) {
cvmod_duty_cycle = base_duty_cycle;
_recalculatePulses();
}
} }
void setOffset(int off) { void setOffset(int off) {
base_offset = constrain(off, 0, 99); base_offset = constrain(off, 0, 99);
if (!isCvModActive()) {
cvmod_offset = base_offset;
_recalculatePulses();
}
} }
void setSwing(int val) { void setSwing(int val) {
base_swing = constrain(val, 50, 95); base_swing = constrain(val, 50, 95);
if (!isCvModActive()) {
cvmod_swing = base_swing;
_recalculatePulses();
}
} }
// Euclidean // Euclidean
void setSteps(int val) { void setSteps(int val) {
base_euc_steps = constrain(val, 1, MAX_PATTERN_LEN); pattern.SetSteps(val);
if (cv1_dest != CV_DEST_EUC_STEPS && cv2_dest != CV_DEST_EUC_STEPS) {
pattern.SetSteps(val);
}
} }
void setHits(int val) { void setHits(int val) {
base_euc_hits = constrain(val, 1, base_euc_steps); pattern.SetHits(val);
if (cv1_dest != CV_DEST_EUC_HITS && cv2_dest != CV_DEST_EUC_HITS) {
pattern.SetHits(val);
}
} }
void setCv1Dest(CvDestination dest) { cv1_dest = dest; } void setCv1Dest(CvDestination dest) {
void setCv2Dest(CvDestination dest) { cv2_dest = dest; } cv1_dest = dest;
_recalculatePulses();
}
void setCv2Dest(CvDestination dest) {
cv2_dest = dest;
_recalculatePulses();
}
CvDestination getCv1Dest() const { return cv1_dest; } CvDestination getCv1Dest() const { return cv1_dest; }
CvDestination getCv2Dest() const { return cv2_dest; } CvDestination getCv2Dest() const { return cv2_dest; }
// Getters (Get the BASE value for editing or cv modded value for display) // Getters (Get the BASE value for editing or cv modded value for display)
int getProbability() const { return base_probability; }
int getDutyCycle() const { return base_duty_cycle; }
int getOffset() const { return base_offset; }
int getSwing() const { return base_swing; }
int getClockMod() const { return pgm_read_word_near(&CLOCK_MOD[getClockModIndex()]); }
int getClockModIndex() const { return base_clock_mod_index; }
byte getSteps() const { return pattern.GetSteps(); }
byte getHits() const { return pattern.GetHits(); }
int getProbability(bool withCvMod = false) const { return withCvMod ? cvmod_probability : base_probability; } // Getters that calculate the value with CV modulation applied.
int getDutyCycle(bool withCvMod = false) const { return withCvMod ? cvmod_duty_cycle : base_duty_cycle; } int getClockModIndexWithMod(int cv1_val, int cv2_val) {
int getOffset(bool withCvMod = false) const { return withCvMod ? cvmod_offset : base_offset; } int clock_mod_index = _calculateMod(CV_DEST_MOD, cv1_val, cv2_val, -(MOD_CHOICE_SIZE / 2), MOD_CHOICE_SIZE / 2);
int getSwing(bool withCvMod = false) const { return withCvMod ? cvmod_swing : base_swing; } return constrain(base_clock_mod_index + clock_mod_index, 0, MOD_CHOICE_SIZE - 1);
int getClockMod(bool withCvMod = false) const { return pgm_read_word_near(&CLOCK_MOD[getClockModIndex(withCvMod)]); } }
int getClockModIndex(bool withCvMod = false) const { return withCvMod ? cvmod_clock_mod_index : base_clock_mod_index; }
bool isCvModActive() const { return cv1_dest != CV_DEST_NONE || cv2_dest != CV_DEST_NONE; }
byte getSteps(bool withCvMod = false) const { return withCvMod ? pattern.GetSteps() : base_euc_steps; } int getClockModWithMod(int cv1_val, int cv2_val) {
byte getHits(bool withCvMod = false) const { return withCvMod ? pattern.GetHits() : base_euc_hits; } int clock_mod = _calculateMod(CV_DEST_MOD, cv1_val, cv2_val, -(MOD_CHOICE_SIZE / 2), MOD_CHOICE_SIZE / 2);
return pgm_read_word_near(&CLOCK_MOD[getClockModIndexWithMod(cv1_val, cv2_val)]);
}
int getProbabilityWithMod(int cv1_val, int cv2_val) {
int prob_mod = _calculateMod(CV_DEST_PROB, cv1_val, cv2_val, -50, 50);
return constrain(base_probability + prob_mod, 0, 100);
}
int getDutyCycleWithMod(int cv1_val, int cv2_val) {
int duty_mod = _calculateMod(CV_DEST_DUTY, cv1_val, cv2_val, -50, 50);
return constrain(base_duty_cycle + duty_mod, 1, 99);
}
int getOffsetWithMod(int cv1_val, int cv2_val) {
int offset_mod = _calculateMod(CV_DEST_OFFSET, cv1_val, cv2_val, -50, 50);
return constrain(base_offset + offset_mod, 0, 99);
}
int getSwingWithMod(int cv1_val, int cv2_val) {
int swing_mod = _calculateMod(CV_DEST_SWING, cv1_val, cv2_val, -25, 25);
return constrain(base_swing + swing_mod, 50, 95);
}
byte getStepsWithMod(int cv1_val, int cv2_val) {
int step_mod = _calculateMod(CV_DEST_EUC_STEPS, cv1_val, cv2_val, 0, MAX_PATTERN_LEN);
return constrain(pattern.GetSteps() + step_mod, 1, MAX_PATTERN_LEN);
}
byte getHitsWithMod(int cv1_val, int cv2_val) {
// The number of hits is dependent on the modulated number of steps.
byte modulated_steps = getStepsWithMod(cv1_val, cv2_val);
int hit_mod = _calculateMod(CV_DEST_EUC_HITS, cv1_val, cv2_val, 0, modulated_steps);
return constrain(pattern.GetHits() + hit_mod, 1, modulated_steps);
}
void toggleMute() { mute = !mute; } void toggleMute() { mute = !mute; }
@ -176,6 +190,13 @@ class Channel {
return; return;
} }
if (isCvModActive()) _recalculatePulses();
int cv1 = gravity.cv1.Read();
int cv2 = gravity.cv2.Read();
int cvmod_clock_mod_index = getClockModIndexWithMod(cv1, cv2);
int cvmod_probability = getProbabilityWithMod(cv1, cv2);
const uint16_t mod_pulses = pgm_read_word_near(&CLOCK_MOD_PULSES[cvmod_clock_mod_index]); const uint16_t mod_pulses = pgm_read_word_near(&CLOCK_MOD_PULSES[cvmod_clock_mod_index]);
// Conditionally apply swing on down beats. // Conditionally apply swing on down beats.
@ -211,56 +232,6 @@ class Channel {
output.Low(); 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, MOD_CHOICE_SIZE - 1);
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: private:
int _calculateMod(CvDestination dest, int cv1_val, int cv2_val, int min_range, int max_range) { int _calculateMod(CvDestination dest, int cv1_val, int cv2_val, int min_range, int max_range) {
@ -270,13 +241,19 @@ class Channel {
} }
void _recalculatePulses() { void _recalculatePulses() {
const uint16_t mod_pulses = pgm_read_word_near(&CLOCK_MOD_PULSES[cvmod_clock_mod_index]); int cv1 = gravity.cv1.Read();
_duty_pulses = max((long)((mod_pulses * (100L - cvmod_duty_cycle)) / 100L), 1L); int cv2 = gravity.cv2.Read();
_offset_pulses = (long)((mod_pulses * (100L - cvmod_offset)) / 100L); int clock_mod_index = getClockModIndexWithMod(cv1, cv2);
int duty_cycle = getDutyCycleWithMod(cv1, cv2);
int offset = getOffsetWithMod(cv1, cv2);
int swing = getSwingWithMod(cv1, cv2);
const uint16_t mod_pulses = pgm_read_word_near(&CLOCK_MOD_PULSES[clock_mod_index]);
_duty_pulses = max((long)((mod_pulses * (100L - duty_cycle)) / 100L), 1L);
_offset_pulses = (long)((mod_pulses * (100L - offset)) / 100L);
// Calculate the down beat swing amount. // Calculate the down beat swing amount.
if (cvmod_swing > 50) { if (swing > 50) {
int shifted_swing = cvmod_swing - 50; int shifted_swing = swing - 50;
_swing_pulse_amount = (long)((mod_pulses * (100L - shifted_swing)) / 100L); _swing_pulse_amount = (long)((mod_pulses * (100L - shifted_swing)) / 100L);
} else { } else {
_swing_pulse_amount = 0; _swing_pulse_amount = 0;
@ -289,15 +266,6 @@ class Channel {
byte base_duty_cycle; byte base_duty_cycle;
byte base_offset; byte base_offset;
byte base_swing; 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 // CV mod configuration
CvDestination cv1_dest; CvDestination cv1_dest;

30
firmware/Gravity/display.h
View File

@ -47,7 +47,7 @@ const uint8_t TEXT_FONT[437] U8G2_FONT_SECTION("velvetscreen") PROGMEM =
* https://stncrn.github.io/u8g2-unifont-helper/ * https://stncrn.github.io/u8g2-unifont-helper/
* "%/0123456789ABCDEFILNORSTUVXx" * "%/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" "\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)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" "\272\272\275\311H\321g\343\306\1\60\37|\373\35CJT\20:fW\207\320\210\60\42\304\204\30D\247"
@ -106,7 +106,6 @@ enum ParamsMainPage : uint8_t {
PARAM_MAIN_ENCODER_DIR, PARAM_MAIN_ENCODER_DIR,
PARAM_MAIN_SAVE_DATA, PARAM_MAIN_SAVE_DATA,
PARAM_MAIN_LOAD_DATA, PARAM_MAIN_LOAD_DATA,
PARAM_MAIN_RESET_STATE,
PARAM_MAIN_FACTORY_RESET, PARAM_MAIN_FACTORY_RESET,
PARAM_MAIN_LAST, PARAM_MAIN_LAST,
}; };
@ -327,15 +326,6 @@ void DisplayMainPage() {
: F("LOAD FROM SLOT"); : F("LOAD FROM SLOT");
} }
break; 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: case PARAM_MAIN_FACTORY_RESET:
if (app.selected_sub_param == 0) { if (app.selected_sub_param == 0) {
mainText = F("DEL"); mainText = F("DEL");
@ -351,7 +341,7 @@ void DisplayMainPage() {
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("CLK RUN"), F("CLK RESET"), F("PULSE OUT"), F("ENCODER DIR"), F("SAVE"), F("LOAD"), F("RESET"), F("ERASE")}; String menu_items[PARAM_MAIN_LAST] = {F("TEMPO"), F("SOURCE"), F("CLK RUN"), F("CLK RESET"), F("PULSE OUT"), F("ENCODER DIR"), F("SAVE"), F("LOAD"), F("ERASE")};
drawMenuItems(menu_items, PARAM_MAIN_LAST); drawMenuItems(menu_items, PARAM_MAIN_LAST);
} }
@ -368,10 +358,12 @@ void DisplayChannelPage() {
// 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;
int cv1 = gravity.cv1.Read();
int cv2 = gravity.cv2.Read();
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 = withCvMod ? ch.getClockModWithMod(cv1, cv2): ch.getClockMod();
if (mod_value > 1) { if (mod_value > 1) {
mainText = F("/"); mainText = F("/");
mainText += String(mod_value); mainText += String(mod_value);
@ -384,30 +376,30 @@ void DisplayChannelPage() {
break; break;
} }
case PARAM_CH_PROB: case PARAM_CH_PROB:
mainText = String(ch.getProbability(withCvMod)) + F("%"); mainText = String(withCvMod ? ch.getProbabilityWithMod(cv1, cv2) : ch.getProbability()) + F("%");
subText = F("HIT CHANCE"); subText = F("HIT CHANCE");
break; break;
case PARAM_CH_DUTY: case PARAM_CH_DUTY:
mainText = String(ch.getDutyCycle(withCvMod)) + F("%"); mainText = String(withCvMod ? ch.getDutyCycleWithMod(cv1, cv2) : ch.getDutyCycle()) + F("%");
subText = F("PULSE WIDTH"); subText = F("PULSE WIDTH");
break; break;
case PARAM_CH_OFFSET: case PARAM_CH_OFFSET:
mainText = String(ch.getOffset(withCvMod)) + F("%"); mainText = String(withCvMod ? ch.getOffsetWithMod(cv1, cv2) : ch.getOffset()) + F("%");
subText = F("SHIFT HIT"); subText = F("SHIFT HIT");
break; break;
case PARAM_CH_SWING: case PARAM_CH_SWING:
ch.getSwing() == 50 ch.getSwing() == 50
? mainText = F("OFF") ? mainText = F("OFF")
: mainText = String(ch.getSwing(withCvMod)) + F("%"); : mainText = String(withCvMod ? ch.getSwingWithMod(cv1, cv2) : ch.getSwing()) + F("%");
subText = "DOWN BEAT"; subText = "DOWN BEAT";
swingDivisionMark(); swingDivisionMark();
break; break;
case PARAM_CH_EUC_STEPS: case PARAM_CH_EUC_STEPS:
mainText = String(ch.getSteps(withCvMod)); mainText = String(withCvMod ? ch.getStepsWithMod(cv1, cv2) : ch.getSteps());
subText = "EUCLID STEPS"; subText = "EUCLID STEPS";
break; break;
case PARAM_CH_EUC_HITS: case PARAM_CH_EUC_HITS:
mainText = String(ch.getHits(withCvMod)); mainText = String(withCvMod ? ch.getHitsWithMod(cv1, cv2) : ch.getHits());
subText = "EUCLID HITS"; subText = "EUCLID HITS";
break; break;
case PARAM_CH_CV1_DEST: case PARAM_CH_CV1_DEST:

14
firmware/Gravity/save_state.cpp
View File

@ -152,13 +152,13 @@ void StateManager::_saveState(const AppState& app, byte slot_index) {
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();
save_ch.base_probability = ch.getProbability(false); save_ch.base_probability = ch.getProbability();
save_ch.base_duty_cycle = ch.getDutyCycle(false); save_ch.base_duty_cycle = ch.getDutyCycle();
save_ch.base_offset = ch.getOffset(false); save_ch.base_offset = ch.getOffset();
save_ch.base_swing = ch.getSwing(false); save_ch.base_swing = ch.getSwing();
save_ch.base_euc_steps = ch.getSteps(false); save_ch.base_euc_steps = ch.getSteps();
save_ch.base_euc_hits = ch.getHits(false); save_ch.base_euc_hits = ch.getHits();
save_ch.cv1_dest = static_cast<byte>(ch.getCv1Dest()); save_ch.cv1_dest = static_cast<byte>(ch.getCv1Dest());
save_ch.cv2_dest = static_cast<byte>(ch.getCv2Dest()); save_ch.cv2_dest = static_cast<byte>(ch.getCv2Dest());
} }