Zach's git repos / HexBoard
Firmware for HexBoard MIDI controller
Diffstat
-rw-r--r--Classes.h158
-rw-r--r--Constants.h140
-rw-r--r--Hexperiment.ino1820
-rw-r--r--Presets.h336
4 files changed, 1197 insertions, 1257 deletions
diff --git a/Classes.h b/Classes.h
new file mode 100644
index 0000000..133d3a5
--- /dev/null
+++ b/Classes.h
@@ -0,0 +1,158 @@
+// class definitions are in a header so that
+// they get read before compiling the main program.
+
+class tuningDef {
+public:
+ std::string name; // limit is 17 characters for GEM menu
+ byte cycleLength; // steps before period/cycle/octave repeats
+ float stepSize; // in cents, 100 = "normal" semitone.
+ SelectOptionInt keyChoices[MAX_SCALE_DIVISIONS];
+ int spanCtoA() {
+ return (- keyChoices[0].val_int);
+ };
+};
+
+class layoutDef {
+public:
+ std::string name; // limit is 17 characters for GEM menu
+ bool isPortrait; // affects orientation of the GEM menu only.
+ byte hexMiddleC; // instead of "what note is button 1", "what button is the middle"
+ int8_t acrossSteps; // defined this way to be compatible with original v1.1 firmare
+ int8_t dnLeftSteps; // defined this way to be compatible with original v1.1 firmare
+ byte tuning; // index of the tuning that this layout is designed for
+};
+
+class colorDef {
+public:
+ float hue;
+ byte sat;
+ byte val;
+ colorDef mixWithWhite() {
+ colorDef temp;
+ temp.hue = this->hue;
+ temp.sat = ((this->sat > SAT_TINT) ? SAT_TINT : this->sat);
+ temp.val = VALUE_FULL;
+ return temp;
+ };
+};
+
+class paletteDef {
+public:
+ colorDef swatch[MAX_SCALE_DIVISIONS]; // the different colors used in this palette
+ byte colorNum[MAX_SCALE_DIVISIONS]; // map key (c,d...) to swatches
+ colorDef getColor(byte givenStepFromC) {
+ return swatch[colorNum[givenStepFromC] - 1];
+ };
+ float getHue(byte givenStepFromC) {
+ return getColor(givenStepFromC).hue;
+ };
+ byte getSat(byte givenStepFromC) {
+ return getColor(givenStepFromC).sat;
+ };
+ byte getVal(byte givenStepFromC) {
+ return getColor(givenStepFromC).val;
+ };
+};
+
+class buttonDef {
+public:
+ byte btnState = 0; // binary 00 = off, 01 = just pressed, 10 = just released, 11 = held
+ void interpBtnPress(bool isPress) {
+ btnState = (((btnState << 1) + isPress) & 3);
+ };
+ int8_t coordRow = 0; // hex coordinates
+ int8_t coordCol = 0; // hex coordinates
+ uint32_t timePressed = 0; // timecode of last press
+ uint32_t LEDcolorAnim = 0; // calculate it once and store value, to make LED playback snappier
+ uint32_t LEDcolorPlay = 0; // calculate it once and store value, to make LED playback snappier
+ uint32_t LEDcolorOn = 0; // calculate it once and store value, to make LED playback snappier
+ uint32_t LEDcolorOff = 0; // calculate it once and store value, to make LED playback snappier
+ bool animate = 0; // hex is flagged as part of the animation in this frame, helps make animations smoother
+ int16_t stepsFromC = 0; // number of steps from C4 (semitones in 12EDO; microtones if >12EDO)
+ bool isCmd = 0; // 0 if it's a MIDI note; 1 if it's a MIDI control cmd
+ bool inScale = 0; // 0 if it's not in the selected scale; 1 if it is
+ byte note = UNUSED_NOTE; // MIDI note or control parameter corresponding to this hex
+ int16_t bend = 0; // in microtonal mode, the pitch bend for this note needed to be tuned correctly
+ byte channel = 0; // what MIDI channel this note is playing on
+ float frequency = 0.0; // what frequency to ring on the buzzer
+};
+
+class wheelDef {
+public:
+ bool alternateMode; // two ways to control
+ bool isSticky; // TRUE if you leave value unchanged when no buttons pressed
+ byte* topBtn; // pointer to the key Status of the button you use as this button
+ byte* midBtn;
+ byte* botBtn;
+ int16_t minValue;
+ int16_t maxValue;
+ int* stepValue; // this can be changed via GEM menu
+ int16_t defValue; // snapback value
+ int16_t curValue;
+ int16_t targetValue;
+ uint32_t timeLastChanged;
+ void setTargetValue() {
+ if (alternateMode) {
+ if (*midBtn >> 1) { // middle button toggles target (0) vs. step (1) mode
+ int16_t temp = curValue;
+ if (*topBtn == 1) {temp += *stepValue;}; // tap button
+ if (*botBtn == 1) {temp -= *stepValue;}; // tap button
+ if (temp > maxValue) {temp = maxValue;}
+ else if (temp <= minValue) {temp = minValue;};
+ targetValue = temp;
+ } else {
+ switch (((*topBtn >> 1) << 1) + (*botBtn >> 1)) {
+ case 0b10: targetValue = maxValue; break;
+ case 0b11: targetValue = defValue; break;
+ case 0b01: targetValue = minValue; break;
+ default: targetValue = curValue; break;
+ };
+ };
+ } else {
+ switch (((*topBtn >> 1) << 2) + ((*midBtn >> 1) << 1) + (*botBtn >> 1)) {
+ case 0b100: targetValue = maxValue; break;
+ case 0b110: targetValue = (3 * maxValue + minValue) / 4; break;
+ case 0b010:
+ case 0b111:
+ case 0b101: targetValue = (maxValue + minValue) / 2; break;
+ case 0b011: targetValue = (maxValue + 3 * minValue) / 4; break;
+ case 0b001: targetValue = minValue; break;
+ case 0b000: targetValue = (isSticky ? curValue : defValue); break;
+ default: break;
+ };
+ }
+ };
+ bool updateValue(uint32_t givenTime) {
+ int16_t temp = targetValue - curValue;
+ if (temp != 0) {
+ if ((givenTime - timeLastChanged) >= CC_MSG_COOLDOWN_MICROSECONDS ) {
+ timeLastChanged = givenTime;
+ if (abs(temp) < *stepValue) {
+ curValue = targetValue;
+ } else {
+ curValue = curValue + (*stepValue * (temp / abs(temp)));
+ };
+ return 1;
+ } else {
+ return 0;
+ };
+ } else {
+ return 0;
+ };
+ };
+};
+// back button
+
+class scaleDef {
+public:
+ std::string name;
+ byte tuning;
+ byte pattern[MAX_SCALE_DIVISIONS];
+};
+
+// this class should only be touched by the 2nd core
+class oscillator {
+public:
+ uint16_t increment = 0;
+ uint16_t counter = 0;
+}; \ No newline at end of file
diff --git a/Constants.h b/Constants.h
new file mode 100644
index 0000000..a38732b
--- /dev/null
+++ b/Constants.h
@@ -0,0 +1,140 @@
+// hardware pins
+#define SDAPIN 16
+#define SCLPIN 17
+#define LED_PIN 22
+#define ROT_PIN_A 20
+#define ROT_PIN_B 21
+#define ROT_PIN_C 24
+#define MPLEX_1_PIN 4
+#define MPLEX_2_PIN 5
+#define MPLEX_4_PIN 2
+#define MPLEX_8_PIN 3
+#define COLUMN_PIN_0 6
+#define COLUMN_PIN_1 7
+#define COLUMN_PIN_2 8
+#define COLUMN_PIN_3 9
+#define COLUMN_PIN_4 10
+#define COLUMN_PIN_5 11
+#define COLUMN_PIN_6 12
+#define COLUMN_PIN_7 13
+#define COLUMN_PIN_8 14
+#define COLUMN_PIN_9 15
+#define TONEPIN 23
+
+// grid related
+#define LED_COUNT 140
+#define COLCOUNT 10
+#define ROWCOUNT 14
+
+#define HEX_DIRECTION_EAST 0
+#define HEX_DIRECTION_NE 1
+#define HEX_DIRECTION_NW 2
+#define HEX_DIRECTION_WEST 3
+#define HEX_DIRECTION_SW 4
+#define HEX_DIRECTION_SE 5
+
+#define CMDBTN_0 0
+#define CMDBTN_1 20
+#define CMDBTN_2 40
+#define CMDBTN_3 60
+#define CMDBTN_4 80
+#define CMDBTN_5 100
+#define CMDBTN_6 120
+#define CMDCOUNT 7
+
+// microtonal related
+#define TUNINGCOUNT 13
+
+#define TUNING_12EDO 0
+#define TUNING_17EDO 1
+#define TUNING_19EDO 2
+#define TUNING_22EDO 3
+#define TUNING_24EDO 4
+#define TUNING_31EDO 5
+#define TUNING_41EDO 6
+#define TUNING_53EDO 7
+#define TUNING_72EDO 8
+#define TUNING_BP 9
+#define TUNING_ALPHA 10
+#define TUNING_BETA 11
+#define TUNING_GAMMA 12
+
+#define MAX_SCALE_DIVISIONS 72
+#define ALL_TUNINGS 255
+
+// MIDI-related
+#define CONCERT_A_HZ 440.0
+#define PITCH_BEND_SEMIS 2
+#define CMDB 192
+#define UNUSED_NOTE 255
+#define CC_MSG_COOLDOWN_MICROSECONDS 32768
+
+// buzzer related
+#define TONE_SL 3
+#define TONE_CH 1
+#define WAVEFORM_SQUARE 0
+#define WAVEFORM_SAW 1
+#define POLL_INTERVAL_IN_MICROSECONDS 32
+#define POLYPHONY_LIMIT 15
+#define ALARM_NUM 2
+#define ALARM_IRQ TIMER_IRQ_2
+#define BUZZ_OFF 0
+#define BUZZ_MONO 1
+#define BUZZ_ARPEGGIO 2
+#define BUZZ_POLY 3
+
+// LED related
+
+// value / brightness ranges from 0..255
+// black = 0, full strength = 255
+
+#define VALUE_BLACK 0
+#define VALUE_LOW 64
+#define VALUE_SHADE 128
+#define VALUE_NORMAL 192
+#define VALUE_FULL 255
+
+// saturation ranges from 0..255
+// 0 = black and white
+// 255 = full chroma
+
+#define SAT_BW 0
+#define SAT_TINT 32
+#define SAT_DULL 85
+#define SAT_MODERATE 170
+#define SAT_VIVID 255
+
+// hue is an angle from 0.0 to 359.9
+// there is a transform function to map "perceptual"
+// hues to RGB. the hue values below are perceptual.
+#define HUE_NONE 0.0
+#define HUE_RED 0.0
+#define HUE_ORANGE 36.0
+#define HUE_YELLOW 72.0
+#define HUE_LIME 108.0
+#define HUE_GREEN 144.0
+#define HUE_CYAN 180.0
+#define HUE_BLUE 216.0
+#define HUE_INDIGO 252.0
+#define HUE_PURPLE 288.0
+#define HUE_MAGENTA 324.0
+
+#define RAINBOW_MODE 0
+#define TIERED_COLOR_MODE 1
+
+// animations
+#define ANIMATE_NONE 0
+#define ANIMATE_STAR 1
+#define ANIMATE_SPLASH 2
+#define ANIMATE_ORBIT 3
+#define ANIMATE_OCTAVE 4
+#define ANIMATE_BY_NOTE 5
+
+// menu-related
+#define MENU_ITEM_HEIGHT 10
+#define MENU_PAGE_SCREEN_TOP_OFFSET 10
+#define MENU_VALUES_LEFT_OFFSET 78
+
+// debug
+#define DIAGNOSTIC_OFF 0
+#define DIAGNOSTIC_ON 1 \ No newline at end of file
diff --git a/Hexperiment.ino b/Hexperiment.ino
index a5aab7a..9b93007 100644
--- a/Hexperiment.ino
+++ b/Hexperiment.ino
@@ -35,875 +35,212 @@
#include <queue> // std::queue construct to store open channels in microtonal mode
#include <string>
- // hardware pins
- #define SDAPIN 16
- #define SCLPIN 17
+ #include "Constants.h" // preprocessor constants / macros
+ #include "Classes.h" // type definitions
+ #include "Presets.h" // pre-load tuning, scale, palette, layout definitions
+
+ // ====== useful math functions
+ int positiveMod(int n, int d) {
+ return (((n % d) + d) % d);
+ }
+
+ byte byteLerp(byte xOne, byte xTwo, float yOne, float yTwo, float y) {
+ float weight = (y - yOne) / (yTwo - yOne);
+ int temp = xOne + ((xTwo - xOne) * weight);
+ if (temp < xOne) {temp = xOne;};
+ if (temp > xTwo) {temp = xTwo;};
+ return temp;
+ }
- // USB MIDI object //
Adafruit_USBD_MIDI usb_midi;
// Create a new instance of the Arduino MIDI Library,
// and attach usb_midi as the transport.
MIDI_CREATE_INSTANCE(Adafruit_USBD_MIDI, usb_midi, MIDI);
- #define CONCERT_A_HZ 440.0
- int16_t channelBend[16]; // what's the current note bend on this channel
- byte channelPoly[16]; // how many notes are playing on this channel
- std::queue<byte> openChannelQueue;
- #define PITCH_BEND_SEMIS 2
- // LED SETUP //
- #define LED_PIN 22
- #define LED_COUNT 140
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
- // ENCODER SETUP //
- #define ROT_PIN_A 20
- #define ROT_PIN_B 21
- #define ROT_PIN_C 24
Rotary rotary = Rotary(ROT_PIN_A, ROT_PIN_B);
bool rotaryIsClicked = HIGH; //
bool rotaryWasClicked = HIGH; //
int8_t rotaryKnobTurns = 0; //
- byte maxKnobTurns = 10;
+ byte maxKnobTurns = 3;
// Create an instance of the U8g2 graphics library.
U8G2_SH1107_SEEED_128X128_F_HW_I2C u8g2(U8G2_R2, /* reset=*/ U8X8_PIN_NONE);
// Create menu object of class GEM_u8g2. Supply its constructor with reference to u8g2 object we created earlier
- #define MENU_ITEM_HEIGHT 10
- #define MENU_PAGE_SCREEN_TOP_OFFSET 10
- #define MENU_VALUES_LEFT_OFFSET 78
GEM_u8g2 menu(
u8g2, GEM_POINTER_ROW, GEM_ITEMS_COUNT_AUTO,
MENU_ITEM_HEIGHT, MENU_PAGE_SCREEN_TOP_OFFSET, MENU_VALUES_LEFT_OFFSET
);
- const byte defaultContrast = 63; // GFX default contrast
- bool screenSaverOn = 0; //
- uint32_t screenTime = 0; // GFX timer to count if screensaver should go on
- const uint32_t screenSaverMillis = 10'000; //
+ const byte defaultContrast = 63; // GFX default contrast
+ bool screenSaverOn = 0; //
+ uint64_t screenTime = 0; // GFX timer to count if screensaver should go on
+ const uint64_t screenSaverTimeout = (1u << 23); // 2^23 microseconds ~ 8 seconds
- // DIAGNOSTICS //
- // 1 = Full button test (1 and 0)
- // 2 = Button test (button number)
- // 3 = MIDI output test
- // 4 = Loop timing readout in milliseconds
- const byte diagnostics = 0;
+ const byte diagnostics = DIAGNOSTIC_ON;
// Global time variables
- uint32_t runTime = 0; // Program loop consistent variable for time in milliseconds since power on
- uint32_t lapTime = 0; // Used to keep track of how long each loop takes. Useful for rate-limiting.
- uint32_t loopTime = 0; // Used to check speed of the loop in diagnostics mode 4
- byte animationFPS = 32; // actually frames per 2^10 seconds. close enough to 30fps
- int16_t rainbowDegreeTime = 64; // ms to go through 1/360 of rainbow.
+ uint64_t runTime = 0; // Program loop consistent variable for time in microseconds since power on
+ uint64_t lapTime = 0; // Used to keep track of how long each loop takes. Useful for rate-limiting.
+ uint64_t loopTime = 0; // Used to check speed of the loop in diagnostics mode 4
+
+ // animation variables E NE NW W SW SE
+ int8_t vertical[] = { 0,-1,-1, 0, 1, 1};
+ int8_t horizontal[] = { 2, 1,-1,-2,-1, 1};
+
+ byte animationFPS = 32; // actually frames per 2^20 microseconds. close enough to 30fps
+ int32_t rainbowDegreeTime = 65'536; // microseconds to go through 1/360 of rainbow
// Button matrix and LED locations (PROD unit only)
- #define MPLEX_1_PIN 4
- #define MPLEX_2_PIN 5
- #define MPLEX_4_PIN 2
- #define MPLEX_8_PIN 3
const byte mPin[] = {
MPLEX_1_PIN, MPLEX_2_PIN, MPLEX_4_PIN, MPLEX_8_PIN
};
- #define COLUMN_PIN_0 6
- #define COLUMN_PIN_1 7
- #define COLUMN_PIN_2 8
- #define COLUMN_PIN_3 9
- #define COLUMN_PIN_4 10
- #define COLUMN_PIN_5 11
- #define COLUMN_PIN_6 12
- #define COLUMN_PIN_7 13
- #define COLUMN_PIN_8 14
- #define COLUMN_PIN_9 15
const byte cPin[] = {
COLUMN_PIN_0, COLUMN_PIN_1, COLUMN_PIN_2, COLUMN_PIN_3,
COLUMN_PIN_4, COLUMN_PIN_5, COLUMN_PIN_6,
COLUMN_PIN_7, COLUMN_PIN_8, COLUMN_PIN_9
};
- #define COLCOUNT 10
- #define ROWCOUNT 14
-
- // Since MIDI only uses 7 bits, we can give greater values special meanings.
- // (see commandPress)
- // start CMDB in a range that won't interfere with layouts.
- #define CMDB 192
- #define UNUSED_NOTE 255
-
- // LED addresses for CMD buttons. (consequencely, also the button address too)
- #define CMDBTN_0 0
- #define CMDBTN_1 20
- #define CMDBTN_2 40
- #define CMDBTN_3 60
- #define CMDBTN_4 80
- #define CMDBTN_5 100
- #define CMDBTN_6 120
const byte assignCmd[] = {
CMDBTN_0, CMDBTN_1, CMDBTN_2, CMDBTN_3,
CMDBTN_4, CMDBTN_5, CMDBTN_6
};
- #define CMDCOUNT 7
// MIDI note layout tables overhauled procedure since v1.1
- // FIRST, some introductory declarations
- typedef struct { // defines the hex-grid coordinates using a double-offset system
- int8_t row;
- int8_t col;
- } coordinates; // probably could have done this as a std::pair, but was too lazy
-
- enum {
- Right, UpRight, UpLeft, Left, DnLeft, DnRight
- }; // the six cardinal directions on the hex grid are 0 thru 5, counter-clockwise
-
- enum {
- Twelve, Seventeen, Nineteen, TwentyTwo,
- TwentyFour, ThirtyOne, FortyOne, FiftyThree,
- SeventyTwo, BohlenPierce,
- CarlosA, CarlosB, CarlosG
- }; // this is supposed to help with code legibility, weird as it looks.
- // tuning # 0 is 12-EDO, so refer to that index 0 as "Twelve"
- // then the next tuning #1 is 17-EDO so refer to index 1 as Seventeen, etc.
-
- // SECOND, each button is an object, of type "buttonDef"
- typedef struct {
- byte keyState = 0; // binary 00 = off, 01 = just pressed, 10 = just released, 11 = held
- coordinates coords = {0,0}; // the hexagonal coordinates
- uint32_t timePressed = 0; // timecode of last press
- uint32_t LEDcolorAnim = 0; // calculate it once and store value, to make LED playback snappier
- uint32_t LEDcolorPlay = 0; // calculate it once and store value, to make LED playback snappier
- uint32_t LEDcolorOn = 0; // calculate it once and store value, to make LED playback snappier
- uint32_t LEDcolorOff = 0; // calculate it once and store value, to make LED playback snappier
- bool animate = 0; // hex is flagged as part of the animation in this frame, helps make animations smoother
- int16_t steps = 0; // number of steps from key center (semitones in 12EDO; microtones if >12EDO)
- bool isCmd = 0; // 0 if it's a MIDI note; 1 if it's a MIDI control cmd
- bool inScale = 0; // 0 if it's not in the selected scale; 1 if it is
- byte note = UNUSED_NOTE; // MIDI note or control parameter corresponding to this hex
- int16_t bend; // in microtonal mode, the pitch bend for this note needed to be tuned correctly
- byte channel; // what MIDI channel this note is playing on
- float frequency; // what frequency to ring on the buzzer
- void updateKeyState(bool keyPressed) {
- keyState = (((keyState << 1) + keyPressed) & 3);
- if (keyState == 1) {
- timePressed = millis(); // log the time
- };
- };
- uint32_t animFrame() {
- if (timePressed) { // 2^10 milliseconds is close enough to 1 second
- return 1 + (((runTime - timePressed) * animationFPS) >> 10);
- } else {
- return 0;
- };
- };
- } buttonDef; // a better C++ programmer than me would turn this into some
- // fancy class definition in a header. i'm not that programmer!
buttonDef h[LED_COUNT]; // a collection of all the buttons from 0 to 139
// h[i] refers to the button with the LED address = i.
-
- // THIRD, each layout can be built on the fly. used to be done
- // separately in the ./makeLayout.py script, but not anymore.
- // with the introduction of microtonal tunings, note that each tuning
- // has its own list of layouts that are useful in that tuning.
-
- typedef struct {
- std::string name;
- bool isPortrait;
- byte rootHex; // instead of "what note is button 1", "what button is the middle"
- int8_t acrossSteps; // defined this way to be compatible with original v1.1 firmare
- int8_t dnLeftSteps; // defined this way to be compatible with original v1.1 firmare
- byte tuning;
- } layoutDef;
-
- layoutDef layoutOptions[] = {
- { "Wicki-Hayden", 1, 64, 2, -7, Twelve },
- { "Harmonic Table", 0, 75, -7, 3, Twelve },
- { "Janko", 0, 65, -1, -1, Twelve },
- { "Gerhard", 0, 65, -1, -3, Twelve },
- { "Accordion C-sys.", 1, 75, 2, -3, Twelve },
- { "Accordion B-sys.", 1, 64, 1, -3, Twelve },
- { "Full Layout", 1, 65, -1, -9, Twelve },
- { "Bosanquet, 17", 0, 65, -2, -1, Seventeen },
- { "Full Layout", 1, 65, -1, -9, Seventeen },
- { "Bosanquet, 19", 0, 65, -1, -2, Nineteen },
- { "Full Layout", 1, 65, -1, -9, Nineteen },
- { "Bosanquet, 22", 0, 65, -3, -1, TwentyTwo },
- { "Full Layout", 1, 65, -1, -9, TwentyTwo },
- { "Bosanquet, 24", 0, 65, -1, -3, TwentyFour },
- { "Full Layout", 1, 65, -1, -9, TwentyFour },
- { "Bosanquet, 31", 0, 65, -2, -3, ThirtyOne },
- { "Full Layout", 1, 65, -1, -9, ThirtyOne },
- { "Bosanquet, 41", 0, 65, -4, -3, FortyOne }, // forty-one #1
- { "Gerhard, 41", 0, 65, 3, -10, FortyOne }, // forty-one #2
- { "Full Layout, 41", 0, 65, -1, -8, FortyOne }, // forty-one #3
- { "Wicki-Hayden, 53", 1, 64, 9, -31, FiftyThree },
- { "Harmonic Tbl, 53", 0, 75, -31, 14, FiftyThree },
- { "Bosanquet, 53", 0, 65, -5, -4, FiftyThree },
- { "Full Layout, 53", 0, 65, -1, -9, FiftyThree },
- { "Full Layout, 72", 0, 65, -1, -9, SeventyTwo },
- { "Full Layout", 1, 65, -1, -9, BohlenPierce },
- { "Full Layout", 1, 65, -1, -9, CarlosA },
- { "Full Layout", 1, 65, -1, -9, CarlosB },
- { "Full Layout", 1, 65, -1, -9, CarlosG }
- };
+ byte enableMIDI = 1;
const byte layoutCount = sizeof(layoutOptions) / sizeof(layoutDef);
+ const byte scaleCount = sizeof(scaleOptions) / sizeof(scaleDef);
- // FOURTH, since we updated routine for the piezo buzzer
- // we no longer rely on the Arduino tone() function.
- // instead we wrote our own pulse generator using the
- // system clock, and can pass precise frequencies
- // up to ~12kHz. the exact frequency of each button
- // depends on the tuning system, defined in the struct below.
-
- typedef struct {
- std::string name;
- byte cycleLength; // steps before repeat
- float stepSize; // in cents, 100 = "normal" semitone.
- } tuningDef;
-
- tuningDef tuningOptions[] = {
- // replaces the idea of const byte EDO[] = { 12, 17, 19, 22, 24, 31, 41, 53, 72 };
- { "12 EDO", 12, 100.0 },
- { "17 EDO", 17, 1200.0 / 17 },
- { "19 EDO", 19, 1200.0 / 19 },
- { "22 EDO", 22, 1200.0 / 22 },
- { "24 EDO", 24, 50.0 },
- { "31 EDO", 31, 1200.0 / 31 },
- { "41 EDO", 41, 1200.0 / 41 },
- { "53 EDO", 53, 1200.0 / 53 },
- { "72 EDO", 72, 100.0 / 6 },
- { "Bohlen-Pierce", 13, 1901.955 / 13 }, //
- { "Carlos Alpha", 9, 77.965 }, //
- { "Carlos Beta", 11, 63.833 }, //
- { "Carlos Gamma", 20, 35.099 }
- };
- const byte tuningCount = sizeof(tuningOptions) / sizeof(tuningDef);
+ // Tone and Arpeggiator variables
+ oscillator synth[POLYPHONY_LIMIT]; // maximum polyphony
+ byte poly = 0; // current polyphony
+ std::queue<byte> openChannelQueue;
+ const byte attenuation[] = {67,67,48,39,34,30,28,26,24,23,22,21,20,19,18,17};
- #define TONEPIN 23
- #define TONE_SL 3
- #define TONE_CH 1
- #define WAVE_RESOLUTION 16
- #define ALARM_NUM 2
- #define ALARM_IRQ TIMER_IRQ_2
+ byte arpeggiatingNow = UNUSED_NOTE; // if this is 255, buzzer set to off (0% duty cycle)
+ uint64_t arpeggiateTime = 0; // Used to keep track of when this note started buzzin
+ uint32_t arpeggiateLength = 65'536; // in microseconds
- typedef struct {
- std::string name;
- byte lvl[WAVE_RESOLUTION];
- } waveDef;
- waveDef wf[] = { // from [0..129]
- {"Square", {0,0,0,0,0,0,0,0,129,129,129,129,129,129,129,129}},
- {"Saw", {0,9,17,26,34,43,52,60,69,77,86,95,103,112,120,129}},
- {"3iangle", {0,16,32,48,65,81,97,113,129,113,97,81,65,48,32,16}},
- {"Sine", {0,5,19,40,65,89,110,124,129,124,110,89,65,40,19,5}}
- };
- byte wfTick = 0;
- byte wfLvl = 0;
+ byte scaleLock = 0;
+ byte perceptual = 1;
- // Tone and Arpeggiator variables
- uint32_t microSecondsPerCycle = 1000000;
- uint32_t microSecondsPerTick = microSecondsPerCycle / WAVE_RESOLUTION;
- byte currentHexBuzzing = 255; // if this is 255, buzzer set to off (0% duty cycle)
- uint32_t currentBuzzTime = 0; // Used to keep track of when this note started buzzin
- uint32_t arpeggiateLength = 60; //
+ int velWheelSpeed = 8;
+ int modWheelSpeed = 8;
+ int pbWheelSpeed = 1024;
- // Pitch bend and mod wheel variables overhauled to use an internal emulation structure as follows
- const uint16_t ccMsgCoolDown = 32; // milliseconds between steps
- typedef struct {
- byte* topBtn;
- byte* midBtn;
- byte* botBtn;
- int16_t minValue;
- int16_t maxValue;
- uint16_t stepValue;
- int16_t defValue;
- int16_t curValue;
- int16_t targetValue;
- uint32_t timeLastChanged;
- void setTargetValue() {
- if (*midBtn >> 1) { // middle button toggles target (0) vs. step (1) mode
- int16_t temp = curValue;
- if (*topBtn == 1) {temp += stepValue;};
- if (*botBtn == 1) {temp -= stepValue;};
- if (temp > maxValue) {temp = maxValue;}
- else if (temp <= minValue) {temp = minValue;};
- targetValue = temp;
- } else {
- switch (((*topBtn >> 1) << 1) + (*botBtn >> 1)) {
- case 0b10: targetValue = maxValue; break;
- case 0b11: targetValue = defValue; break;
- case 0b01: targetValue = minValue; break;
- default: targetValue = curValue; break;
- };
- };
- };
- bool updateValue() {
- int16_t temp = targetValue - curValue;
- if (temp != 0) {
- if ((runTime - timeLastChanged) >= ccMsgCoolDown) {
- timeLastChanged = runTime;
- if (abs(temp) < stepValue) {
- curValue = targetValue;
- } else {
- curValue = curValue + (stepValue * (temp / abs(temp)));
- };
- return 1;
- } else {
- return 0;
- };
- } else {
- return 0;
- };
- };
- } wheelDef;
- wheelDef modWheel = {
- &h[assignCmd[4]].keyState,
- &h[assignCmd[5]].keyState,
- &h[assignCmd[6]].keyState,
- 0, 127, 8,
- 0, 0, 0
+ wheelDef modWheel = { false, false, // standard mode, not sticky
+ &h[assignCmd[4]].btnState, &h[assignCmd[5]].btnState, &h[assignCmd[6]].btnState,
+ 0, 127, &modWheelSpeed, 0, 0, 0, 0
};
- wheelDef pbWheel = {
- &h[assignCmd[4]].keyState,
- &h[assignCmd[5]].keyState,
- &h[assignCmd[6]].keyState,
- -8192, 8192, 1024,
- 0, 0, 0
+ wheelDef pbWheel = { false, false, // standard mode, not sticky
+ &h[assignCmd[4]].btnState, &h[assignCmd[5]].btnState, &h[assignCmd[6]].btnState,
+ -8192, 8191, &pbWheelSpeed, 0, 0, 0, 0
};
- wheelDef velWheel = {
- &h[assignCmd[0]].keyState,
- &h[assignCmd[1]].keyState,
- &h[assignCmd[2]].keyState,
- 0, 127, 8,
- 96, 96, 96
+ wheelDef velWheel = { false, true, // standard mode, sticky
+ &h[assignCmd[0]].btnState, &h[assignCmd[1]].btnState, &h[assignCmd[2]].btnState,
+ 0, 127, &velWheelSpeed, 96, 96, 96, 0
};
bool toggleWheel = 0; // 0 for mod, 1 for pb
- /* Sequencer mode has not yet been restored
-
- // Variables for sequencer mode
- // Sequencer mode probably needs some love before it will be useful/usable.
- // The device is held vertically, and two rows create a "lane".
- // the first 8 buttons from each row are the steps (giving you 4 measures with quarter-note precision)
- // The extra 3 (4?) buttons are for bank switching, muting, and solo-ing
- typedef struct {
- // The first 16 are for bank 0, and the second 16 are for bank 1.
- bool steps[32] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
- bool bank = 0;
- int state = 0; // TODO: change to enum: normal, mute, solo, mute&solo
- int instrument = 0; // What midi note this lane will send to the computer.
- } Lane;
- #define STATE_MUTE 1
- #define STATE_SOLO 2
-
- #define NLANES 7
- Lane lanes[NLANES];
-
- int sequencerStep = 0; // 0 - 31
-
- // You have to push a button to switch modes
- bool sequencerMode = 0;
-
- // THESE CAN BE USED TO RESET THE SEQUENCE POSITION
- // void handleStart(void);
- // void handleContinue(void);
- // void handleStop(void);
-
- // THIS WILL BE USED FOR THE SEQUENCER CLOCK (24 frames per quarter note)
- // void handleTimeCodeQuarterFrame(byte data);
- // We should be able to adjust the division in the menu to have different sequence speeds.
-
- void handleNoteOn(byte channel, byte pitch, byte velocity) {
- // Rosegarden sends its metronome this way. Using for testing...
- if (1 == sequencerMode && 10 == channel && 100 == pitch) {
- sequencerPlayNextNote();
- }
- }
-
- */
-
- // ====== initialize list of supported scales / modes / raga / maqam
-
- typedef struct {
- std::string name;
- byte tuning;
- byte step[16]; // 16 bytes = 128 bits, 1 = in scale; 0 = not
- } scaleDef;
- scaleDef scaleOptions[] = {
- { "None", 255, { 255, 255, 255,255,255,255,255,255,255,255,255,255,255,255,255,255} },
- { "Major", Twelve, { 0b10101101, 0b0101'0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
- { "Minor, natural", Twelve, { 0b10110101, 0b1010'0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
- { "Minor, melodic", Twelve, { 0b10110101, 0b0101'0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
- { "Minor, harmonic", Twelve, { 0b10110101, 0b1001'0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
- { "Pentatonic, major", Twelve, { 0b10101001, 0b0100'0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
- { "Pentatonic, minor", Twelve, { 0b10010101, 0b0010'0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
- { "Blues", Twelve, { 0b10010111, 0b0010'0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
- { "Double Harmonic", Twelve, { 0b11001101, 0b1001'0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
- { "Phrygian", Twelve, { 0b11010101, 0b1010'0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
- { "Phrygian Dominant", Twelve, { 0b11001101, 0b1010'0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
- { "Dorian", Twelve, { 0b10110101, 0b0110'0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
- { "Lydian", Twelve, { 0b10101011, 0b0101'0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
- { "Lydian Dominant", Twelve, { 0b10101011, 0b0110'0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
- { "Mixolydian", Twelve, { 0b10101101, 0b0110'0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
- { "Locrian", Twelve, { 0b11010110, 0b1010'0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
- { "Whole tone", Twelve, { 0b10101010, 0b1010'0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
- { "Octatonic", Twelve, { 0b10110110, 0b1101'0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
- { "Rast maqam", TwentyFour, { 0b10001001, 0b00100010, 0b00101100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
- { "Rast makam", FiftyThree, { 0b10000000, 0b01000000, 0b01000010, 0b00000001,
- 0b00000000, 0b10001000, 0b10000'000, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
- };
- const byte scaleCount = sizeof(scaleOptions) / sizeof(scaleDef);
-
- // ====== initialize key notation and coloring routines
-
- enum { DARK = 0, VeryDIM = 1, DIM = 32, BRIGHT = 127, VeryBRIGHT = 255 };
- enum { GRAY = 0, DULL = 127, VIVID = 255 };
- enum colors { W, R, O, Y, L, G, C, B, I, P, M,
- r, o, y, l, g, c, b, i, p, m };
- float hueCode[] = { 0.0, 0.0, 36.0, 72.0, 108.0, 144.0, 180.0, 216.0, 252.0, 288.0, 324.0,
- 0.0, 36.0, 72.0, 108.0, 144.0, 180.0, 216.0, 252.0, 288.0, 324.0 };
- byte satCode[] = { GRAY, VIVID,VIVID,VIVID,VIVID, VIVID, VIVID, VIVID, VIVID, VIVID, VIVID,
- DULL, DULL, DULL, DULL, DULL, DULL, DULL, DULL, DULL, DULL };
-
- typedef struct {
- std::string name;
- byte tuning;
- int8_t offset; // steps from constant A4 to that key class
- colors tierColor;
- } keyDef;
- keyDef keyOptions[] = {
- // 12 EDO, whole tone = 2, #/b = 1
- { " C (B#)", Twelve, -9, W },
- { " C# / Db", Twelve, -8, i },
- { " D", Twelve, -7, W },
- { " D# / Eb", Twelve, -6, i },
- { " (Fb) E", Twelve, -5, W },
- { " F (E#)", Twelve, -4, c },
- { " Gb / F#", Twelve, -3, I },
- { " G", Twelve, -2, c },
- { " G# / Ab", Twelve, -1, I },
- { " A", Twelve, 0, c },
- { " A# / Bb", Twelve, 1, I },
- { "(Cb) B", Twelve, 2, c },
- // 17 EDO, whole tone = 3, #/b = 2, +/d = 1
- { " C (B+)", Seventeen, -13, W },
- { " C+ / Db / B#", Seventeen, -12, R },
- { " C# / Dd", Seventeen, -11, I },
- { " D", Seventeen, -10, W },
- { " D+ / Eb", Seventeen, -9, R },
- { " Fb / D# / Ed", Seventeen, -8, I },
- { "(Fd) E", Seventeen, -7, W },
- { " F (E+)", Seventeen, -6, W },
- { " F+ / Gb / E#", Seventeen, -5, R },
- { " F# / Gd", Seventeen, -4, I },
- { " G", Seventeen, -3, W },
- { " G+ / Ab", Seventeen, -2, R },
- { " G# / Ad", Seventeen, -1, I },
- { " A", Seventeen, 0, W },
- { " Bb / A+", Seventeen, 1, R },
- { " Cb / Bd / A#", Seventeen, 2, I },
- { "(Cd) B" , Seventeen, 3, W },
- // 19 EDO, whole tone = 3, #/b = 1
- { " C", Nineteen, -14, W },
- { " C#", Nineteen, -13, R },
- { " Db", Nineteen, -12, I },
- { " D", Nineteen, -11, W },
- { " D#", Nineteen, -10, R },
- { " Eb", Nineteen, -9, I },
- { " E", Nineteen, -8, W },
- { " E# / Fb", Nineteen, -7, m },
- { " F", Nineteen, -6, W },
- { " F#", Nineteen, -5, R },
- { " Gb", Nineteen, -4, I },
- { " G", Nineteen, -3, W },
- { " G#", Nineteen, -2, R },
- { " Ab", Nineteen, -1, I },
- { " A", Nineteen, 0, W },
- { " A#", Nineteen, 1, R },
- { " Bb", Nineteen, 2, I },
- { " B", Nineteen, 3, W },
- { " Cb / B#", Nineteen, 4, m },
- // 22 EDO, whole tone = 4, #/b = 3, ^/v = 1
- { " C (^B)", TwentyTwo, -17, W },
- { " ^C / Db / vB#", TwentyTwo, -16, l },
- { " vC# / ^Db / B#", TwentyTwo, -15, C },
- { " C# / vD", TwentyTwo, -14, i },
- { " D", TwentyTwo, -13, W },
- { " ^D / Eb", TwentyTwo, -12, l },
- { " Fb / vD# / ^Eb", TwentyTwo, -11, C },
- { " ^Fb / D# / vE", TwentyTwo, -10, i },
- { "(vF) E", TwentyTwo, -9, W },
- { " F (^E)", TwentyTwo, -8, W },
- { " ^F / Gb / vE#", TwentyTwo, -7, l },
- { " vF# / ^Gb / E#", TwentyTwo, -6, C },
- { " F# / vG", TwentyTwo, -5, i },
- { " G", TwentyTwo, -4, W },
- { " ^G / Ab", TwentyTwo, -3, l },
- { " vG# / ^Ab", TwentyTwo, -2, C },
- { " G# / vA", TwentyTwo, -1, i },
- { " A", TwentyTwo, 0, W },
- { " Bb / ^A", TwentyTwo, 1, l },
- { " Cb / ^Bb / vA#", TwentyTwo, 2, C },
- { " ^Cb / vB / A#", TwentyTwo, 3, i },
- { "(vC) B", TwentyTwo, 4, W },
- // 24 EDO, whole tone = 4, #/b = 2, +/d = 1
- { " C / B#", TwentyFour, -18, W },
- { " C+", TwentyFour, -17, r },
- { " C# / Db", TwentyFour, -16, I },
- { " Dd", TwentyFour, -15, g },
- { " D", TwentyFour, -14, W },
- { " D+", TwentyFour, -13, r },
- { " Eb / D#", TwentyFour, -12, I },
- { " Ed", TwentyFour, -11, g },
- { " E / Fb", TwentyFour, -10, W },
- { " E+ / Fd", TwentyFour, -9, y },
- { " E# / F", TwentyFour, -8, W },
- { " F+", TwentyFour, -7, r },
- { " Gb / F#", TwentyFour, -6, I },
- { " Gd", TwentyFour, -5, g },
- { " G", TwentyFour, -4, W },
- { " G+", TwentyFour, -3, r },
- { " G# / Ab", TwentyFour, -2, I },
- { " Ad", TwentyFour, -1, g },
- { " A", TwentyFour, 0, W },
- { " A+", TwentyFour, 1, r },
- { " Bb / A#", TwentyFour, 2, I },
- { " Bd", TwentyFour, 3, g },
- { " B / Cb", TwentyFour, 4, W },
- { " B+ / Cd", TwentyFour, 5, y },
- // 31 EDO, whole tone = 5, #/b = 2, +/d = 1
- { " C", ThirtyOne, -23, W },
- { " C+", ThirtyOne, -22, R },
- { " C#", ThirtyOne, -21, Y },
- { " Db", ThirtyOne, -20, C },
- { " Dd", ThirtyOne, -19, I },
- { " D", ThirtyOne, -18, W },
- { " D+", ThirtyOne, -17, R },
- { " D#", ThirtyOne, -16, Y },
- { " Eb", ThirtyOne, -15, C },
- { " Ed", ThirtyOne, -14, I },
- { " E", ThirtyOne, -13, W },
- { " E+ / Fb", ThirtyOne, -12, L },
- { " E# / Fd", ThirtyOne, -11, M },
- { " F", ThirtyOne, -10, W },
- { " F+", ThirtyOne, -9, R },
- { " F#", ThirtyOne, -8, Y },
- { " Gb", ThirtyOne, -7, C },
- { " Gd", ThirtyOne, -6, I },
- { " G", ThirtyOne, -5, W },
- { " G+", ThirtyOne, -4, R },
- { " G#", ThirtyOne, -3, Y },
- { " Ab", ThirtyOne, -2, C },
- { " Ad", ThirtyOne, -1, I },
- { " A", ThirtyOne, 0, W },
- { " A+", ThirtyOne, 1, R },
- { " A#", ThirtyOne, 2, Y },
- { " Bb", ThirtyOne, 3, C },
- { " Bd", ThirtyOne, 4, I },
- { " B", ThirtyOne, 5, W },
- { " Cb / B+", ThirtyOne, 6, L },
- { " Cd / B#", ThirtyOne, 7, M },
- // 41 EDO, whole tone = 7, #/b = 4, +/d = 2, ^/v = 1
- { " C (vB#)", FortyOne, -31, W },
- { " ^C / B#", FortyOne, -30, c },
- { " C+ ", FortyOne, -29, O },
- { " vC# / Db", FortyOne, -28, I },
- { " C# / ^Db", FortyOne, -27, R },
- { " Dd", FortyOne, -26, B },
- { " vD", FortyOne, -25, y },
- { " D", FortyOne, -24, W },
- { " ^D", FortyOne, -23, c },
- { " D+", FortyOne, -22, O },
- { " vD# / Eb", FortyOne, -21, I },
- { " D# / ^Eb", FortyOne, -20, R },
- { " Ed", FortyOne, -19, B },
- { " vE", FortyOne, -18, y },
- { " (^Fb) E", FortyOne, -17, W },
- { " Fd / ^E", FortyOne, -16, c },
- { " vF / E+", FortyOne, -15, y },
- { " F (vE#)", FortyOne, -14, W },
- { " ^F / E#", FortyOne, -13, c },
- { " F+", FortyOne, -12, O },
- { " Gb / vF#", FortyOne, -11, I },
- { " ^Gb / F#", FortyOne, -10, R },
- { " Gd", FortyOne, -9, B },
- { " vG", FortyOne, -8, y },
- { " G", FortyOne, -7, W },
- { " ^G", FortyOne, -6, c },
- { " G+", FortyOne, -5, O },
- { " vG# / Ab", FortyOne, -4, I },
- { " G# / ^Ab", FortyOne, -3, R },
- { " Ad", FortyOne, -2, B },
- { " vA", FortyOne, -1, y },
- { " A", FortyOne, 0, W },
- { " ^A", FortyOne, 1, c },
- { " A+", FortyOne, 2, O },
- { " vA# / Bb", FortyOne, 3, I },
- { " A# / ^Bb", FortyOne, 4, R },
- { " Bd", FortyOne, 5, B },
- { " vB", FortyOne, 6, y },
- { " (^Cb) B", FortyOne, 7, W },
- { " Cd / ^B", FortyOne, 8, c },
- { " vC / B+", FortyOne, 9, y },
- // 53 EDO, whole tone = 9, #/b = 5, >/< = 2, ^/v = 1
- { " C (vB#)", FiftyThree, -40, W },
- { " ^C / B#", FiftyThree, -39, c },
- { " >C / <Db", FiftyThree, -38, l },
- { " <C# / vDb", FiftyThree, -37, O },
- { " vC# / Db", FiftyThree, -36, I },
- { " C# / ^Db", FiftyThree, -35, R },
- { " ^C# / >Db", FiftyThree, -34, B },
- { " >C# / <D", FiftyThree, -33, g },
- { " vD", FiftyThree, -32, y },
- { " D", FiftyThree, -31, W },
- { " ^D", FiftyThree, -30, c },
- { " >D / <Eb", FiftyThree, -29, l },
- { " <D# / vEb", FiftyThree, -28, O },
- { " vD# / Eb", FiftyThree, -27, I },
- { " D# / ^Eb", FiftyThree, -26, R },
- { " ^D# / >Eb", FiftyThree, -25, B },
- { " >D# / <E", FiftyThree, -24, g },
- { " Fb / vE", FiftyThree, -23, y },
- { "(^Fb) E", FiftyThree, -22, W },
- { "(>Fb) ^E", FiftyThree, -21, c },
- { " <F / >E", FiftyThree, -20, G },
- { " vF (<E#)", FiftyThree, -19, y },
- { " F (vE#)", FiftyThree, -18, W },
- { " ^F / E#", FiftyThree, -17, c },
- { " >F / <Gb", FiftyThree, -16, l },
- { " <F# / vGb", FiftyThree, -15, O },
- { " vF# / Gb", FiftyThree, -14, I },
- { " F# / ^Gb", FiftyThree, -13, R },
- { " ^F# / >Gb", FiftyThree, -12, B },
- { " >F# / <G", FiftyThree, -11, g },
- { " vG", FiftyThree, -10, y },
- { " G", FiftyThree, -9, W },
- { " ^G", FiftyThree, -8, c },
- { " >G / <Ab", FiftyThree, -7, l },
- { " <G# / vAb", FiftyThree, -6, O },
- { " vG# / Ab", FiftyThree, -5, I },
- { " G# / ^Ab", FiftyThree, -4, R },
- { " ^G# / >Ab", FiftyThree, -3, B },
- { " >G# / <A", FiftyThree, -2, g },
- { " vA", FiftyThree, -1, y },
- { " A", FiftyThree, 0, W },
- { " ^A", FiftyThree, 1, c },
- { " <Bb / >A", FiftyThree, 2, l },
- { " vBb / <A#", FiftyThree, 3, O },
- { " Bb / vA#", FiftyThree, 4, I },
- { " ^Bb / A#", FiftyThree, 5, R },
- { " >Bb / ^A#", FiftyThree, 6, B },
- { " <B / >A#", FiftyThree, 7, g },
- { " Cb / vB", FiftyThree, 8, y },
- { "(^Cb) B", FiftyThree, 9, W },
- { "(>Cb) ^B", FiftyThree, 10, c },
- { " <C / >B", FiftyThree, 11, G },
- { " vC (<B#)", FiftyThree, 12, y },
- // 72 EDO, whole tone = 12, #/b = 6, +/d = 3, ^/v = 1
- { " C (B#)", SeventyTwo, -54, W },
- { " ^C", SeventyTwo, -53, g },
- { " vC+", SeventyTwo, -52, r },
- { " C+", SeventyTwo, -51, p },
- { " ^C+", SeventyTwo, -50, b },
- { " vC#", SeventyTwo, -49, y },
- { " C# / Db", SeventyTwo, -48, I },
- { " ^C# / ^Db", SeventyTwo, -47, g },
- { " vDd", SeventyTwo, -46, r },
- { " Dd", SeventyTwo, -45, p },
- { " ^Dd", SeventyTwo, -44, b },
- { " vD", SeventyTwo, -43, y },
- { " D", SeventyTwo, -42, W },
- { " ^D", SeventyTwo, -41, g },
- { " vD+", SeventyTwo, -40, r },
- { " D+", SeventyTwo, -39, p },
- { " ^D+", SeventyTwo, -38, b },
- { " vEb / vD#", SeventyTwo, -37, y },
- { " Eb / D#", SeventyTwo, -36, I },
- { " ^Eb / ^D#", SeventyTwo, -35, g },
- { " vEd", SeventyTwo, -34, r },
- { " Ed", SeventyTwo, -33, p },
- { " ^Ed", SeventyTwo, -32, b },
- { " vE (vFb)", SeventyTwo, -31, y },
- { " E (Fb)", SeventyTwo, -30, W },
- { " ^E (^Fb)", SeventyTwo, -29, g },
- { " vE+ / vFd", SeventyTwo, -28, r },
- { " E+ / Fd", SeventyTwo, -27, p },
- { " ^E+ / ^Fd", SeventyTwo, -26, b },
- { "(vE#) vF", SeventyTwo, -25, y },
- { " (E#) F", SeventyTwo, -24, W },
- { "(^E#) ^F", SeventyTwo, -23, g },
- { " vF+", SeventyTwo, -22, r },
- { " F+", SeventyTwo, -21, p },
- { " ^F+", SeventyTwo, -20, b },
- { " vGb / vF#", SeventyTwo, -19, y },
- { " Gb / F#", SeventyTwo, -18, I },
- { " ^Gb / ^F#", SeventyTwo, -17, g },
- { " vGd", SeventyTwo, -16, r },
- { " Gd", SeventyTwo, -15, p },
- { " ^Gd", SeventyTwo, -14, b },
- { " vG", SeventyTwo, -13, y },
- { " G", SeventyTwo, -12, W },
- { " ^G", SeventyTwo, -11, g },
- { " vG+", SeventyTwo, -10, r },
- { " G+", SeventyTwo, -9, p },
- { " ^G+", SeventyTwo, -8, b },
- { " vG# / vAb", SeventyTwo, -7, y },
- { " G# / Ab", SeventyTwo, -6, I },
- { " ^G# / ^Ab", SeventyTwo, -5, g },
- { " vAd", SeventyTwo, -4, r },
- { " Ad", SeventyTwo, -3, p },
- { " ^Ad", SeventyTwo, -2, b },
- { " vA", SeventyTwo, -1, y },
- { " A", SeventyTwo, 0, W },
- { " ^A", SeventyTwo, 1, g },
- { " vA+", SeventyTwo, 2, r },
- { " A+", SeventyTwo, 3, p },
- { " ^A+", SeventyTwo, 4, b },
- { " vBb / vA#", SeventyTwo, 5, y },
- { " Bb / A#", SeventyTwo, 6, I },
- { " ^Bb / ^A#", SeventyTwo, 7, g },
- { " vBd", SeventyTwo, 8, r },
- { " Bd", SeventyTwo, 9, p },
- { " ^Bd", SeventyTwo, 10, b },
- { " vB (vCb)", SeventyTwo, 11, y },
- { " B (Cb)", SeventyTwo, 12, W },
- { " ^B (^Cb)", SeventyTwo, 13, g },
- { " vB+ / vCd", SeventyTwo, 14, r },
- { " B+ / Cd", SeventyTwo, 15, p },
- { " ^B+ / ^Cd", SeventyTwo, 16, b },
- { "(vB#) vC", SeventyTwo, 17, y },
- //
- { "Note 0",BohlenPierce,0,W},
- { "Note 1",BohlenPierce,1,Y},
- { "Note 2",BohlenPierce,2,L},
- { "Note 3",BohlenPierce,3,G},
- { "Note 4",BohlenPierce,4,C},
- { "Note 5",BohlenPierce,5,B},
- { "Note 6",BohlenPierce,6,I},
- { "Note 7",BohlenPierce,7,P},
- { "Note 8",BohlenPierce,8,M},
- { "Note 9",BohlenPierce,9,R},
- { "Note 10",BohlenPierce,10,O},
- { "Note 11",BohlenPierce,11,g},
- { "Note 12",BohlenPierce,12,b},
- //
- { "Note 0",CarlosA,0,W},
- { "Note 1",CarlosA,1,Y},
- { "Note 2",CarlosA,2,G},
- { "Note 3",CarlosA,3,B},
- { "Note 4",CarlosA,4,P},
- { "Note 5",CarlosA,5,R},
- { "Note 6",CarlosA,6,c},
- { "Note 7",CarlosA,7,l},
- { "Note 8",CarlosA,8,m},
- //
- { "Note 0",CarlosB,0,W},
- { "Note 1",CarlosB,1,Y},
- { "Note 2",CarlosB,2,L},
- { "Note 3",CarlosB,3,G},
- { "Note 4",CarlosB,4,C},
- { "Note 5",CarlosB,5,B},
- { "Note 6",CarlosB,6,I},
- { "Note 7",CarlosB,7,P},
- { "Note 8",CarlosB,8,M},
- { "Note 9",CarlosB,9,R},
- { "Note 10",CarlosB,10,O},
- //
- { "Note 0",CarlosG,0,Y},
- { "Note 1",CarlosG,1,y},
- { "Note 2",CarlosG,2,L},
- { "Note 3",CarlosG,3,l},
- { "Note 4",CarlosG,4,G},
- { "Note 5",CarlosG,5,g},
- { "Note 6",CarlosG,6,C},
- { "Note 7",CarlosG,7,c},
- { "Note 8",CarlosG,8,B},
- { "Note 9",CarlosG,9,b},
- { "Note 10",CarlosG,10,I},
- { "Note 11",CarlosG,11,i},
- { "Note 12",CarlosG,12,P},
- { "Note 13",CarlosG,13,p},
- { "Note 14",CarlosG,14,M},
- { "Note 15",CarlosG,15,m},
- { "Note 16",CarlosG,16,R},
- { "Note 17",CarlosG,17,r},
- { "Note 18",CarlosG,18,O},
- { "Note 19",CarlosG,19,o},
-
- };
- const int keyCount = sizeof(keyOptions) / sizeof(keyDef);
-
// MENU SYSTEM SETUP //
// Create menu page object of class GEMPage. Menu page holds menu items (GEMItem) and represents menu level.
// Menu can have multiple menu pages (linked to each other) with multiple menu items each
GEMPage menuPageMain("HexBoard MIDI Controller");
GEMPage menuPageTuning("Tuning");
- GEMPage menuPageLayout("Layout");
- GEMPage menuPageScales("Scales");
- GEMPage menuPageKeys("Keys");
-
+ GEMItem menuTuningBack("<< Back", menuPageMain);
GEMItem menuGotoTuning("Tuning", menuPageTuning);
- GEMItem* menuItemTuning[tuningCount]; // dynamically generate item based on tunings
-
+ GEMPage menuPageLayout("Layout");
GEMItem menuGotoLayout("Layout", menuPageLayout);
- GEMItem* menuItemLayout[layoutCount]; // dynamically generate item based on presets
-
+ GEMItem menuLayoutBack("<< Back", menuPageMain);
+ GEMPage menuPageScales("Scales");
GEMItem menuGotoScales("Scales", menuPageScales);
- GEMItem* menuItemScales[scaleCount]; // dynamically generate item based on presets and if allowed in given EDO tuning
-
- GEMItem menuGotoKeys("Keys", menuPageKeys);
- GEMItem* menuItemKeys[keyCount]; // dynamically generate item based on presets
-
- byte scaleLock = 0;
- byte perceptual = 1;
- void resetHexLEDs();
- byte enableMIDI = 1;
- byte MPE = 0; // microtonal mode. if zero then attempt to self-manage multiple channels.
- // if one then on certain synths that are MPE compatible will send in that mode.
- void prepMIDIforMicrotones();
- SelectOptionByte optionByteYesOrNo[] = { { "No" , 0 },
- { "Yes" , 1 } };
+ GEMItem menuScalesBack("<< Back", menuPageMain);
+ GEMPage menuPageControl("Control wheel");
+ GEMItem menuGotoControl("Control wheel", menuPageControl);
+ GEMItem menuControlBack("<< Back", menuPageMain);
+
+ // the following get initialized in the setup() routine.
+ GEMItem* menuItemTuning[TUNINGCOUNT];
+ GEMItem* menuItemLayout[layoutCount];
+ GEMItem* menuItemScales[scaleCount];
+ GEMSelect* selectKey[TUNINGCOUNT];
+ GEMItem* menuItemKeys[TUNINGCOUNT];
+
+ void resetHexLEDs(); // forward-declaration
+ SelectOptionByte optionByteYesOrNo[] = { { "No", 0 }, { "Yes" , 1 } };
GEMSelect selectYesOrNo( sizeof(optionByteYesOrNo) / sizeof(SelectOptionByte), optionByteYesOrNo);
- GEMItem menuItemScaleLock( "Scale lock?", scaleLock, selectYesOrNo);
- GEMItem menuItemPercep( "Fix color:", perceptual, selectYesOrNo, resetHexLEDs);
- GEMItem menuItemMIDI( "Enable MIDI:", enableMIDI, selectYesOrNo);
- GEMItem menuItemMPE( "MPE Mode:", MPE, selectYesOrNo, prepMIDIforMicrotones);
-
- byte playbackMode = 2;
- SelectOptionByte optionBytePlayback[] = { { "Off" , 0 },
- { "Mono" , 1 },
- { "Arp'gio", 2 } };
+ GEMItem menuItemScaleLock( "Scale lock?", scaleLock, selectYesOrNo);
+ GEMItem menuItemPercep( "Fix color:", perceptual, selectYesOrNo, resetHexLEDs);
+
+ byte playbackMode = BUZZ_POLY;
+ SelectOptionByte optionBytePlayback[] = { { "Off", BUZZ_OFF }, { "Mono", BUZZ_MONO }, { "Arp'gio", BUZZ_ARPEGGIO }, { "Poly", BUZZ_POLY } };
GEMSelect selectPlayback(sizeof(optionBytePlayback) / sizeof(SelectOptionByte), optionBytePlayback);
GEMItem menuItemPlayback( "Buzzer:", playbackMode, selectPlayback);
- byte colorMode = 1;
- SelectOptionByte optionByteColor[] = { { "Rainbow", 0 },
- { "Tiered" , 1 } };
- GEMSelect selectColor( sizeof(optionByteColor) / sizeof(SelectOptionByte), optionByteColor);
- GEMItem menuItemColor( "Color mode:", colorMode, selectColor, resetHexLEDs);
-
- enum { NoAnim, StarAnim, SplashAnim, OrbitAnim, OctaveAnim, NoteAnim };
- byte animationType = NoAnim;
- SelectOptionByte optionByteAnimate[] = { { "None" , NoAnim },
- { "Octave" , OctaveAnim},
- { "By Note", NoteAnim},
- { "Star" , StarAnim},
- { "Splash" , SplashAnim},
- { "Orbit" , OrbitAnim} };
+ void changeTranspose(); // forward-declaration
+ int transposeSteps = 0;
+ // doing this long-hand because the STRUCT has problems accepting string conversions of numbers for some reason
+ SelectOptionInt optionIntTransposeSteps[] = {
+ {"-127",-127},{"-126",-126},{"-125",-125},{"-124",-124},{"-123",-123},{"-122",-122},{"-121",-121},{"-120",-120},{"-119",-119},{"-118",-118},{"-117",-117},{"-116",-116},{"-115",-115},{"-114",-114},{"-113",-113},
+ {"-112",-112},{"-111",-111},{"-110",-110},{"-109",-109},{"-108",-108},{"-107",-107},{"-106",-106},{"-105",-105},{"-104",-104},{"-103",-103},{"-102",-102},{"-101",-101},{"-100",-100},{"- 99",- 99},{"- 98",- 98},
+ {"- 97",- 97},{"- 96",- 96},{"- 95",- 95},{"- 94",- 94},{"- 93",- 93},{"- 92",- 92},{"- 91",- 91},{"- 90",- 90},{"- 89",- 89},{"- 88",- 88},{"- 87",- 87},{"- 86",- 86},{"- 85",- 85},{"- 84",- 84},{"- 83",- 83},
+ {"- 82",- 82},{"- 81",- 81},{"- 80",- 80},{"- 79",- 79},{"- 78",- 78},{"- 77",- 77},{"- 76",- 76},{"- 75",- 75},{"- 74",- 74},{"- 73",- 73},{"- 72",- 72},{"- 71",- 71},{"- 70",- 70},{"- 69",- 69},{"- 68",- 68},
+ {"- 67",- 67},{"- 66",- 66},{"- 65",- 65},{"- 64",- 64},{"- 63",- 63},{"- 62",- 62},{"- 61",- 61},{"- 60",- 60},{"- 59",- 59},{"- 58",- 58},{"- 57",- 57},{"- 56",- 56},{"- 55",- 55},{"- 54",- 54},{"- 53",- 53},
+ {"- 52",- 52},{"- 51",- 51},{"- 50",- 50},{"- 49",- 49},{"- 48",- 48},{"- 47",- 47},{"- 46",- 46},{"- 45",- 45},{"- 44",- 44},{"- 43",- 43},{"- 42",- 42},{"- 41",- 41},{"- 40",- 40},{"- 39",- 39},{"- 38",- 38},
+ {"- 37",- 37},{"- 36",- 36},{"- 35",- 35},{"- 34",- 34},{"- 33",- 33},{"- 32",- 32},{"- 31",- 31},{"- 30",- 30},{"- 29",- 29},{"- 28",- 28},{"- 27",- 27},{"- 26",- 26},{"- 25",- 25},{"- 24",- 24},{"- 23",- 23},
+ {"- 22",- 22},{"- 21",- 21},{"- 20",- 20},{"- 19",- 19},{"- 18",- 18},{"- 17",- 17},{"- 16",- 16},{"- 15",- 15},{"- 14",- 14},{"- 13",- 13},{"- 12",- 12},{"- 11",- 11},{"- 10",- 10},{"- 9",- 9},{"- 8",- 8},
+ {"- 7",- 7},{"- 6",- 6},{"- 5",- 5},{"- 4",- 4},{"- 3",- 3},{"- 2",- 2},{"- 1",- 1},{"+/-0", 0},{"+ 1", 1},{"+ 2", 2},{"+ 3", 3},{"+ 4", 4},{"+ 5", 5},{"+ 6", 6},{"+ 7", 7},
+ {"+ 8", 8},{"+ 9", 9},{"+ 10", 10},{"+ 11", 11},{"+ 12", 12},{"+ 13", 13},{"+ 14", 14},{"+ 15", 15},{"+ 16", 16},{"+ 17", 17},{"+ 18", 18},{"+ 19", 19},{"+ 20", 20},{"+ 21", 21},{"+ 22", 22},
+ {"+ 23", 23},{"+ 24", 24},{"+ 25", 25},{"+ 26", 26},{"+ 27", 27},{"+ 28", 28},{"+ 29", 29},{"+ 30", 30},{"+ 31", 31},{"+ 32", 32},{"+ 33", 33},{"+ 34", 34},{"+ 35", 35},{"+ 36", 36},{"+ 37", 37},
+ {"+ 38", 38},{"+ 39", 39},{"+ 40", 40},{"+ 41", 41},{"+ 42", 42},{"+ 43", 43},{"+ 44", 44},{"+ 45", 45},{"+ 46", 46},{"+ 47", 47},{"+ 48", 48},{"+ 49", 49},{"+ 50", 50},{"+ 51", 51},{"+ 52", 52},
+ {"+ 53", 53},{"+ 54", 54},{"+ 55", 55},{"+ 56", 56},{"+ 57", 57},{"+ 58", 58},{"+ 59", 59},{"+ 60", 60},{"+ 61", 61},{"+ 62", 62},{"+ 63", 63},{"+ 64", 64},{"+ 65", 65},{"+ 66", 66},{"+ 67", 67},
+ {"+ 68", 68},{"+ 69", 69},{"+ 70", 70},{"+ 71", 71},{"+ 72", 72},{"+ 73", 73},{"+ 74", 74},{"+ 75", 75},{"+ 76", 76},{"+ 77", 77},{"+ 78", 78},{"+ 79", 79},{"+ 80", 80},{"+ 81", 81},{"+ 82", 82},
+ {"+ 83", 83},{"+ 84", 84},{"+ 85", 85},{"+ 86", 86},{"+ 87", 87},{"+ 88", 88},{"+ 89", 89},{"+ 90", 90},{"+ 91", 91},{"+ 92", 92},{"+ 93", 93},{"+ 94", 94},{"+ 95", 95},{"+ 96", 96},{"+ 97", 97},
+ {"+ 98", 98},{"+ 99", 99},{"+100", 100},{"+101", 101},{"+102", 102},{"+103", 103},{"+104", 104},{"+105", 105},{"+106", 106},{"+107", 107},{"+108", 108},{"+109", 109},{"+110", 110},{"+111", 111},{"+112", 112},
+ {"+113", 113},{"+114", 114},{"+115", 115},{"+116", 116},{"+117", 117},{"+118", 118},{"+119", 119},{"+120", 120},{"+121", 121},{"+122", 122},{"+123", 123},{"+124", 124},{"+125", 125},{"+126", 126},{"+127", 127}
+ };
+ GEMSelect selectTransposeSteps( 255, optionIntTransposeSteps);
+ GEMItem menuItemTransposeSteps( "Transpose:", transposeSteps, selectTransposeSteps, changeTranspose);
+
+ byte colorMode = TIERED_COLOR_MODE;
+ SelectOptionByte optionByteColor[] = { { "Rainbow", RAINBOW_MODE }, { "Tiered" , TIERED_COLOR_MODE } };
+ GEMSelect selectColor( sizeof(optionByteColor) / sizeof(SelectOptionByte), optionByteColor);
+ GEMItem menuItemColor( "Color mode:", colorMode, selectColor, resetHexLEDs);
+
+ byte animationType = ANIMATE_NONE;
+ SelectOptionByte optionByteAnimate[] = { { "None" , ANIMATE_NONE }, { "Octave", ANIMATE_OCTAVE },
+ { "By Note", ANIMATE_BY_NOTE }, { "Star", ANIMATE_STAR }, { "Splash" , ANIMATE_SPLASH }, { "Orbit", ANIMATE_ORBIT } };
GEMSelect selectAnimate( sizeof(optionByteAnimate) / sizeof(SelectOptionByte), optionByteAnimate);
- GEMItem menuItemAnimate( "Animation:", animationType, selectAnimate);
+ GEMItem menuItemAnimate( "Animation:", animationType, selectAnimate);
- byte currWave = 0;
- SelectOptionByte optionByteWaveform[] = { { wf[0].name.c_str(), 0 },
- { wf[1].name.c_str(), 1 },
- { wf[2].name.c_str(), 2 },
- { wf[3].name.c_str(), 3 } };
+ byte currWave = WAVEFORM_SAW;
+ SelectOptionByte optionByteWaveform[] = { { "Square", WAVEFORM_SQUARE }, { "Saw", WAVEFORM_SAW } };
GEMSelect selectWaveform(sizeof(optionByteWaveform) / sizeof(SelectOptionByte), optionByteWaveform);
- GEMItem menuItemWaveform( "Waveform:", currWave, selectWaveform);
+ GEMItem menuItemWaveform( "Waveform:", currWave, selectWaveform);
+
+ SelectOptionInt optionIntModWheel[] = { { "too slo", 1 }, { "Turtle", 2 }, { "Slow", 4 },
+ { "Medium", 8 }, { "Fast", 16 }, { "Cheetah", 32 }, { "Instant", 127 } };
+ GEMSelect selectModSpeed(sizeof(optionIntModWheel) / sizeof(SelectOptionInt), optionIntModWheel);
+ GEMItem menuItemModSpeed( "Mod wheel:", modWheelSpeed, selectModSpeed);
+ GEMItem menuItemVelSpeed( "Vel wheel:", velWheelSpeed, selectModSpeed);
+
+ SelectOptionInt optionIntPBWheel[] = { { "too slo", 128 }, { "Turtle", 256 }, { "Slow", 512 },
+ { "Medium", 1024 }, { "Fast", 2048 }, { "Cheetah", 4096 }, { "Instant", 16384 } };
+ GEMSelect selectPBSpeed(sizeof(optionIntPBWheel) / sizeof(SelectOptionInt), optionIntPBWheel);
+ GEMItem menuItemPBSpeed( "PB wheel:", pbWheelSpeed, selectPBSpeed);
// put all user-selectable options into a class so that down the line these can be saved and loaded.
- typedef struct {
+ class presetDef {
+ public:
std::string presetName;
int tuningIndex; // instead of using pointers, i chose to store index value of each option, to be saved to a .pref or .ini or something
int layoutIndex;
int scaleIndex;
- int keyIndex;
+ int keyStepsFromA; // what key the scale is in, where zero equals A.
int transpose;
// define simple recall functions
tuningDef tuning() {
@@ -915,11 +252,8 @@
scaleDef scale() {
return scaleOptions[scaleIndex];
};
- keyDef key() {
- return keyOptions[keyIndex];
- };
int layoutsBegin() {
- if (tuningIndex == Twelve) {
+ if (tuningIndex == TUNING_12EDO) {
return 0;
} else {
int temp = 0;
@@ -929,90 +263,25 @@
return temp;
};
};
- int keysBegin() {
- if (tuningIndex == Twelve) {
- return 0;
- } else {
- int temp = 0;
- while (keyOptions[temp].tuning < tuningIndex) {
- temp++;
- };
- return temp;
- };
+ int keyStepsFromC() {
+ return -(tuning().spanCtoA() + keyStepsFromA);
};
- int findC() {
- return keyOptions[keysBegin()].offset;
+ int pitchRelToA4(int givenStepsFromC) {
+ return givenStepsFromC - tuning().spanCtoA() + transpose;
+ };
+ int keyDegree(int givenStepsFromC) {
+ return positiveMod(givenStepsFromC + keyStepsFromC(), tuning().cycleLength);
};
- } presetDef;
- presetDef current = {
- "Default",
- Twelve, // see the relevant enum{} statement
- 0, // default to the first layout, wicki hayden
- 0, // default to using no scale (chromatic)
- 0, // default to the key of C
- 0 // default to no transposition
};
-// ====== functions
- byte byteLerp(byte xOne, byte xTwo, float yOne, float yTwo, float y) {
- float weight = (y - yOne) / (yTwo - yOne);
- int temp = xOne + ((xTwo - xOne) * weight);
- if (temp < xOne) {temp = xOne;};
- if (temp > xTwo) {temp = xTwo;};
- return temp;
- }
- int positiveMod(int n, int d) {
- return (((n % d) + d) % d);
- }
- coordinates indexToCoord(byte x) {
- coordinates temp;
- temp.row = (x / 10);
- temp.col = (2 * (x % 10)) + (temp.row & 1);
- return temp;
- }
- bool hexOOB(coordinates c) {
- return (c.row < 0)
- || (c.row >= ROWCOUNT)
- || (c.col < 0)
- || (c.col >= (2 * COLCOUNT))
- || ((c.col + c.row) & 1);
- }
- byte coordToIndex(coordinates c) {
- if (hexOOB(c)) {
- return 255;
- } else {
- return (10 * c.row) + (c.col / 2);
+ presetDef current = {
+ "Default", // name
+ TUNING_12EDO, // tuning
+ 0, // default to the first layout, wicki hayden
+ 0, // default to using no scale (chromatic)
+ 0, // default to the key of C, which in 12EDO is -9 steps from A.
+ 0 // default to no transposition
};
- }
- coordinates hexVector(byte direction, byte distance) {
- coordinates temp;
- int8_t vertical[] = {0,-1,-1, 0, 1,1};
- int8_t horizontal[] = {2, 1,-1,-2,-1,1};
- temp.row = vertical[direction] * distance;
- temp.col = horizontal[direction] * distance;
- return temp;
- }
- coordinates hexOffset(coordinates a, coordinates b) {
- coordinates temp;
- temp.row = a.row + b.row;
- temp.col = a.col + b.col;
- return temp;
- }
- coordinates hexDistance(coordinates origin, coordinates destination) {
- coordinates temp;
- temp.row = destination.row - origin.row;
- temp.col = destination.col - origin.col;
- return temp;
- }
- float freqToMIDI(float Hz) { // formula to convert from Hz to MIDI note
- return 69.0 + 12.0 * log2f(Hz / 440.0);
- }
- float MIDItoFreq(float MIDI) { // formula to convert from MIDI note to Hz
- return 440.0 * exp2((MIDI - 69.0) / 12.0);
- }
- float stepsToMIDI(int16_t stepsFromA) { // return the MIDI pitch associated
- return freqToMIDI(CONCERT_A_HZ) + ((float)stepsFromA * (float)current.tuning().stepSize / 100.0);
- }
// ====== diagnostic wrapper
@@ -1024,60 +293,127 @@
// ====== LED routines
- int16_t transformHue(float D) {
- if ((!perceptual) || (D > 360.0)) {
- return 65536 * (D / 360.0);
- } else {
- // red yellow green blue
- int hueIn[] = { 0, 9, 18, 90, 108, 126, 135, 150, 198, 243, 252, 261, 306, 333, 360};
- // #ff0000 #ffff00 #00ff00 #00ffff #0000ff #ff00ff
- int hueOut[] = { 0, 3640, 5461,10922,12743,16384,21845,27306,32768,38229,43690,49152,54613,58254,65535};
- byte B = 0;
- while (D - hueIn[B] > 0) {
- B++;
- };
- return hueOut[B - 1] + (hueOut[B] - hueOut[B - 1]) * ((D - (float)hueIn[B - 1])/(float)(hueIn[B] - hueIn[B - 1]));
+ int16_t transformHue(float h) {
+ // red yellow green blue
+ int hueIn[] = { 0, 9, 18, 90, 108, 126, 135, 150, 198, 243, 252, 261, 306, 333, 360};
+ // #ff0000 #ffff00 #00ff00 #00ffff #0000ff #ff00ff
+ int hueOut[] = { 0, 3640, 5461,10922,12743,16384,21845,27306,32768,38229,43690,49152,54613,58254,65535};
+ float D = fmod(h,360);
+ byte B = 0;
+ while (D - hueIn[B] > 0) {
+ B++;
};
+ float T = (D - hueIn[B - 1]) / (float)(hueIn[B] - hueIn[B - 1]);
+ return (hueOut[B - 1] * (1 - T)) + (hueOut[B] * T);
}
+
+ uint32_t getLEDcode(colorDef c) {
+ return strip.gamma32(strip.ColorHSV(transformHue(c.hue),c.sat,c.val));
+ }
+
void resetHexLEDs() { // calculate color codes for each hex, store for playback
- int16_t hue;
- float hueDegrees;
- byte sat;
- colors c;
for (byte i = 0; i < LED_COUNT; i++) {
if (!(h[i].isCmd)) {
- byte scaleDegree = positiveMod(h[i].steps + current.key().offset - current.findC(),current.tuning().cycleLength);
+ colorDef setColor;
+ byte paletteIndex = positiveMod(h[i].stepsFromC,current.tuning().cycleLength);
switch (colorMode) {
- case 1:
- c = keyOptions[current.keysBegin() + scaleDegree].tierColor;
- hueDegrees = hueCode[c];
- sat = satCode[c];
+ case TIERED_COLOR_MODE:
+ setColor = palette[current.tuningIndex].getColor(paletteIndex);
break;
default:
- hueDegrees = 360.0 * ((float)scaleDegree / (float)current.tuning().cycleLength);
- sat = 255;
+ setColor =
+ { 360.0 * ((float)paletteIndex / (float)current.tuning().cycleLength)
+ , SAT_VIVID
+ , VALUE_NORMAL
+ };
break;
};
- hue = transformHue(hueDegrees);
- h[i].LEDcolorPlay = strip.gamma32(strip.ColorHSV(hue,sat,VeryBRIGHT));
- h[i].LEDcolorOn = strip.gamma32(strip.ColorHSV(hue,sat,BRIGHT));
- h[i].LEDcolorOff = strip.gamma32(strip.ColorHSV(hue,sat,DIM));
- h[i].LEDcolorAnim = strip.ColorHSV(hue,0,255);
- } else {
- //
+ h[i].LEDcolorOn = getLEDcode(setColor);
+ h[i].LEDcolorPlay = getLEDcode(setColor.mixWithWhite()); // "mix with white"
+ setColor = {HUE_NONE,SAT_BW,VALUE_BLACK};
+ h[i].LEDcolorOff = getLEDcode(setColor); // turn off entirely
+ h[i].LEDcolorAnim = h[i].LEDcolorPlay;
};
};
+ sendToLog("LED codes re-calculated.");
+ }
+
+ void resetVelocityLEDs() {
+ colorDef tempColor =
+ { (runTime % (rainbowDegreeTime * 360)) / rainbowDegreeTime
+ , SAT_MODERATE
+ , byteLerp(0,255,85,127,velWheel.curValue)
+ };
+ strip.setPixelColor(assignCmd[0], getLEDcode(tempColor));
+
+ tempColor.val = byteLerp(0,255,42,85,velWheel.curValue);
+ strip.setPixelColor(assignCmd[1], getLEDcode(tempColor));
+
+ tempColor.val = byteLerp(0,255,0,42,velWheel.curValue);
+ strip.setPixelColor(assignCmd[2], getLEDcode(tempColor));
+ }
+ void resetWheelLEDs() {
+ // middle button
+ int tempSat = SAT_BW;
+ colorDef tempColor = {HUE_NONE, tempSat, (toggleWheel ? VALUE_SHADE : VALUE_LOW)};
+ strip.setPixelColor(assignCmd[3], getLEDcode(tempColor));
+ if (toggleWheel) {
+ // pb red / green
+ tempSat = byteLerp(SAT_BW,SAT_VIVID,0,8192,abs(pbWheel.curValue));
+ tempColor = {((pbWheel.curValue > 0) ? HUE_RED : HUE_CYAN), tempSat, VALUE_FULL};
+ strip.setPixelColor(assignCmd[5], getLEDcode(tempColor));
+
+ tempColor.val = tempSat * (pbWheel.curValue > 0);
+ strip.setPixelColor(assignCmd[4], getLEDcode(tempColor));
+
+ tempColor.val = tempSat * (pbWheel.curValue < 0);
+ strip.setPixelColor(assignCmd[6], getLEDcode(tempColor));
+ } else {
+ // mod blue / yellow
+ tempSat = byteLerp(SAT_BW,SAT_VIVID,0,64,abs(modWheel.curValue - 63));
+ tempColor = {((modWheel.curValue > 63) ? HUE_YELLOW : HUE_INDIGO), tempSat, 127 + (tempSat / 2)};
+ strip.setPixelColor(assignCmd[6], getLEDcode(tempColor));
+
+ if (modWheel.curValue <= 63) {
+ tempColor.val = 127 - (tempSat / 2);
+ }
+ strip.setPixelColor(assignCmd[5], getLEDcode(tempColor));
+
+ tempColor.val = tempSat * (modWheel.curValue > 63);
+ strip.setPixelColor(assignCmd[4], getLEDcode(tempColor));
+ };
+ }
+ uint32_t applyNotePixelColor(byte x){
+ if (h[x].animate) { return h[x].LEDcolorAnim;
+ } else if (h[x].channel) { return h[x].LEDcolorPlay;
+ } else if (h[x].inScale) { return h[x].LEDcolorOn;
+ } else { return h[x].LEDcolorOff;
+ };
}
// ====== layout routines
+ float freqToMIDI(float Hz) { // formula to convert from Hz to MIDI note
+ return 69.0 + 12.0 * log2f(Hz / 440.0);
+ }
+ float MIDItoFreq(float MIDI) { // formula to convert from MIDI note to Hz
+ return 440.0 * exp2((MIDI - 69.0) / 12.0);
+ }
+ float stepsToMIDI(int16_t stepsFromA) { // return the MIDI pitch associated
+ return freqToMIDI(CONCERT_A_HZ) + ((float)stepsFromA * (float)current.tuning().stepSize / 100.0);
+ }
+
void assignPitches() { // run this if the layout, key, or transposition changes, but not if color or scale changes
sendToLog("assignPitch was called:");
for (byte i = 0; i < LED_COUNT; i++) {
if (!(h[i].isCmd)) {
- float N = stepsToMIDI(h[i].steps + current.key().offset + current.transpose);
+ // steps is the distance from C
+ // the stepsToMIDI function needs distance from A4
+ // it also needs to reflect any transposition, but
+ // NOT the key of the scale.
+ float N = stepsToMIDI(current.pitchRelToA4(h[i].stepsFromC));
if (N < 0 || N >= 128) {
- h[i].note = 255;
+ h[i].note = UNUSED_NOTE;
h[i].bend = 0;
h[i].frequency = 0.0;
} else {
@@ -1087,7 +423,7 @@
};
sendToLog(
"hex #" + std::to_string(i) + ", " +
- "steps=" + std::to_string(h[i].steps) + ", " +
+ "steps=" + std::to_string(h[i].stepsFromC) + ", " +
"isCmd? " + std::to_string(h[i].isCmd) + ", " +
"note=" + std::to_string(h[i].note) + ", " +
"bend=" + std::to_string(h[i].bend) + ", " +
@@ -1102,14 +438,25 @@
sendToLog("applyScale was called:");
for (byte i = 0; i < LED_COUNT; i++) {
if (!(h[i].isCmd)) {
- byte degree = positiveMod(h[i].steps, current.tuning().cycleLength);
- byte whichByte = degree / 8;
- byte bitShift = 7 - (degree - (whichByte << 3));
- byte digitMask = 1 << bitShift;
- h[i].inScale = (current.scale().step[whichByte] & digitMask) >> bitShift;
+ if (current.scale().tuning == ALL_TUNINGS) {
+ h[i].inScale = 1;
+ } else {
+ byte degree = current.keyDegree(h[i].stepsFromC);
+ if (degree == 0) {
+ h[i].inScale = 1; // the root is always in the scale
+ } else {
+ byte tempSum = 0;
+ byte iterator = 0;
+ while (degree > tempSum) {
+ tempSum += current.scale().pattern[iterator];
+ iterator++;
+ }; // add the steps in the scale, and you're in scale
+ h[i].inScale = (tempSum == degree); // if the note lands on one of those sums
+ };
+ };
sendToLog(
"hex #" + std::to_string(i) + ", " +
- "steps=" + std::to_string(h[i].steps) + ", " +
+ "steps=" + std::to_string(h[i].stepsFromC) + ", " +
"isCmd? " + std::to_string(h[i].isCmd) + ", " +
"note=" + std::to_string(h[i].note) + ", " +
"inScale? " + std::to_string(h[i].inScale) + "."
@@ -1119,21 +466,23 @@
resetHexLEDs();
sendToLog("applyScale complete.");
}
+
void applyLayout() { // call this function when the layout changes
sendToLog("buildLayout was called:");
for (byte i = 0; i < LED_COUNT; i++) {
- if (!(h[i].isCmd)) {
- coordinates dist = hexDistance(h[current.layout().rootHex].coords, h[i].coords);
- h[i].steps = (
- (dist.col * current.layout().acrossSteps) +
- (dist.row * (
+ if (!(h[i].isCmd)) {
+ int8_t distCol = h[i].coordCol - h[current.layout().hexMiddleC].coordCol;
+ int8_t distRow = h[i].coordRow - h[current.layout().hexMiddleC].coordRow;
+ h[i].stepsFromC = (
+ (distCol * current.layout().acrossSteps) +
+ (distRow * (
current.layout().acrossSteps +
(2 * current.layout().dnLeftSteps)
))
- ) / 2;
+ ) / 2;
sendToLog(
"hex #" + std::to_string(i) + ", " +
- "steps=" + std::to_string(h[i].steps) + "."
+ "steps from C4=" + std::to_string(h[i].stepsFromC) + "."
);
};
};
@@ -1143,7 +492,6 @@
sendToLog("buildLayout complete.");
}
// ====== buzzer routines
-
// the piezo buzzer is an on/off switch that can buzz as fast as the processor clock (133MHz)
// the processor is fast enough to emulate analog signals.
// the RP2040 has pulse width modulation (PWM) built into the hardware.
@@ -1152,64 +500,83 @@
// to emulate an 8-bit (0-255) analog sample, with phase-correction, we need a 9 bit (512) cycle.
// we can safely sample up to 260kHz (133MHz / 512) this way.
// the highest frequency note in MIDI is about 12.5kHz.
- // it is therefore possible to emulate waveforms with 4 bits resolution (260kHz / 12.5kHz, it's > 16 but < 32).
+ // it is theoretically possible to emulate waveforms with 4 bits resolution (260kHz / 12.5kHz)
+ // but we are limited by calculation time.
+ // the macro POLLING_INTERVAL_IN_MICROSECONDS is set to a value that is long enough
+ // that the audio output is accurate, but short enough to allow as much resolution as possible.
+ // currently, 32 microseconds appears to be sufficient (about 500 CPU cycles).
+ //
// 1) set a constant PWM signal at F_CPU/512 (260kHz) to play on pin 23
// the PWM signal can emulate an analog value from 0 to 255.
// this is done in setup1().
- // 2) if a note is to be played on the buzzer, get the frequency, and express as a period in microseconds.
+ // 2) if a note is to be played on the buzzer, assign a channel (same as MPE mode for MIDI)
+ // and calculate the frequency. this might include pitch bends.
// this is done in buzz().
- // 3) divide the period into 16 subperiods. fractions of microsecond are distributed across the 16 ticks.
- // 4) every subperiod, change the level of the PWM output so that you emulate the next in the sequence of
- // 16 analog sample values. those values are based on the waveform shape chosen (square, sine, etc)
- // 5) this value is also scaled by the MIDI velocity wheel.
+ // 3) the frequency is expressed as "amount you'd increment a counter every polling interval
+ // so that you roll over a 16-bit (65536) value at that frequency.
+ // example: 440Hz note, 32microS polling
+ // 65536 x 440/s x .000032s = an increment of 923 per poll
+ // this is done in buzz().
+ // 4) the object called synth[] stores the increment and counter for each channel (0-14)=MIDI(2 thru 16)
+ // at every poll, each counter is incremented (will roll over since the type is 16-bit unsigned integer)
+ // and depending on the waveform, the 8-bit analog level is calculated.
+ // example: square waves return 0 if the counter is 0-32767, 255 if 32768-65535.
+ // saw waves return (counter / 256).
+ // 5) the analog levels are mixed. i use an attenuation function, basically (# of simultaneous notes) ^ -0.5,
+ // so the perceived volume is consistent. the velocity wheel is also multiplied in.
// 6) hardware timers are used because they will interrupt and run even if other code is active.
// otherwise, the subperiod is essentially floored at the length of the main loop() which is
// thousands of microseconds long!
- // the implementation of 6) is to make a single timer that calls back an interrupt function called advanceTick().
+ // further, we can run this process on the 2nd core so it doesn't interrupt the user experience
+ // the implementation of 6) is to make a single timer that calls back an interrupt function called poll().
// the callback function then resets the interrupt flag and resets the timer alarm.
- // the timer is set to go off at the time of the last timer, plus the subperiod (stored based on the last frequency played).
- // after the timer is reset, the function then changes the level of the PWM based on 4) and 5) above.
- // example:
- // to buzz note 69 (A=440Hz) at velocity 96:
- // period = 2273 microseconds
- // subperiod = 142 microseconds for 15 ticks, 143 microseconds for 1 tick
- // for a square wave play 8 periods at zero level, 8 periods at 96 * 129 / 64 = 203 level
+ // the timer is set to go off at the time of the last timer + the polling interval
+
- void advanceTick() {
+ // RUN ON CORE 2
+ void poll() {
hw_clear_bits(&timer_hw->intr, 1u << ALARM_NUM);
- wfTick = ((wfTick + 1) & (WAVE_RESOLUTION - 1));
- microSecondsPerTick = (microSecondsPerCycle / WAVE_RESOLUTION)
- + ((microSecondsPerCycle % WAVE_RESOLUTION) < wfTick)
- ;
- timer_hw->alarm[ALARM_NUM] = timer_hw->timerawl + microSecondsPerTick;
- wfLvl = ((playbackMode && (currentHexBuzzing <= LED_COUNT)) ? (wf[currWave].lvl[wfTick] * velWheel.curValue) >> 6 : 0);
- pwm_set_chan_level(TONE_SL, TONE_CH, wfLvl);
- }
- void buzz() {
- if (playbackMode && (currentHexBuzzing <= LED_COUNT)) {
- microSecondsPerCycle = round(1000000 / (exp2(pbWheel.curValue * PITCH_BEND_SEMIS / 98304.0) * h[currentHexBuzzing].frequency));
- };
- }
- byte nextHeldNote() {
- byte n = 255;
- for (byte i = 1; i < LED_COUNT; i++) {
- byte j = positiveMod(currentHexBuzzing + i, LED_COUNT);
- if ((h[j].channel) && (!h[j].isCmd)) {
- n = j;
- break;
+ timer_hw->alarm[ALARM_NUM] = timer_hw->timerawl + POLL_INTERVAL_IN_MICROSECONDS;
+ uint16_t lvl = 0;
+ byte p;
+ for (byte i = 0; i < POLYPHONY_LIMIT; i++) {
+ synth[i].counter += synth[i].increment; // should loop from 65536 -> 0
+ switch (currWave) {
+ case WAVEFORM_SQUARE:
+ p = 0 - ((synth[i].counter & 0x8000) >> 15); // grab first bit -> 0 or -1 (255)
+ break;
+ case WAVEFORM_SAW:
+ p = (synth[i].counter >> 8); // 0 thru 255
+ break;
+ default:
+ p = 0;
+ break;
};
+ lvl += p; // for polyphony=15, cap=255*15=3825
};
- return n;
- }
- void tryBuzzing(byte x) {
- currentHexBuzzing = x;
- if ((h[x].isCmd) || (h[x].note >= 128)) {
- currentHexBuzzing = 255; // send 128 or larger to turn off tone
+ lvl = (lvl * attenuation[poly]) >> 8; // cap = 3825 * 17 / 256 = 254
+ lvl = (lvl * velWheel.curValue) >> 7;
+ pwm_set_chan_level(TONE_SL, TONE_CH, lvl);
+ }
+ // RUN ON CORE 1
+ void buzz(byte x, bool p) {
+ byte ch = h[x].channel - 2;
+ synth[ch].counter = 0;
+ if (p) {
+ synth[ch].increment = h[x].frequency // note frequency
+ * exp2(pbWheel.curValue * PITCH_BEND_SEMIS / 98304.0) // adjusted for global pitch bend
+ * ((POLL_INTERVAL_IN_MICROSECONDS << 16) / 1000000); // cycle 0-65535 at resultant frequency
+ } else {
+ synth[ch].increment = 0; // zero effectively silences the channel
};
- buzz();
}
-// ====== MIDI routines
+// ====== MIDI routines
+ void setAllNotesOff(byte Ch) {
+ if (enableMIDI) {
+ MIDI.sendControlChange(123, 0, Ch);
+ }
+ }
void setPitchBendRange(byte Ch, byte semitones) {
if (enableMIDI) { // MIDI mode only
MIDI.beginRpn(0, Ch);
@@ -1217,7 +584,8 @@
MIDI.endRpn(Ch);
sendToLog(
"set pitch bend range on ch " +
- std::to_string(Ch) + " to be " + std::to_string(semitones) + " semitones"
+ std::to_string(Ch) + " to be " +
+ std::to_string(semitones) + " semitones"
);
}
}
@@ -1232,144 +600,96 @@
);
}
}
- void prepMIDIforMicrotones() {
- bool makeZone = (MPE && (current.tuningIndex != Twelve)); // if MPE flag is on and tuning <> 12EDO
- setMPEzone(1, (8 * makeZone)); // MPE zone 1 = ch 2 thru 9 (or reset if not using MPE)
- delay(ccMsgCoolDown);
- setMPEzone(16, (5 * makeZone)); // MPE zone 16 = ch 11 thru 15 (or reset if not using MPE)
- delay(ccMsgCoolDown);
+ void applyMPEmode() {
+ while (!openChannelQueue.empty()) { // empty the channel queue
+ openChannelQueue.pop();
+ };
for (byte i = 1; i <= 16; i++) {
- setPitchBendRange(i, PITCH_BEND_SEMIS); // some synths try to set PB range to 48 semitones.
- delay(ccMsgCoolDown); // this forces it back to the expected range of 2 semitones.
- if ((i != 10) && ((!makeZone) || ((i > 1) && (i < 16)))) {
- openChannelQueue.push(i);
- sendToLog("pushed ch " + std::to_string(i) + " to the open channel queue");
- };
- channelBend[i - 1] = 0;
- channelPoly[i - 1] = 0;
+ setAllNotesOff(i); // turn off all notes
+ setPitchBendRange(i, PITCH_BEND_SEMIS); // force pitch bend back to the expected range of 2 semitones.
+ };
+ setMPEzone(1, POLYPHONY_LIMIT); // MPE zone 1 = ch 2 thru 16
+ for (byte i = 0; i < POLYPHONY_LIMIT; i++) {
+ openChannelQueue.push(i + 2);
+ sendToLog("pushed ch " + std::to_string(i + 2) + " to the open channel queue");
};
}
void chgModulation() {
if (enableMIDI) { // MIDI mode only
- if (current.tuningIndex == Twelve) {
- MIDI.sendControlChange(1, modWheel.curValue, 1);
- sendToLog("sent mod value " + std::to_string(modWheel.curValue) + " to ch 1");
- } else if (MPE) {
- MIDI.sendControlChange(1, modWheel.curValue, 1);
- sendToLog("sent mod value " + std::to_string(modWheel.curValue) + " to ch 1");
- MIDI.sendControlChange(1, modWheel.curValue, 16);
- sendToLog("sent mod value " + std::to_string(modWheel.curValue) + " to ch 16");
- } else {
- for (byte i = 0; i < 16; i++) {
- MIDI.sendControlChange(1, modWheel.curValue, i + 1);
- sendToLog("sent mod value " + std::to_string(modWheel.curValue) + " to ch " + std::to_string(i+1));
- };
- };
+ MIDI.sendControlChange(1, modWheel.curValue, 1);
+ sendToLog("sent mod value " + std::to_string(modWheel.curValue) + " to ch 1");
};
- };
+ }
void chgUniversalPB() {
if (enableMIDI) { // MIDI mode only
- if (current.tuningIndex == Twelve) {
- MIDI.sendPitchBend(pbWheel.curValue, 1);
- sendToLog("sent pb value " + std::to_string(pbWheel.curValue) + " to ch 1");
- } else if (MPE) {
- MIDI.sendPitchBend(pbWheel.curValue, 1);
- sendToLog("sent pb value " + std::to_string(pbWheel.curValue) + " to ch 1");
- MIDI.sendPitchBend(pbWheel.curValue, 16);
- sendToLog("sent pb value " + std::to_string(pbWheel.curValue) + " to ch 16");
- } else {
- for (byte i = 0; i < 16; i++) {
- MIDI.sendPitchBend(channelBend[i] + pbWheel.curValue, i + 1);
- sendToLog("sent pb value " + std::to_string(channelBend[i] + pbWheel.curValue) + " to ch " + std::to_string(i+1));
- };
- };
- };
- }
- byte assignChannel(byte x) {
- if (current.tuningIndex == Twelve) {
- return 1;
- } else {
- byte temp = 17;
- for (byte c = MPE; c < (16 - MPE); c++) { // MPE - look at ch 2 thru 15 [c 1-14]; otherwise ch 1 thru 16 [c 0-15]
- if ((c + 1 != 10) && (h[x].bend == channelBend[c])) { // not using drum channel ch 10 in either case
- temp = c + 1;
- sendToLog("found a matching channel: ch " + std::to_string(temp) + " has pitch bend " + std::to_string(channelBend[c]));
- break;
- };
- };
- if (temp = 17) {
- if (openChannelQueue.empty()) {
- sendToLog("channel queue was empty so we didn't send a note on");
- } else {
- temp = openChannelQueue.front();
- openChannelQueue.pop();
- sendToLog("popped " + std::to_string(temp) + " off the queue");
+ MIDI.sendPitchBend(pbWheel.curValue, 1);
+ for (byte i = 0; i < LED_COUNT; i++) {
+ if (!(h[i].isCmd)) {
+ if (h[i].channel) {
+ buzz(i,true); // rebuzz all notes if the pitch bend changes
+ };
};
};
- return temp;
+ sendToLog("sent pb wheel value " + std::to_string(pbWheel.curValue) + " to ch 1");
};
}
-
+
// ====== hex press routines
- void noteOn(byte x) {
- byte c = assignChannel(x);
- if (c <= 16) {
- h[x].channel = c; // value is 1 - 16
- if (current.tuningIndex != Twelve) {
- channelPoly[c - 1]++; // array is 0 - 15
- };
- if (playbackMode) {
- tryBuzzing(x);
+ void playNote(byte x) {
+ // this gets called on any non-command hex
+ // that is not scale-locked.
+ if (!(h[x].channel)) { // but just in case, check
+ if (openChannelQueue.empty()) { // if there aren't any open channels
+ sendToLog("channel queue was empty so did not play");
} else {
- if (current.tuningIndex != Twelve) {
- MIDI.sendPitchBend(h[x].bend, c); // ch 1-16
+ h[x].channel = openChannelQueue.front(); // value in MIDI terms (1-16)
+ openChannelQueue.pop();
+ sendToLog("popped " + std::to_string(h[x].channel) + " off the queue");
+ if (!(playbackMode == BUZZ_OFF)) {
+ buzz(x, true);
+ };
+ if (enableMIDI) {
+ MIDI.sendPitchBend(h[x].bend, h[x].channel); // ch 1-16
+ MIDI.sendNoteOn(h[x].note, velWheel.curValue, h[x].channel); // ch 1-16
+ sendToLog(
+ "sent MIDI noteOn: " + std::to_string(h[x].note) +
+ " pb " + std::to_string(h[x].bend) +
+ " vel " + std::to_string(velWheel.curValue) +
+ " ch " + std::to_string(h[x].channel)
+ );
};
- MIDI.sendNoteOn(h[x].note, velWheel.curValue, c); // ch 1-16
- sendToLog(
- "sent note on: " + std::to_string(h[x].note) +
- " pb " + std::to_string(h[x].bend) +
- " vel " + std::to_string(velWheel.curValue) +
- " ch " + std::to_string(c)
- );
};
};
}
- void noteOff(byte x) {
- byte c = h[x].channel;
- if (c) {
- h[x].channel = 0;
- if (current.tuningIndex != Twelve) {
- switch (channelPoly[c - 1]) {
- case 1:
- channelPoly[c - 1]--;
- openChannelQueue.push(c);
- break;
- case 0:
- break;
- default:
- channelPoly[c - 1]--;
- break;
- };
+ void stopNote(byte x) {
+ // this gets called on any non-command hex
+ // that is not scale-locked.
+ if (h[x].channel) { // but just in case, check
+ openChannelQueue.push(h[x].channel);
+ sendToLog("pushed " + std::to_string(h[x].channel) + " on the queue");
+ if (!(playbackMode == BUZZ_OFF)) {
+ buzz(x, false);
};
- if (playbackMode) {
- tryBuzzing(nextHeldNote());
- } else {
- MIDI.sendNoteOff(h[x].note, velWheel.curValue, c);
+ if (playbackMode == BUZZ_ARPEGGIO) {
+ arpeggiateTime = 0; // trigger arpeggiate function early if any note changes
+ };
+ if (enableMIDI) {
+ MIDI.sendNoteOff(h[x].note, velWheel.curValue, h[x].channel);
sendToLog(
"sent note off: " + std::to_string(h[x].note) +
" pb " + std::to_string(h[x].bend) +
" vel " + std::to_string(velWheel.curValue) +
- " ch " + std::to_string(c)
+ " ch " + std::to_string(h[x].channel)
);
};
+ h[x].channel = 0;
};
}
void cmdOn(byte x) { // volume and mod wheel read all current buttons
switch (h[x].note) {
case CMDB + 3:
toggleWheel = !toggleWheel;
- // recolorHex(x);
break;
default:
// the rest should all be taken care of within the wheelDef structure
@@ -1377,14 +697,28 @@
};
}
void cmdOff(byte x) { // pitch bend wheel only if buttons held.
- // nothing; should all be taken care of within the wheelDef structure
+ switch (h[x].note) {
+ default:
+ break; // nothing; should all be taken care of within the wheelDef structure
+ };
}
// ====== animations
-
- void flagToAnimate(coordinates C) {
- if (!hexOOB(C)) {
- h[coordToIndex(C)].animate = 1;
+ uint64_t animFrame(byte x) {
+ if (h[x].timePressed) { // 2^20 microseconds is close enough to 1 second
+ return 1 + (((runTime - h[x].timePressed) * animationFPS) >> 20);
+ } else {
+ return 0;
+ };
+ }
+ void flagToAnimate(int8_t r, int8_t c) {
+ if (!
+ ( ( r < 0 ) || ( r >= ROWCOUNT )
+ || ( c < 0 ) || ( c >= (2 * COLCOUNT) )
+ || ( ( c + r ) & 1 )
+ )
+ ) {
+ h[(10 * r) + (c / 2)].animate = 1;
};
}
void animateMirror() {
@@ -1392,8 +726,8 @@
if ((!(h[i].isCmd)) && (h[i].channel)) { // that is a held note
for (byte j = 0; j < LED_COUNT; j++) { // compare to every hex
if ((!(h[j].isCmd)) && (!(h[j].channel))) { // that is a note not being played
- int16_t temp = h[i].steps - h[j].steps; // look at difference between notes
- if (animationType == OctaveAnim) { // set octave diff to zero if need be
+ int16_t temp = h[i].stepsFromC - h[j].stepsFromC; // look at difference between notes
+ if (animationType == ANIMATE_OCTAVE) { // set octave diff to zero if need be
temp = positiveMod(temp, current.tuning().cycleLength);
};
if (temp == 0) { // highlight if diff is zero
@@ -1404,24 +738,29 @@
};
};
}
+
void animateOrbit() {
for (byte i = 0; i < LED_COUNT; i++) { // check every hex
- if ((!(h[i].isCmd)) && (h[i].channel)) { // that is a held note
- flagToAnimate(hexOffset(h[i].coords,hexVector((h[i].animFrame() % 6),1))); // different neighbor each frame
+ if ((!(h[i].isCmd)) && (h[i].channel) && ((h[i].inScale) || (!scaleLock))) { // that is a held note
+ byte tempDir = (animFrame(i) % 6);
+ flagToAnimate(h[i].coordRow + vertical[tempDir], h[i].coordCol + horizontal[tempDir]); // different neighbor each frame
};
};
}
+
void animateRadial() {
- for (byte i = 0; i < LED_COUNT; i++) { // check every hex
- if (!(h[i].isCmd)) { // that is a note
- uint32_t radius = h[i].animFrame();
- if ((radius > 0) && (radius < 16)) { // played in the last 16 frames
- byte steps = ((animationType == SplashAnim) ? radius : 1); // star = 1 step to next corner; ring = 1 step per hex
- coordinates temp = hexOffset(h[i].coords,hexVector(DnLeft,radius)); // start at one corner of the ring
- for (byte dir = 0; dir < 6; dir++) { // walk along the ring in each of the 6 hex directions
+ for (byte i = 0; i < LED_COUNT; i++) { // check every hex
+ if (!(h[i].isCmd) && ((h[i].inScale) || (!scaleLock))) { // that is a note
+ uint64_t radius = animFrame(i);
+ if ((radius > 0) && (radius < 16)) { // played in the last 16 frames
+ byte steps = ((animationType == ANIMATE_SPLASH) ? radius : 1); // star = 1 step to next corner; ring = 1 step per hex
+ int8_t turtleRow = h[i].coordRow + (radius * vertical[HEX_DIRECTION_SW]);
+ int8_t turtleCol = h[i].coordCol + (radius * horizontal[HEX_DIRECTION_SW]);
+ for (byte dir = HEX_DIRECTION_EAST; dir < 6; dir++) { // walk along the ring in each of the 6 hex directions
for (byte i = 0; i < steps; i++) { // # of steps to the next corner
- flagToAnimate(temp); // flag for animation
- temp = hexOffset(temp, hexVector(dir,radius / steps)); // then next step
+ flagToAnimate(turtleRow,turtleCol); // flag for animation
+ turtleRow += (vertical[dir] * (radius / steps));
+ turtleCol += (horizontal[dir] * (radius / steps));
};
};
};
@@ -1430,7 +769,6 @@
}
// ====== menu routines
-
void menuHome() {
menu.setMenuPageCurrent(menuPageMain);
menu.drawMenu();
@@ -1443,13 +781,13 @@
}
void showOnlyValidScaleChoices() { // re-run at setup and whenever tuning changes
for (int S = 0; S < scaleCount; S++) {
- menuItemScales[S]->hide((scaleOptions[S].tuning != current.tuningIndex) && (scaleOptions[S].tuning != 255));
+ menuItemScales[S]->hide((scaleOptions[S].tuning != current.tuningIndex) && (scaleOptions[S].tuning != ALL_TUNINGS));
};
sendToLog("menu: Scale choices were updated.");
}
void showOnlyValidKeyChoices() { // re-run at setup and whenever tuning changes
- for (int K = 0; K < keyCount; K++) {
- menuItemKeys[K]->hide((keyOptions[K].tuning != current.tuningIndex));
+ for (int T = 0; T < TUNINGCOUNT; T++) {
+ menuItemKeys[T]->hide((T != current.tuningIndex));
};
sendToLog("menu: Key choices were updated.");
}
@@ -1469,72 +807,66 @@
};
menuHome();
}
- void changeKey(GEMCallbackData callbackData) { // when you change the key via the menu
- int selection = callbackData.valInt;
- if (selection != current.keyIndex) {
- current.keyIndex = selection;
- assignPitches();
- };
- menuHome();
+ void changeKey() { // when you change the key via the menu
+ applyScale();
+ }
+ void changeTranspose() { // when you change the transpose via the menu
+ current.transpose = transposeSteps;
+ assignPitches();
}
void changeTuning(GEMCallbackData callbackData) { // not working yet
byte selection = callbackData.valByte;
if (selection != current.tuningIndex) {
current.tuningIndex = selection;
- current.layoutIndex = current.layoutsBegin();
- current.scaleIndex = 0;
- current.keyIndex = current.keysBegin();
- showOnlyValidLayoutChoices();
- showOnlyValidScaleChoices();
- showOnlyValidKeyChoices();
- applyLayout();
- prepMIDIforMicrotones();
+ current.layoutIndex = current.layoutsBegin(); // reset layout to first in list
+ current.scaleIndex = 0; // reset scale to "no scale"
+ current.keyStepsFromA = current.tuning().spanCtoA(); // reset key to C
+ showOnlyValidLayoutChoices(); // change list of choices in GEM Menu
+ showOnlyValidScaleChoices(); // change list of choices in GEM Menu
+ showOnlyValidKeyChoices(); // change list of choices in GEM Menu
+ applyLayout(); // apply changes above
+ applyMPEmode(); // clear out MIDI queue
};
menuHome();
}
- void buildMenu() {
- menuPageMain.addMenuItem(menuGotoTuning);
- for (byte T = 0; T < tuningCount; T++) { // create pointers to all tuning choices
+ void createTuningMenuItems() {
+ for (byte T = 0; T < TUNINGCOUNT; T++) {
menuItemTuning[T] = new GEMItem(tuningOptions[T].name.c_str(), changeTuning, T);
menuPageTuning.addMenuItem(*menuItemTuning[T]);
};
-
- menuPageMain.addMenuItem(menuGotoLayout);
+ }
+ void createLayoutMenuItems() {
for (byte L = 0; L < layoutCount; L++) { // create pointers to all layouts
menuItemLayout[L] = new GEMItem(layoutOptions[L].name.c_str(), changeLayout, L);
menuPageLayout.addMenuItem(*menuItemLayout[L]);
};
showOnlyValidLayoutChoices();
-
- menuPageMain.addMenuItem(menuGotoScales);
+ }
+ void createKeyMenuItems() {
+ for (byte T = 0; T < TUNINGCOUNT; T++) {
+ selectKey[T] = new GEMSelect(tuningOptions[T].cycleLength, tuningOptions[T].keyChoices);
+ menuItemKeys[T] = new GEMItem("Key:", current.keyStepsFromA, *selectKey[T], changeKey);
+ menuPageScales.addMenuItem(*menuItemKeys[T]);
+ };
+ showOnlyValidKeyChoices();
+ }
+ void createScaleMenuItems() {
for (int S = 0; S < scaleCount; S++) { // create pointers to all scale items, filter them as you go
menuItemScales[S] = new GEMItem(scaleOptions[S].name.c_str(), changeScale, S);
menuPageScales.addMenuItem(*menuItemScales[S]);
};
showOnlyValidScaleChoices();
-
- menuPageMain.addMenuItem(menuGotoKeys);
- for (int K = 0; K < keyCount; K++) {
- menuItemKeys[K] = new GEMItem(keyOptions[K].name.c_str(), changeKey, K);
- menuPageKeys.addMenuItem(*menuItemKeys[K]);
- };
- showOnlyValidKeyChoices();
-
- menuPageMain.addMenuItem(menuItemScaleLock);
- menuPageMain.addMenuItem(menuItemColor);
- menuPageMain.addMenuItem(menuItemMIDI);
- menuPageMain.addMenuItem(menuItemPlayback);
- menuPageMain.addMenuItem(menuItemWaveform);
- menuPageMain.addMenuItem(menuItemAnimate);
- menuPageMain.addMenuItem(menuItemPercep);
- menuPageMain.addMenuItem(menuItemMPE);
}
// ====== setup routines
-
+ void testDiagnostics() {
+ sendToLog("theHDM was here");
+ }
void setupMIDI() {
usb_midi.setStringDescriptor("HexBoard MIDI"); // Initialize MIDI, and listen to all MIDI channels
MIDI.begin(MIDI_CHANNEL_OMNI); // This will also call usb_midi's begin()
+ applyMPEmode();
+ sendToLog("setupMIDI okay");
}
void setupFileSystem() {
Serial.begin(115200); // Set serial to make uploads work without bootsel button
@@ -1544,81 +876,98 @@
LittleFS.begin(); // Mounts file system.
if (!LittleFS.begin()) {
sendToLog("An Error has occurred while mounting LittleFS");
+ } else {
+ sendToLog("LittleFS mounted OK");
}
}
void setupPins() {
- for (byte p = 0; p < sizeof(cPin); p++) // For each column pin...
- {
+ for (byte p = 0; p < sizeof(cPin); p++) { // For each column pin...
pinMode(cPin[p], INPUT_PULLUP); // set the pinMode to INPUT_PULLUP (+3.3V / HIGH).
}
- for (byte p = 0; p < sizeof(mPin); p++) // For each column pin...
- {
+ for (byte p = 0; p < sizeof(mPin); p++) { // For each column pin...
pinMode(mPin[p], OUTPUT); // Setting the row multiplexer pins to output.
}
Wire.setSDA(SDAPIN);
Wire.setSCL(SCLPIN);
pinMode(ROT_PIN_C, INPUT_PULLUP);
+ sendToLog("Pins mounted");
}
void setupGrid() {
- /*
- sendToLog("initializing hex grid..."));
- */
for (byte i = 0; i < LED_COUNT; i++) {
- h[i].coords = indexToCoord(i);
+ h[i].coordRow = (i / 10);
+ h[i].coordCol = (2 * (i % 10)) + (h[i].coordRow & 1);
h[i].isCmd = 0;
- h[i].note = 255;
- h[i].keyState = 0;
+ h[i].note = UNUSED_NOTE;
+ h[i].btnState = 0;
};
for (byte c = 0; c < CMDCOUNT; c++) {
h[assignCmd[c]].isCmd = 1;
h[assignCmd[c]].note = CMDB + c;
};
+ sendToLog("initializing hex grid...");
applyLayout();
}
- void setupLEDs() { // need layout
+ void setupLEDs() {
strip.begin(); // INITIALIZE NeoPixel strip object
strip.show(); // Turn OFF all pixels ASAP
+ sendToLog("LEDs started...");
resetHexLEDs();
}
- void setupMenu() { // need menu
+ void setupMenu() {
menu.setSplashDelay(0);
menu.init();
- buildMenu();
+ menuPageMain.addMenuItem(menuGotoTuning);
+ createTuningMenuItems();
+ menuPageTuning.addMenuItem(menuTuningBack);
+ menuPageMain.addMenuItem(menuGotoLayout);
+ createLayoutMenuItems();
+ menuPageLayout.addMenuItem(menuLayoutBack);
+ menuPageMain.addMenuItem(menuGotoScales);
+ createKeyMenuItems();
+ menuPageScales.addMenuItem(menuItemScaleLock);
+ createScaleMenuItems();
+ menuPageScales.addMenuItem(menuScalesBack);
+ menuPageMain.addMenuItem(menuGotoControl);
+ menuPageControl.addMenuItem(menuItemPBSpeed);
+ menuPageControl.addMenuItem(menuItemModSpeed);
+ menuPageControl.addMenuItem(menuItemVelSpeed);
+ menuPageControl.addMenuItem(menuControlBack);
+ menuPageMain.addMenuItem(menuItemTransposeSteps);
+ menuPageMain.addMenuItem(menuItemColor);
+ menuPageMain.addMenuItem(menuItemPlayback);
+ menuPageMain.addMenuItem(menuItemWaveform);
+ menuPageMain.addMenuItem(menuItemAnimate);
menuHome();
}
void setupGFX() {
u8g2.begin(); // Menu and graphics setup
u8g2.setBusClock(1000000); // Speed up display
u8g2.setContrast(defaultContrast); // Set contrast
- }
- void testDiagnostics() {
- /*
- sendToLog("theHDM was here"));
- */
+ sendToLog("U8G2 graphics initialized.");
}
void setupPiezo() {
- gpio_set_function(TONEPIN, GPIO_FUNC_PWM);
- pwm_set_phase_correct(TONE_SL, true);
- pwm_set_wrap(TONE_SL, 254);
- pwm_set_clkdiv(TONE_SL, 1.0f);
- pwm_set_chan_level(TONE_SL, TONE_CH, 0);
- pwm_set_enabled(TONE_SL, true);
+ gpio_set_function(TONEPIN, GPIO_FUNC_PWM); // set that pin as PWM
+ pwm_set_phase_correct(TONE_SL, true); // phase correct sounds better
+ pwm_set_wrap(TONE_SL, 254); // 0 - 254 allows 0 - 255 level
+ pwm_set_clkdiv(TONE_SL, 1.0f); // run at full clock speed
+ pwm_set_chan_level(TONE_SL, TONE_CH, 0); // initialize at zero to prevent whining sound
+ pwm_set_enabled(TONE_SL, true); // ENGAGE!
hw_set_bits(&timer_hw->inte, 1u << ALARM_NUM); // initialize the timer
- irq_set_exclusive_handler(ALARM_IRQ, advanceTick); // function to run every interrupt
- irq_set_enabled(ALARM_IRQ, true);
- timer_hw->alarm[ALARM_NUM] = timer_hw->timerawl + microSecondsPerTick;
+ irq_set_exclusive_handler(ALARM_IRQ, poll); // function to run every interrupt
+ irq_set_enabled(ALARM_IRQ, true); // ENGAGE!
+ timer_hw->alarm[ALARM_NUM] = timer_hw->timerawl + POLL_INTERVAL_IN_MICROSECONDS;
+ sendToLog("buzzer is ready.");
}
// ====== loop routines
-
void timeTracker() {
lapTime = runTime - loopTime;
- // sendToLog(lapTime)); // Print out the time it takes to run each loop
- loopTime = runTime; // Update previousTime variable to give us a reference point for next loop
- runTime = millis(); // Store the current time in a uniform variable for this program loop
+ loopTime = runTime; // Update previousTime variable to give us a reference point for next loop
+ runTime = timer_hw->timerawh;
+ runTime = (runTime << 32) + (timer_hw->timerawl); // Store the current time in a uniform variable for this program loop
}
void screenSaver() {
- if (screenTime <= screenSaverMillis) {
+ if (screenTime <= screenSaverTimeout) {
screenTime = screenTime + lapTime;
if (screenSaverOn) {
screenSaverOn = 0;
@@ -1632,35 +981,39 @@
}
}
void readHexes() {
- for (byte r = 0; r < ROWCOUNT; r++) { // Iterate through each of the row pins on the multiplexing chip.
+ for (byte r = 0; r < ROWCOUNT; r++) { // Iterate through each of the row pins on the multiplexing chip.
for (byte d = 0; d < 4; d++) {
digitalWrite(mPin[d], (r >> d) & 1);
}
- for (byte c = 0; c < COLCOUNT; c++) { // Now iterate through each of the column pins that are connected to the current row pin.
- byte p = cPin[c]; // Hold the currently selected column pin in a variable.
- pinMode(p, INPUT_PULLUP); // Set that row pin to INPUT_PULLUP mode (+3.3V / HIGH).
- delayMicroseconds(10); // Delay to give the pin modes time to change state (false readings are caused otherwise).
+ for (byte c = 0; c < COLCOUNT; c++) { // Now iterate through each of the column pins that are connected to the current row pin.
+ byte p = cPin[c]; // Hold the currently selected column pin in a variable.
+ pinMode(p, INPUT_PULLUP); // Set that row pin to INPUT_PULLUP mode (+3.3V / HIGH).
+ byte i = c + (r * COLCOUNT);
+ delayMicroseconds(6); // delay while column pin mode
bool didYouPressHex = (digitalRead(p) == LOW); // hex is pressed if it returns LOW. else not pressed
- h[c + (r * COLCOUNT)].updateKeyState(didYouPressHex);
- pinMode(p, INPUT); // Set the selected column pin back to INPUT mode (0V / LOW).
+ h[i].interpBtnPress(didYouPressHex);
+ if (h[i].btnState == 1) {
+ h[i].timePressed = runTime; // log the time
+ };
+ pinMode(p, INPUT); // Set the selected column pin back to INPUT mode (0V / LOW).
}
}
}
void actionHexes() {
for (byte i = 0; i < LED_COUNT; i++) { // For all buttons in the deck
- switch (h[i].keyState) {
+ switch (h[i].btnState) {
case 1: // just pressed
if (h[i].isCmd) {
cmdOn(i);
} else if (h[i].inScale || (!scaleLock)) {
- noteOn(i);
+ playNote(i);
};
break;
case 2: // just released
if (h[i].isCmd) {
cmdOff(i);
} else if (h[i].inScale || (!scaleLock)) {
- noteOff(i);
+ stopNote(i);
};
break;
case 3: // held
@@ -1670,52 +1023,60 @@
};
};
}
+
void arpeggiate() {
- if (playbackMode > 1) {
- if (runTime - currentBuzzTime > arpeggiateLength) {
- currentBuzzTime = millis();
- byte n = nextHeldNote();
- if (n != 255) {
- tryBuzzing(nextHeldNote());
+ if (playbackMode == BUZZ_ARPEGGIO) {
+ if (runTime - arpeggiateTime > arpeggiateLength) {
+ arpeggiateTime = runTime;
+ byte n = UNUSED_NOTE;
+ for (byte i = 1; i < LED_COUNT; i++) {
+ byte j = positiveMod(arpeggiatingNow + i, LED_COUNT);
+ if ((h[j].channel) && (!h[j].isCmd)) {
+ n = j;
+ break;
+ };
+ };
+ arpeggiatingNow = n;
+ if (n != UNUSED_NOTE) {
+ buzz(n, true);
};
};
};
}
void updateWheels() {
velWheel.setTargetValue();
- bool upd = velWheel.updateValue();
+ bool upd = velWheel.updateValue(runTime);
if (upd) {
- buzz(); // update the volume live
sendToLog("vel became " + std::to_string(velWheel.curValue));
}
if (toggleWheel) {
pbWheel.setTargetValue();
- upd = pbWheel.updateValue();
+ upd = pbWheel.updateValue(runTime);
if (upd) {
- buzz();
chgUniversalPB();
};
} else {
modWheel.setTargetValue();
- upd = modWheel.updateValue();
+ upd = modWheel.updateValue(runTime);
if (upd) {
chgModulation();
};
};
}
- void animateLEDs() { // TBD
+
+ void animateLEDs() {
for (byte i = 0; i < LED_COUNT; i++) {
h[i].animate = 0;
};
if (animationType) {
switch (animationType) {
- case StarAnim: case SplashAnim:
+ case ANIMATE_STAR: case ANIMATE_SPLASH:
animateRadial();
break;
- case OrbitAnim:
+ case ANIMATE_ORBIT:
animateOrbit();
break;
- case OctaveAnim: case NoteAnim:
+ case ANIMATE_OCTAVE: case ANIMATE_BY_NOTE:
animateMirror();
break;
default:
@@ -1726,58 +1087,11 @@
void lightUpLEDs() {
for (byte i = 0; i < LED_COUNT; i++) {
if (!(h[i].isCmd)) {
- if (h[i].animate) {
- strip.setPixelColor(i,h[i].LEDcolorAnim);
- } else if (h[i].channel) {
- strip.setPixelColor(i,h[i].LEDcolorPlay);
- } else if (h[i].inScale) {
- strip.setPixelColor(i,h[i].LEDcolorOn);
- } else {
- strip.setPixelColor(i,h[i].LEDcolorOff);
- };
- };
- };
- int16_t hueV = transformHue((runTime / rainbowDegreeTime) % 360);
- strip.setPixelColor(assignCmd[0],strip.gamma32(strip.ColorHSV(
- hueV,192,byteLerp(0,255,85,127,velWheel.curValue)
- )));
- strip.setPixelColor(assignCmd[1],strip.gamma32(strip.ColorHSV(
- hueV,192,byteLerp(0,255,42,85,velWheel.curValue)
- )));
- strip.setPixelColor(assignCmd[2],strip.gamma32(strip.ColorHSV(
- hueV,192,byteLerp(0,255,0,42,velWheel.curValue)
- )));
- if (toggleWheel) {
- // pb red / green
- int16_t hueP = transformHue((pbWheel.curValue > 0) ? 0 : 180);
- byte satP = byteLerp(0,255,0,8192,abs(pbWheel.curValue));
- strip.setPixelColor(assignCmd[3],strip.gamma32(strip.ColorHSV(
- 0,0,64
- )));
- strip.setPixelColor(assignCmd[4],strip.gamma32(strip.ColorHSV(
- transformHue(0),satP * (pbWheel.curValue > 0),satP * (pbWheel.curValue > 0)
- )));
- strip.setPixelColor(assignCmd[5],strip.gamma32(strip.ColorHSV(
- hueP,satP,255
- )));
- strip.setPixelColor(assignCmd[6],strip.gamma32(strip.ColorHSV(
- transformHue(180),satP * (pbWheel.curValue < 0),satP * (pbWheel.curValue < 0)
- )));
- } else {
- // mod blue / yellow
- int16_t hueM = transformHue((modWheel.curValue > 63) ? 90 : 270);
- byte satM = byteLerp(0,255,0,64,abs(modWheel.curValue - 63));
- strip.setPixelColor(assignCmd[3],strip.gamma32(strip.ColorHSV(0,0,128)));
- strip.setPixelColor(assignCmd[4],strip.gamma32(strip.ColorHSV(
- hueM,satM,((modWheel.curValue > 63) ? satM : 0)
- )));
- strip.setPixelColor(assignCmd[5],strip.gamma32(strip.ColorHSV(
- hueM,satM,((modWheel.curValue > 63) ? 127 + (satM / 2) : 127 - (satM / 2))
- )));
- strip.setPixelColor(assignCmd[6],strip.gamma32(strip.ColorHSV(
- hueM,satM,127 + (satM / 2)
- )));
+ strip.setPixelColor(i,applyNotePixelColor(i));
+ }
};
+ resetVelocityLEDs();
+ resetWheelLEDs();
strip.show();
}
void dealWithRotary() {
@@ -1802,20 +1116,12 @@
}
void keepTrackOfRotaryKnobTurns() {
switch (rotary.process()) {
- case DIR_CW:
- rotaryKnobTurns++;
- break;
- case DIR_CCW:
- rotaryKnobTurns--;
- break;
+ case DIR_CW: rotaryKnobTurns++; break;
+ case DIR_CCW: rotaryKnobTurns--; break;
}
rotaryKnobTurns = (
- rotaryKnobTurns > maxKnobTurns
- ? maxKnobTurns
- : (
- rotaryKnobTurns < -maxKnobTurns
- ? -maxKnobTurns
- : rotaryKnobTurns
+ (rotaryKnobTurns > maxKnobTurns) ? maxKnobTurns : (
+ (rotaryKnobTurns < -maxKnobTurns) ? -maxKnobTurns : rotaryKnobTurns
)
);
}
@@ -1823,6 +1129,7 @@
// ====== setup() and loop()
void setup() {
+ testDiagnostics(); // Print diagnostic troubleshooting information to serial monitor
#if (defined(ARDUINO_ARCH_MBED) && defined(ARDUINO_ARCH_RP2040))
TinyUSB_Device_Init(0); // Manual begin() is required on core without built-in support for TinyUSB such as mbed rp2040
#endif
@@ -1836,11 +1143,10 @@
for (byte i = 0; i < 5 && !TinyUSBDevice.mounted(); i++) {
delay(1); // wait until device mounted, maybe
};
- testDiagnostics(); // Print diagnostic troubleshooting information to serial monitor
}
void setup1() { // set up on second core
setupPiezo();
- };
+ }
void loop() { // run on first core
timeTracker(); // Time tracking functions
screenSaver(); // Reduces wear-and-tear on OLED panel
diff --git a/Presets.h b/Presets.h
new file mode 100644
index 0000000..ffc4c87
--- /dev/null
+++ b/Presets.h
@@ -0,0 +1,336 @@
+// 1/8192 of a whole tone pitch bend accuracy ~ 0.025 cents.
+// over 128 possible notes, error shd be less than 0.0002 cents to avoid drift.
+// expressing cents to 6 sig figs should be sufficient.
+// notation -- comma delimited string.
+// first entry should be the label for A=440.
+// last entry should be C, i.e. the "home key".
+// the rest of the scale C thru G will be spelled using the same pattern.
+// the number of commas is used to count where A and C are located in step space.
+tuningDef tuningOptions[] = {
+ { "12 EDO", 12, 100.000,
+ {{"C" ,-9},{"C#",-8},{"D" ,-7},{"Eb",-6},{"E" ,-5},{"F",-4}
+ ,{"F#",-3},{"G" ,-2},{"G#",-1},{"A" , 0},{"Bb", 1},{"B", 2}
+ }},
+ { "17 EDO", 17, 70.5882,
+ {{"C",-13},{"Db",-12},{"C#",-11},{"D",-10},{"Eb",-9},{"D#",-8}
+ ,{"E", -7},{"F" , -6},{"Gb", -5},{"F#",-4},{"G", -3},{"Ab",-2}
+ ,{"G#",-1},{"A" , 0},{"Bb", 1},{"A#", 2},{"B", 3}
+ }},
+ { "19 EDO", 19, 63.1579,
+ {{"C" ,-14},{"C#",-13},{"Db",-12},{"D",-11},{"D#",-10},{"Eb",-9},{"E",-8}
+ ,{"E#", -7},{"F" , -6},{"F#", -5},{"Gb",-4},{"G", -3},{"G#",-2}
+ ,{"Ab", -1},{"A" , 0},{"A#", 1},{"Bb", 2},{"B", 3},{"Cb", 4}
+ }},
+ { "22 EDO", 22, 54.5455,
+ {{" C", -17},{"^C",-16},{"vC#",-15},{"vD",-14},{" D",-13},{"^D",-12}
+ ,{"^Eb",-11},{"vE",-10},{" E", -9},{" F", -8},{"^F", -7},{"vF#",-6}
+ ,{"vG", -5},{" G", -4},{"^G", -3},{"vG#",-2},{"vA", -1},{" A", 0}
+ ,{"^A", 1},{"^Bb", 2},{"vB", 3},{" B", 4}
+ }},
+ { "24 EDO", 24, 50.0000,
+ {{"C", -18},{"C+",-17},{"C#",-16},{"Dd",-15},{"D",-14},{"D+",-13}
+ ,{"Eb",-12},{"Ed",-11},{"E", -10},{"E+", -9},{"F", -8},{"F+", -7}
+ ,{"F#", -6},{"Gd", -5},{"G", -4},{"G+", -3},{"G#",-2},{"Ad", -1}
+ ,{"A", 0},{"A+", 1},{"Bb", 2},{"Bd", 3},{"B", 4},{"Cd", 5}
+ }},
+ { "31 EDO", 31, 38.7097,
+ {{"C",-23},{"C+",-22},{"C#",-21},{"Db",-20},{"Dd",-19}
+ ,{"D",-18},{"D+",-17},{"D#",-16},{"Eb",-15},{"Ed",-14}
+ ,{"E",-13},{"E+",-12} ,{"Fd",-11}
+ ,{"F",-10},{"F+", -9},{"F#", -8},{"Gb", -7},{"Gd", -6}
+ ,{"G", -5},{"G+", -4},{"G#", -3},{"Ab", -2},{"Ad", -1}
+ ,{"A", 0},{"A+", 1},{"A#", 2},{"Bb", 3},{"Bd", 4}
+ ,{"B", 5},{"B+", 6} ,{"Cd", 7}
+ }},
+ { "41 EDO", 41, 29.2683,
+ {{" C",-31},{"^C",-30},{" C+",-29},{" Db",-28},{" C#",-27},{" Dd",-26},{"vD",-24}
+ ,{" D",-24},{"^D",-23},{" D+",-22},{" Eb",-21},{" D#",-20},{" Ed",-19},{"vE",-18}
+ ,{" E",-17},{"^E",-16} ,{"vF",-15}
+ ,{" F",-14},{"^F",-13},{" F+",-12},{" Gb",-11},{" F#",-10},{" Gd", -9},{"vG", -8}
+ ,{" G", -7},{"^G", -6},{" G+", -5},{" Ab", -4},{" G#", -3},{" Ad", -2},{"vA", -1}
+ ,{" A", 0},{"^A", 1},{" A+", 2},{" Bb", 3},{" A#", 4},{" Bd", 5},{"vB", 6}
+ ,{" B", 7},{"^B", 8} ,{"vC", 9}
+ }},
+ { "53 EDO", 53, 22.6415,
+ {{" C", -40},{"^C", -39},{">C",-38},{"vDb",-37},{"Db",-36}
+ ,{" C#",-35},{"^C#",-34},{"<D",-33},{"vD", -32}
+ ,{" D", -31},{"^D", -30},{">D",-29},{"vEb",-28},{"Eb",-27}
+ ,{" D#",-26},{"^D#",-25},{"<E",-24},{"vE", -23}
+ ,{" E", -22},{"^E", -21},{">E",-20},{"vF", -19}
+ ,{" F", -18},{"^F", -17},{">F",-16},{"vGb",-15},{"Gb",-14}
+ ,{" F#",-13},{"^F#",-12},{"<G",-11},{"vG", -10}
+ ,{" G", -9},{"^G", -8},{">G", -7},{"vAb", -6},{"Ab", -5}
+ ,{" G#", -4},{"^G#", -3},{"<A", -2},{"vA", -1}
+ ,{" A", 0},{"^A", 1},{">A", 2},{"vBb", 3},{"Bb", 4}
+ ,{" A#", 5},{"^A#", 6},{"<B", 7},{"vB", 8}
+ ,{" B", 9},{"^B", 10},{"<C", 11},{"vC", 12}
+ }},
+ { "72 EDO", 72, 16.6667,
+ {{" C", -54},{"^C", -53},{">C", -52},{" C+",-51},{"<C#",-50},{"vC#",-49}
+ ,{" C#",-48},{"^C#",-47},{">C#",-46},{" Dd",-45},{"<D" ,-44},{"vD" ,-43}
+ ,{" D", -42},{"^D", -41},{">D", -40},{" D+",-39},{"<Eb",-38},{"vEb",-37}
+ ,{" Eb",-36},{"^Eb",-35},{">Eb",-34},{" Ed",-33},{"<E" ,-32},{"vE" ,-31}
+ ,{" E", -30},{"^E", -29},{">E", -28},{" E+",-27},{"<F" ,-26},{"vF" ,-25}
+ ,{" F", -24},{"^F", -23},{">F", -22},{" F+",-21},{"<F#",-20},{"vF#",-19}
+ ,{" F#",-18},{"^F#",-17},{">F#",-16},{" Gd",-15},{"<G" ,-14},{"vG" ,-13}
+ ,{" G", -12},{"^G", -11},{">G", -10},{" G+", -9},{"<G#", -8},{"vG#", -7}
+ ,{" G#", -6},{"^G#", -5},{">G#", -4},{" Ad", -3},{"<A" , -2},{"vA" , -1}
+ ,{" A", 0},{"^A", 1},{">A", 2},{" A+", 3},{"<Bb", 4},{"vBb", 5}
+ ,{" Bb", 6},{"^Bb", 7},{">Bb", 8},{" Bd", 9},{"<B" , 10},{"vB" , 11}
+ ,{" B", 12},{"^B", 13},{">B", 14},{" Cd", 15},{"<C" , 16},{"vC" , 17}
+ }},
+ { "Bohlen-Pierce", 13, 146.304,
+ {{"C",-10},{"Db",-9},{"D",-8},{"E",-7},{"F",-6},{"Gb",-5}
+ ,{"G",-4},{"H",-3},{"Jb",-2},{"J",-1},{"A",0},{"Bb",1},{"B",2}
+ }},
+ { "Carlos Alpha", 9, 77.9650,
+ {{"I",0},{"I#",1},{"II-",2},{"II+",3},{"III",4}
+ ,{"III#",5},{"IV-",6},{"IV+",7},{"Ib",8}
+ }},
+ { "Carlos Beta", 11, 63.8329,
+ {{"I",0},{"I#",1},{"IIb",2},{"II",3},{"II#",4},{"III",5}
+ ,{"III#",6},{"IVb",7},{"IV",8},{"IV#",9},{"Ib",10}
+ }},
+ { "Carlos Gamma", 20, 35.0985,
+ {{" I", 0},{"^I", 1},{" IIb", 2},{"^IIb", 3},{" I#", 4},{"^I#", 5}
+ ,{" II", 6},{"^II", 7}
+ ,{" III",8},{"^III",9},{" IVb",10},{"^IVb",11},{" III#",12},{"^III#",13}
+ ,{" IV",14},{"^IV",15},{" Ib", 16},{"^Ib", 17},{" IV#", 18},{"^IV#", 19}
+ }},
+};
+
+paletteDef palette[] = {
+ // 12 EDO
+ {{ {HUE_NONE, SAT_BW, VALUE_NORMAL }
+ , {HUE_PURPLE, SAT_DULL, VALUE_NORMAL }
+ , {HUE_CYAN, SAT_DULL, VALUE_NORMAL }
+ , {HUE_INDIGO, SAT_VIVID, VALUE_NORMAL }
+ }, {1,2,1,2,1,3,4,3,4,3,4,3}},
+ // 17 EDO
+ {{ {HUE_NONE, SAT_BW, VALUE_NORMAL }
+ , {HUE_INDIGO, SAT_VIVID, VALUE_NORMAL }
+ , {HUE_RED, SAT_VIVID, VALUE_NORMAL }
+ }, {1,2,3,1,2,3,1,1,2,3,1,2,3,1,2,3,1}},
+ // 19 EDO
+ {{ {HUE_NONE, SAT_BW, VALUE_NORMAL } // n
+ , {HUE_YELLOW, SAT_VIVID, VALUE_NORMAL } // #
+ , {HUE_CYAN, SAT_VIVID, VALUE_NORMAL } // b
+ , {HUE_MAGENTA, SAT_VIVID, VALUE_NORMAL } // enh
+ }, {1,2,3,1,2,3,1,4,1,2,3,1,2,3,1,2,3,1,4}},
+ // 22 EDO
+ {{ {HUE_NONE, SAT_BW, VALUE_NORMAL } // n
+ , {HUE_CYAN, SAT_VIVID, VALUE_NORMAL } // ^
+ , {HUE_MAGENTA, SAT_VIVID, VALUE_NORMAL } // mid
+ , {HUE_YELLOW, SAT_VIVID, VALUE_NORMAL } // v
+ }, {1,2,3,4,1,2,3,4,1,1,2,3,4,1,2,3,4,1,2,3,4,1}},
+ // 24 EDO
+ {{ {HUE_NONE, SAT_BW, VALUE_NORMAL } // n
+ , {HUE_GREEN, SAT_DULL, VALUE_SHADE } // +
+ , {HUE_CYAN, SAT_VIVID, VALUE_NORMAL } // #/b
+ , {HUE_BLUE, SAT_DULL, VALUE_SHADE } // d
+ , {HUE_CYAN, SAT_DULL, VALUE_SHADE } // enh
+ }, {1,2,3,4,1,2,3,4,1,5,1,2,3,4,1,2,3,4,1,2,3,4,1,5}},
+ // 31 EDO
+ {{ {HUE_NONE, SAT_BW, VALUE_NORMAL } // n
+ , {HUE_RED, SAT_DULL, VALUE_NORMAL } // +
+ , {HUE_YELLOW, SAT_DULL, VALUE_SHADE } // #
+ , {HUE_CYAN, SAT_DULL, VALUE_SHADE } // b
+ , {HUE_INDIGO, SAT_DULL, VALUE_NORMAL } // d
+ , {HUE_RED, SAT_DULL, VALUE_SHADE } // enh E+ Fb
+ , {HUE_INDIGO, SAT_DULL, VALUE_SHADE } // enh E# Fd
+ }, {1,2,3,4,5,1,2,3,4,5,1,6,7,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,6,7}},
+ // 41 EDO
+ {{ {HUE_NONE, SAT_BW, VALUE_NORMAL } // n
+ , {HUE_RED, SAT_VIVID, VALUE_NORMAL } // ^
+ , {HUE_BLUE, SAT_VIVID, VALUE_NORMAL } // +
+ , {HUE_CYAN, SAT_DULL, VALUE_SHADE } // b
+ , {HUE_GREEN, SAT_VIVID, VALUE_SHADE } // #
+ , {HUE_MAGENTA, SAT_VIVID, VALUE_NORMAL } // d
+ , {HUE_YELLOW, SAT_VIVID, VALUE_NORMAL } // v
+ }, {1,2,3,4,5,6,7,1,2,3,4,5,6,7,1,2,3,1,2,3,4,5,6,7,
+ 1,2,3,4,5,6,7,1,2,3,4,5,6,7,1,6,7}},
+ // 53 EDO
+ {{ {HUE_NONE, SAT_BW, VALUE_NORMAL } // n
+ , {HUE_ORANGE, SAT_DULL, VALUE_NORMAL } // ^
+ , {HUE_MAGENTA, SAT_DULL, VALUE_NORMAL } // L
+ , {HUE_INDIGO, SAT_VIVID, VALUE_NORMAL } // bv
+ , {HUE_GREEN, SAT_VIVID, VALUE_NORMAL } // b
+ , {HUE_YELLOW, SAT_VIVID, VALUE_NORMAL } // #
+ , {HUE_RED, SAT_VIVID, VALUE_NORMAL } // #^
+ , {HUE_PURPLE, SAT_DULL, VALUE_NORMAL } // 7
+ , {HUE_CYAN, SAT_DULL, VALUE_NORMAL } // v
+ }, {1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9,1,2,3,9,1,2,3,4,5,6,7,8,9,
+ 1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9,1,2,3,9}},
+ // 72 EDO
+ {{ {HUE_NONE, SAT_BW, VALUE_NORMAL } // n
+ , {HUE_GREEN, SAT_DULL, VALUE_SHADE } // ^
+ , {HUE_RED, SAT_DULL, VALUE_SHADE } // L
+ , {HUE_PURPLE, SAT_DULL, VALUE_SHADE } // +/d
+ , {HUE_BLUE, SAT_DULL, VALUE_SHADE } // 7
+ , {HUE_YELLOW, SAT_DULL, VALUE_SHADE } // v
+ , {HUE_INDIGO, SAT_VIVID, VALUE_NORMAL } // #/b
+ }, {1,2,3,4,5,6,7,2,3,4,5,6,1,2,3,4,5,6,7,2,3,4,5,6,1,2,3,4,5,6,1,2,3,4,5,6,
+ 7,2,3,4,5,6,1,2,3,4,5,6,7,2,3,4,5,6,1,2,3,4,5,6,7,2,3,4,5,6,1,2,3,4,5,6}},
+ // BOHLEN PIERCE
+ {{ {HUE_NONE, SAT_BW, VALUE_NORMAL }
+ , {HUE_INDIGO, SAT_VIVID, VALUE_NORMAL }
+ , {HUE_RED, SAT_VIVID, VALUE_NORMAL }
+ }, {1,2,3,1,2,3,1,1,2,3,1,2,3}},
+ // ALPHA
+ {{ {HUE_NONE, SAT_BW, VALUE_NORMAL } // n
+ , {HUE_YELLOW, SAT_VIVID, VALUE_NORMAL } // #
+ , {HUE_INDIGO, SAT_VIVID, VALUE_NORMAL } // d
+ , {HUE_LIME, SAT_VIVID, VALUE_NORMAL } // +
+ , {HUE_RED, SAT_VIVID, VALUE_NORMAL } // enharmonic
+ , {HUE_CYAN, SAT_VIVID, VALUE_NORMAL } // b
+ }, {1,2,3,4,1,2,3,5,6}},
+ // BETA
+ {{ {HUE_NONE, SAT_BW, VALUE_NORMAL } // n
+ , {HUE_INDIGO, SAT_VIVID, VALUE_NORMAL } // #
+ , {HUE_RED, SAT_VIVID, VALUE_NORMAL } // b
+ , {HUE_MAGENTA, SAT_DULL, VALUE_NORMAL } // enharmonic
+ }, {1,2,3,1,4,1,2,3,1,2,3}},
+ // GAMMA
+ {{ {HUE_NONE, SAT_BW, VALUE_NORMAL } // n
+ , {HUE_RED, SAT_VIVID, VALUE_NORMAL } // b
+ , {HUE_BLUE, SAT_VIVID, VALUE_NORMAL } // #
+ , {HUE_YELLOW, SAT_VIVID, VALUE_NORMAL } // n^
+ , {HUE_PURPLE, SAT_VIVID, VALUE_NORMAL } // b^
+ , {HUE_GREEN, SAT_VIVID, VALUE_NORMAL } // #^
+ }, {1,4,2,5,3,6,1,4,1,4,2,5,3,6,1,4,2,5,3,6}},
+};
+
+layoutDef layoutOptions[] = {
+ { "Wicki-Hayden", 1, 64, 2, -7, TUNING_12EDO },
+ { "Harmonic Table", 0, 75, -7, 3, TUNING_12EDO },
+ { "Janko", 0, 65, -1, -1, TUNING_12EDO },
+ { "Gerhard", 0, 65, -1, -3, TUNING_12EDO },
+ { "Accordion C-sys.", 1, 75, 2, -3, TUNING_12EDO },
+ { "Accordion B-sys.", 1, 64, 1, -3, TUNING_12EDO },
+ { "Full Gamut", 1, 65, -1, -9, TUNING_12EDO },
+ { "Bosanquet-Wilson", 0, 65, -2, -1, TUNING_17EDO },
+ { "Neutral Thirds A", 0, 65, -1, -2, TUNING_17EDO },
+ { "Neutral Thirds B", 0, 65, 1, -3, TUNING_17EDO },
+ { "Full Gamut", 1, 65, -1, -9, TUNING_17EDO },
+ { "Bosanquet-Wilson", 0, 65, -1, -2, TUNING_19EDO },
+ { "Kleismic", 0, 65, -1, -4, TUNING_19EDO },
+ { "Full Gamut", 1, 65, -1, -9, TUNING_19EDO },
+ { "Bosanquet-Wilson", 0, 65, -3, -1, TUNING_22EDO },
+ { "Porcupine", 0, 65, 1, -4, TUNING_22EDO },
+ { "Full Gamut", 1, 65, 1, -8, TUNING_22EDO },
+ { "Bosanquet-Wilson", 0, 65, -1, -3, TUNING_24EDO },
+ { "Inverted", 0, 65, 1, -4, TUNING_24EDO },
+ { "Full Gamut", 1, 65, -1, -9, TUNING_24EDO },
+ { "Bosanquet-Wilson", 0, 65, -2, -3, TUNING_31EDO },
+ { "Double Bosanquet", 0, 65, -1, -4, TUNING_31EDO },
+ { "Anti-Double Bos.", 0, 65, 1, -5, TUNING_31EDO },
+ { "Full Gamut", 1, 65, -1, -7, TUNING_31EDO },
+ { "Bosanquet-Wilson", 0, 65, -4, -3, TUNING_41EDO }, // forty-one #1
+ { "Gerhard", 0, 65, 3, -10, TUNING_41EDO }, // forty-one #2
+ { "Baldy", 0, 65, -1, -6, TUNING_41EDO },
+ { "Rodan", 1, 65, -1, -7, TUNING_41EDO },
+ { "Full Gamut", 0, 65, -1, -8, TUNING_41EDO }, // forty-one #3
+ { "Bosanquet-Wilson", 0, 65, -5, -4, TUNING_53EDO },
+ { "Kleismic A", 0, 65, -8, -3, TUNING_53EDO },
+ { "Kleismic B", 0, 65, -5, -3, TUNING_53EDO },
+ { "Wicki-Hayden", 1, 64, 9, -31, TUNING_53EDO },
+ { "Harmonic Table", 0, 75, -31, 14, TUNING_53EDO },
+ { "Buzzard", 0, 65, -9, -1, TUNING_53EDO },
+ { "Expanded Janko", 0, 65, -1, -6, TUNING_72EDO },
+ { "Full Gamut", 1, 65, -1, -9, TUNING_72EDO },
+ { "Standard", 0, 65, -2, -1, TUNING_BP },
+ { "Full Gamut", 1, 65, -1, -9, TUNING_BP },
+ { "Compressed", 0, 65, -2, -1, TUNING_ALPHA },
+ { "Full Gamut", 1, 65, -1, -9, TUNING_ALPHA },
+ { "Compressed", 0, 65, -2, -1, TUNING_BETA },
+ { "Full Gamut", 1, 65, -1, -9, TUNING_BETA },
+ { "Compressed", 0, 65, -2, -1, TUNING_GAMMA },
+ { "Full Gamut", 1, 65, -1, -9, TUNING_GAMMA }
+};
+
+scaleDef scaleOptions[] = {
+ { "None", ALL_TUNINGS, { 0 } },
+ // 12 EDO
+ { "Major", TUNING_12EDO, { 2,2,1,2,2,2,1 } },
+ { "Minor, natural", TUNING_12EDO, { 2,1,2,2,1,2,2 } },
+ { "Minor, melodic", TUNING_12EDO, { 2,1,2,2,2,2,1 } },
+ { "Minor, harmonic", TUNING_12EDO, { 2,1,2,2,1,3,1 } },
+ { "Pentatonic, major", TUNING_12EDO, { 2,2,3,2,3 } },
+ { "Pentatonic, minor", TUNING_12EDO, { 3,2,2,3,2 } },
+ { "Blues", TUNING_12EDO, { 3,1,1,1,1,3,2 } },
+ { "Double Harmonic", TUNING_12EDO, { 1,3,1,2,1,3,1 } },
+ { "Phrygian", TUNING_12EDO, { 1,2,2,2,1,2,2 } },
+ { "Phrygian Dominant", TUNING_12EDO, { 1,3,1,2,1,2,2 } },
+ { "Dorian", TUNING_12EDO, { 2,1,2,2,2,1,2 } },
+ { "Lydian", TUNING_12EDO, { 2,2,2,1,2,2,1 } },
+ { "Lydian Dominant", TUNING_12EDO, { 2,2,2,1,2,1,2 } },
+ { "Mixolydian", TUNING_12EDO, { 2,2,1,2,2,1,2 } },
+ { "Locrian", TUNING_12EDO, { 1,2,2,1,2,2,2 } },
+ { "Whole tone", TUNING_12EDO, { 2,2,2,2,2,2 } },
+ { "Octatonic", TUNING_12EDO, { 2,1,2,1,2,1,2,1 } },
+ // 17 EDO; for more: https://en.xen.wiki/w/17edo#Scales
+ { "Diatonic", TUNING_17EDO, { 3,3,1,3,3,3,1 } },
+ { "Pentatonic", TUNING_17EDO, { 3,3,4,3,4 } },
+ { "Harmonic", TUNING_17EDO, { 3,2,3,2,2,2,3 } },
+ { "Husayni maqam", TUNING_17EDO, { 2,2,3,3,2,1,1,3 } },
+ { "Blues", TUNING_17EDO, { 4,3,1,1,1,4,3 } },
+ { "Hydra", TUNING_17EDO, { 3,3,1,1,2,3,2,1,1 } },
+ // 19 EDO; for more: https://en.xen.wiki/w/19edo#Scales
+ { "Diatonic", TUNING_19EDO, { 3,3,2,3,3,3,2 } },
+ { "Pentatonic", TUNING_19EDO, { 3,3,5,3,5 } },
+ { "Semaphore", TUNING_19EDO, { 3,1,3,1,3,3,1,3,1 } },
+ { "Negri", TUNING_19EDO, { 2,2,2,2,2,1,2,2,2,2 } },
+ { "Sensi", TUNING_19EDO, { 2,2,1,2,2,2,1,2,2,2,1 } },
+ { "Kleismic", TUNING_19EDO, { 1,3,1,1,3,1,1,3,1,3,1 } },
+ { "Magic", TUNING_19EDO, { 3,1,1,1,3,1,1,1,3,1,1,1,1 } },
+ { "Kind of blues", TUNING_19EDO, { 4,4,1,2,4,4 } },
+ // 22 EDO; for more: https://en.xen.wiki/w/22edo_modes
+ { "Diatonic", TUNING_22EDO, { 4,4,1,4,4,4,1 } },
+ { "Pentatonic", TUNING_22EDO, { 4,4,5,4,5 } },
+ { "Orwell", TUNING_22EDO, { 3,2,3,2,3,2,3,2,2 } },
+ { "Porcupine", TUNING_22EDO, { 4,3,3,3,3,3,3 } },
+ { "Pajara", TUNING_22EDO, { 2,2,3,2,2,2,3,2,2,2 } },
+ // 24 EDO; for more: https://en.xen.wiki/w/24edo_scales
+ { "Diatonic 12", TUNING_24EDO, { 4,4,2,4,4,4,2 } },
+ { "Diatonic Soft", TUNING_24EDO, { 3,5,2,3,5,4,2 } },
+ { "Diatonic Neutral", TUNING_24EDO, { 4,3,3,4,3,4,3 } },
+ { "Pentatonic (12)", TUNING_24EDO, { 4,4,6,4,6 } },
+ { "Pentatonic (Hába)", TUNING_24EDO, { 5,5,5,5,4 } },
+ { "Invert Pentatonic", TUNING_24EDO, { 6,3,6,6,3 } },
+ { "Rast maqam", TUNING_24EDO, { 4,3,3,4,4,2,1,3 } },
+ { "Bayati maqam", TUNING_24EDO, { 3,3,4,4,2,1,3,4 } },
+ { "Hijaz maqam", TUNING_24EDO, { 2,6,2,4,2,1,3,4 } },
+ { "8-EDO", TUNING_24EDO, { 3,3,3,3,3,3,3,3 } },
+ { "Wyschnegradsky", TUNING_24EDO, { 2,2,2,2,2,1,2,2,2,2,2,2,1 } },
+ // 31 EDO; for more: https://en.xen.wiki/w/31edo#Scales
+ { "Diatonic", TUNING_31EDO, { 5,5,3,5,5,5,3 } },
+ { "Pentatonic", TUNING_31EDO, { 5,5,8,5,8 } },
+ { "Harmonic", TUNING_31EDO, { 5,5,4,4,4,3,3,3 } },
+ { "Mavila", TUNING_31EDO, { 5,3,3,3,5,3,3,3,3 } },
+ { "Quartal", TUNING_31EDO, { 2,2,7,2,2,7,2,7 } },
+ { "Orwell", TUNING_31EDO, { 4,3,4,3,4,3,4,3,3 } },
+ { "Neutral", TUNING_31EDO, { 4,4,4,4,4,4,4,3 } },
+ { "Miracle", TUNING_31EDO, { 4,3,3,3,3,3,3,3,3,3 } },
+ // 41 EDO; for more: https://en.xen.wiki/w/41edo#Scales_and_modes
+ { "Diatonic", TUNING_41EDO, { 7,7,3,7,7,7,3 } },
+ { "Pentatonic", TUNING_41EDO, { 7,7,10,7,10 } },
+ { "Pure major", TUNING_41EDO, { 7,6,4,7,6,7,4 } },
+ { "5-limit chromatic", TUNING_41EDO, { 4,3,4,2,4,3,4,4,2,4,3,4 } },
+ { "7-limit chromatic", TUNING_41EDO, { 3,4,2,4,4,3,4,2,4,3,3,4 } },
+ { "Harmonic", TUNING_41EDO, { 5,4,4,4,4,3,3,3,3,3,2,3 } },
+ { "Middle East-ish", TUNING_41EDO, { 7,5,7,5,5,7,5 } },
+ { "Thai", TUNING_41EDO, { 6,6,6,6,6,6,5 } },
+ { "Slendro", TUNING_41EDO, { 8,8,8,8,9 } },
+ { "Pelog / Mavila", TUNING_41EDO, { 8,5,5,8,5,5,5 } },
+ // 53 EDO
+ { "Diatonic", TUNING_53EDO, { 9,9,4,9,9,9,4 } },
+ { "Pentatonic", TUNING_53EDO, { 9,9,13,9,13 } },
+ { "Rast makam", TUNING_53EDO, { 9,8,5,9,9,4,4,5 } },
+ // 72 EDO
+ { "Diatonic", TUNING_72EDO, { 12,12,6,12,12,12,6 } },
+ { "Pentatonic", TUNING_72EDO, { 12,12,18,12,18 } },
+ // BP
+ // Alpha
+ // Beta
+ // Gamma
+};