// Patches needed for U8G2, Rotary.h

// ==============================================================================

// list of things remaining to do:

// -- save and load presets

// -- sequencer restore

// ==============================================================================

#include <Arduino.h>

#include <Wire.h>

#include <LittleFS.h>

#include <queue> // std::queue construct to store open channels in microtonal mode

// ====== initialize timers

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

// ====== initialize SDA and SCL pins for hardware I/O

// ====== initialize MIDI

#include <Adafruit_TinyUSB.h>

#include <MIDI.h>

Adafruit_USBD_MIDI usb_midi;

MIDI_CREATE_INSTANCE(Adafruit_USBD_MIDI, usb_midi, MIDI);

// if one then on certain synths that are MPE compatible will send in that mode.

int16_t channelBend[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; // what's the current note bend on this channel

byte channelPoly[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; // how many notes are playing on this channel

std::queue<byte> openChannelQueue;

// ====== initialize LEDs

#include <Adafruit_NeoPixel.h>

const byte multiplexPins[] = { 4, 5, 2, 3 }; // m1p, m2p, m4p, m8p

const byte columnPins[] = { 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };

enum { NoAnim, StarAnim, SplashAnim, OrbitAnim, OctaveAnim, NoteAnim };

byte animationType = 0;

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.

// ====== initialize hex state object

enum { Right, UpRight, UpLeft, Left, DnLeft, DnRight };

typedef struct {

int8_t row;

int8_t col;

typedef struct {

byte keyState = 0; // binary 00 = off, 01 = just pressed, 10 = just released, 11 = held

coordinates coords = {0,0};

uint32_t timePressed = 0; // timecode of last press

bool animate = 0; // hex is flagged as part of the animation in this frame

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

timePressed = millis(); // log the time

};

};

if (timePressed) { // 2^10 milliseconds is close enough to 1 second

return 1 + (((runTime - timePressed) * animationFPS) >> 10);

} else {

};

};

} buttonDef;

const byte assignCmd[] = { 0, 20, 40, 60, 80, 100, 120 };

const byte cmdCount = 7;

const byte cmdCode = 192;

// ====== initialize wheel emulation

typedef struct {

byte* topBtn;

byte* midBtn;

int16_t temp = curValue;

if (*topBtn == 1) {temp += stepValue;};

if (*botBtn == 1) {temp -= stepValue;};

else if (temp <= minValue) {temp = minValue;};

targetValue = temp;

} else {

} else {

return 0;

};

} wheelDef;

wheelDef modWheel = {

&h[assignCmd[4]].keyState,

&h[assignCmd[6]].keyState,

0, 127, 8,

0, 0, 0

wheelDef pbWheel = {

&h[assignCmd[4]].keyState,

&h[assignCmd[5]].keyState,

&h[assignCmd[0]].keyState,

&h[assignCmd[1]].keyState,

&h[assignCmd[2]].keyState,

96, 96, 96

};

bool toggleWheel = 0; // 0 for mod, 1 for pb

// ====== initialize rotary knob

#include <Rotary.h>

Rotary rotary = Rotary(rotaryPinA, rotaryPinB);

bool rotaryIsClicked = HIGH; //

bool rotaryWasClicked = HIGH; //

int8_t rotaryKnobTurns = 0; //

// ====== initialize GFX display

#include <GEM_u8g2.h>

#define GEM_DISABLE_GLCD

U8G2_SH1107_SEEED_128X128_F_HW_I2C u8g2(U8G2_R2, U8X8_PIN_NONE);

const byte defaultContrast = 63; // GFX default contrast

bool screenSaverOn = 0; //

uint32_t screenTime = 0; // GFX timer to count if screensaver should go on

// ====== initialize piezo buzzer

uint32_t currentBuzzTime = 0; // Used to keep track of when this note started buzzin

// ====== initialize tuning (microtonal) presets

float stepSize; // in cents, 100 = "normal" semitone.

} tuningDef;

enum {

CarlosA, CarlosB, CarlosG

};

tuningDef tuningOptions[] = {

byte step[16]; // 16 bytes = 128 bits, 1 = in scale; 0 = not

} scaleDef;

scaleDef scaleOptions[] = {

{ (char*)"Rast maqam", TwentyFour, { 0b10001001, 0b00100010, 0b00101100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },

{ (char*)"Rast makam", FiftyThree, { 0b10000000, 0b01000000, 0b01000010, 0b00000001,

};

const byte scaleCount = sizeof(scaleOptions) / sizeof(scaleDef);

byte scaleLock = 0; // menu wants this to be an int, not a bool

// ====== initialize key coloring routines

enum colors { W, R, O, Y, L, G, C, B, I, P, M,

enum { DARK = 0, VeryDIM = 1, DIM = 32, BRIGHT = 127, VeryBRIGHT = 255 };

enum { GRAY = 0, DULL = 127, VIVID = 255 };

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 };

DULL, DULL, DULL, DULL, DULL, DULL, DULL, DULL, DULL, DULL };

byte perceptual = 1;

// ====== initialize note labels in each tuning, also used for key signature

typedef struct {

char* name;

byte tuning;

colors tierColor;

} keyDef;

keyDef keyOptions[] = {

// ====== initialize structure to store and recall user preferences

typedef struct { // put all user-selectable options into a class so that down the line these can be saved and loaded.

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;

};

} presetDef;

presetDef current = {

Twelve, // see the relevant enum{} statement

0, // default to the first layout, wicki hayden

0, // default to using no scale (chromatic)

0 // default to no transposition

};

// ====== functions

int positiveMod(int n, int d) {

return (((n % d) + d) % d);

}

return temp;

}

bool hexOOB(coordinates c) {

|| ((c.col + c.row) & 1);

}

byte coordToIndex(coordinates c) {

coordinates hexVector(byte direction, byte distance) {

coordinates temp;

int8_t vertical[] = {0,-1,-1, 0, 1,1};

temp.row = vertical[direction] * distance;

temp.col = horizontal[direction] * distance;

return temp;

if ((!perceptual) || (D > 360.0)) {

return 65536 * (D / 360.0);

} else {

int hueIn[] = { 0, 9, 18, 90, 108, 126, 135, 150, 198, 243, 252, 261, 306, 333, 360};

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) {

float hueDegrees;

byte sat;

colors c;

if (!(h[i].isCmd)) {

byte scaleDegree = positiveMod(h[i].steps + current.key().offset - current.findC(),current.tuning().cycleLength);

switch (colorMode) {

void assignPitches() { // run this if the layout, key, or transposition changes, but not if color or scale changes

sendToLog("assignPitch was called:");

if (!(h[i].isCmd)) {

float N = stepsToMIDI(h[i].steps + current.key().offset + current.transpose);

if (N < 0 || N >= 128) {

"hex #" + String(i) + ", " +

"steps=" + String(h[i].steps) + ", " +

"isCmd? " + String(h[i].isCmd) + ", " +

"inScale? " + String(h[i].inScale) + "."

));

};

}

void applyScale() {

sendToLog("applyScale was called:");

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;

sendToLog(String(

"hex #" + String(i) + ", " +

"steps=" + String(h[i].steps) + ", " +

"isCmd? " + String(h[i].isCmd) + ", " +

"inScale? " + String(h[i].inScale) + "."

));

};

}

void applyLayout() { // call this function when the layout changes

sendToLog("buildLayout was called:");

if (!(h[i].isCmd)) {

coordinates dist = hexDistance(h[current.layout().rootHex].coords, h[i].coords);

h[i].steps = (

(dist.row * (

(2 * current.layout().dnLeftSteps)

))

) / 2;

}

// ====== buzzer routines

byte nextHeldNote() {

byte n = 255;

break;

};

};

return n;

}

};

}

// ====== MIDI routines

void setPitchBendRange(byte Ch, byte semitones) {

}

void setMPEzone(byte masterCh, byte sizeOfZone) {

}

void prepMIDIforMicrotones() {

bool makeZone = (MPE && (current.tuningIndex != Twelve)); // if MPE flag is on and tuning <> 12EDO

};

}

void chgModulation() {

};

};

void chgUniversalPB() {

};

};

}

byte assignChannel(byte x) {

if (current.tuningIndex == Twelve) {

return 1;

if (c <= 16) {

h[x].channel = c; // value is 1 - 16

if (current.tuningIndex != Twelve) {

channelPoly[c - 1]++; // array is 0 - 15

};

};

}

byte c = h[x].channel;

if (c) {

h[x].channel = 0;

if (current.tuningIndex != Twelve) {

switch (channelPoly[c - 1]) {

case 1:

break;

};

};

};

};

}

};

}

void animateMirror() {

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

h[j].animate = 1;

};

};

};

};

}

void animateOrbit() {

};

};

}

void animateRadial() {

uint32_t radius = h[i].animFrame();

};

};

};

}

// ====== menu variables and routines

// must declare these variables globally for some reason

// doing so down here so we don't have to forward declare callback functions

//

GEMPage menuPageMain("HexBoard MIDI Controller");

GEMItem* menuItemTuning[tuningCount]; // dynamically generate item based on tunings

GEMPage menuPageLayout("Layout");

GEMItem* menuItemLayout[layoutCount]; // dynamically generate item based on presets

GEMPage menuPageScales("Scales");

GEMItem* menuItemScales[scaleCount]; // dynamically generate item based on presets and if allowed in given EDO tuning

GEMPage menuPageKeys("Keys");

GEMItem* menuItemKeys[keyCount]; // dynamically generate item based on presets

GEMItem menuItemScaleLock( "Scale lock?", scaleLock, selectYesOrNo);

GEMItem menuItemAnimate( "Animation:", animationType, selectAnimate);

void menuHome() {

menu.setMenuPageCurrent(menuPageMain);

menuPageMain.addMenuItem(menuItemScaleLock);

menuPageMain.addMenuItem(menuItemColor);

menuPageMain.addMenuItem(menuItemAnimate);

menuPageMain.addMenuItem(menuItemPercep);

}

{

pinMode(multiplexPins[p], OUTPUT); // Setting the row multiplexer pins to output.

}

pinMode(rotaryPinC, INPUT_PULLUP);

}

void setupGrid() {

sendToLog(String("initializing hex grid..."));

h[i].coords = indexToCoord(i);

h[i].isCmd = 0;

h[i].note = 255;

void testDiagnostics() {

sendToLog(String("theHDM was here"));

}

// ====== loop routines

}

}

void readHexes() {

for (byte d = 0; d < 4; d++) {

digitalWrite(multiplexPins[d], (r >> d) & 1);

}

byte p = columnPins[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).

bool didYouPressHex = (digitalRead(p) == LOW); // hex is pressed if it returns LOW. else not pressed

pinMode(p, INPUT); // Set the selected column pin back to INPUT mode (0V / LOW).

}

}

}

switch (h[i].keyState) {

case 1: // just pressed

if (h[i].isCmd) {

};

}

void arpeggiate() {

if (runTime - currentBuzzTime > arpeggiateLength) {

currentBuzzTime = millis();

};

};

};

}

velWheel.setTargetValue();

if (upd) {

sendToLog(String("vel became " + String(velWheel.curValue)));

}

if (toggleWheel) {

pbWheel.setTargetValue();

upd = pbWheel.updateValue();

if (upd) {

chgUniversalPB();

};

} else {

};

};

}

h[i].animate = 0;

};

if (animationType) {

case StarAnim: case SplashAnim:

animateRadial();

break;

break;

case OctaveAnim: case NoteAnim:

animateMirror();

default:

break;

};

};

}

if (!(h[i].isCmd)) {

if (h[i].animate) {

strip.setPixelColor(i,h[i].LEDcolorAnim);

0,0,64

)));

strip.setPixelColor(assignCmd[4],strip.gamma32(strip.ColorHSV(

)));

strip.setPixelColor(assignCmd[5],strip.gamma32(strip.ColorHSV(

hueP,satP,255

)));

strip.setPixelColor(assignCmd[6],strip.gamma32(strip.ColorHSV(

)));

} else {

// mod blue / yellow

hueM,satM,((modWheel.curValue > 63) ? satM : 0)

)));

strip.setPixelColor(assignCmd[5],strip.gamma32(strip.ColorHSV(

)));

strip.setPixelColor(assignCmd[6],strip.gamma32(strip.ColorHSV(

hueM,satM,127 + (satM / 2)

rotaryWasClicked = rotaryIsClicked;

if (rotaryKnobTurns != 0) {

for (byte i = 0; i < abs(rotaryKnobTurns); i++) {

}

rotaryKnobTurns = 0;

screenTime = 0;

rotaryKnobTurns--;

break;

}

}

// ====== setup() and loop()

void setup() {

setupMIDI();

setupFileSystem();

setupPins();

setupGrid();

setupLEDs();

setupGFX();

for (byte i = 0; i < 5 && !TinyUSBDevice.mounted(); i++) {

delay(1); // wait until device mounted, maybe

};

}

};

void loop() { // run on first core

timeTracker(); // Time tracking functions

}

void loop1() { // run on second core

keepTrackOfRotaryKnobTurns();