288 lines
9.3 KiB
C++
288 lines
9.3 KiB
C++
/**
|
|
* @file channel.h
|
|
* @author Adam Wonak (https://github.com/awonak/)
|
|
* @brief Alt firmware version of Gravity by Sitka Instruments.
|
|
* @version 2.0.0
|
|
* @date 2025-08-17
|
|
*
|
|
* @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_PROB,
|
|
CV_DEST_DUTY,
|
|
CV_DEST_OFFSET,
|
|
CV_DEST_SWING,
|
|
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_probability = 100;
|
|
base_duty_cycle = 50;
|
|
base_offset = 0;
|
|
base_swing = 50;
|
|
|
|
cv1_dest = CV_DEST_NONE;
|
|
cv2_dest = CV_DEST_NONE;
|
|
|
|
pattern.Init(DEFAULT_PATTERN);
|
|
|
|
// Calcule the clock mod pulses on init.
|
|
recalculatePulses();
|
|
}
|
|
|
|
bool inline 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);
|
|
recalculatePulses();
|
|
}
|
|
|
|
void setProbability(int prob) {
|
|
base_probability = constrain(prob, 0, 100);
|
|
}
|
|
|
|
void setDutyCycle(int duty) {
|
|
base_duty_cycle = constrain(duty, 1, 99);
|
|
recalculatePulses();
|
|
}
|
|
|
|
void setOffset(int off) {
|
|
base_offset = constrain(off, 0, 99);
|
|
recalculatePulses();
|
|
}
|
|
|
|
void setSwing(int val) {
|
|
base_swing = constrain(val, 50, 95);
|
|
recalculatePulses();
|
|
}
|
|
|
|
// Euclidean
|
|
void setSteps(int val) {
|
|
pattern.SetSteps(val);
|
|
}
|
|
void setHits(int val) {
|
|
pattern.SetHits(val);
|
|
}
|
|
|
|
void setCv1Dest(CvDestination dest) {
|
|
cv1_dest = dest;
|
|
recalculatePulses();
|
|
}
|
|
void setCv2Dest(CvDestination dest) {
|
|
cv2_dest = dest;
|
|
recalculatePulses();
|
|
}
|
|
CvDestination getCv1Dest() const { return cv1_dest; }
|
|
CvDestination getCv2Dest() const { return cv2_dest; }
|
|
|
|
// Getters (Get the BASE value for editing or cv modded value for display)
|
|
int getProbability() const { return base_probability; }
|
|
int getDutyCycle() const { return base_duty_cycle; }
|
|
int getOffset() const { return base_offset; }
|
|
int getSwing() const { return base_swing; }
|
|
int getClockMod() const { return pgm_read_word_near(&CLOCK_MOD[getClockModIndex()]); }
|
|
int getClockModIndex() const { return base_clock_mod_index; }
|
|
byte getSteps() const { return pattern.GetSteps(); }
|
|
byte getHits() const { return pattern.GetHits(); }
|
|
|
|
// Getters that calculate the value with CV modulation applied.
|
|
int getClockModIndexWithMod(int cv1_val, int cv2_val) {
|
|
int clock_mod_index = _calculateMod(CV_DEST_MOD, cv1_val, cv2_val, -(MOD_CHOICE_SIZE / 2), MOD_CHOICE_SIZE / 2);
|
|
return constrain(base_clock_mod_index + clock_mod_index, 0, MOD_CHOICE_SIZE - 1);
|
|
}
|
|
|
|
int 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; }
|
|
|
|
/**
|
|
* @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;
|
|
}
|
|
|
|
int cvmod_probability = base_probability;
|
|
if (cv1_dest == CV_DEST_PROB || cv2_dest == CV_DEST_PROB) {
|
|
cvmod_probability = getProbabilityWithMod(gravity.cv1.Read(), gravity.cv2.Read());
|
|
}
|
|
|
|
// Conditionally apply swing on down beats.
|
|
uint16_t swing_pulses = 0;
|
|
if (_swing_pulses > 0 && (tick / _mod_pulses) % 2 == 1) {
|
|
swing_pulses = _swing_pulses;
|
|
}
|
|
|
|
// 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();
|
|
}
|
|
}
|
|
|
|
void recalculatePulses() {
|
|
int cv1 = gravity.cv1.Read();
|
|
int cv2 = gravity.cv2.Read();
|
|
int clock_mod_index = getClockModIndexWithMod(cv1, cv2);
|
|
int duty_cycle = getDutyCycleWithMod(cv1, cv2);
|
|
int offset = getOffsetWithMod(cv1, cv2);
|
|
int swing = getSwingWithMod(cv1, cv2);
|
|
_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 (swing > 50) {
|
|
int shifted_swing = swing - 50;
|
|
_swing_pulses = (long)((_mod_pulses * (100L - shifted_swing)) / 100L);
|
|
} else {
|
|
_swing_pulses = 0;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
// User-settable base values.
|
|
byte base_clock_mod_index;
|
|
byte base_probability;
|
|
byte base_duty_cycle;
|
|
byte base_offset;
|
|
byte base_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 _mod_pulses;
|
|
uint16_t _duty_pulses;
|
|
uint16_t _offset_pulses;
|
|
uint16_t _swing_pulses;
|
|
};
|
|
|
|
#endif // CHANNEL_H
|