ESP32 Chord Synthesizer

#include <Arduino.h>
#include <Wire.h>
#include <driver/uart.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

constexpr int OLED_SDA_PIN = 21;
constexpr int OLED_SCL_PIN = 22;
constexpr int ENCODER_CLK_PIN = 32;
constexpr int ENCODER_DT_PIN = 33;
constexpr int ENCODER_SW_PIN = 4;
constexpr int CHORD_C_PIN = 13;
constexpr int CHORD_D_PIN = 14;
constexpr int CHORD_E_PIN = 16;
constexpr int CHORD_F_PIN = 17;
constexpr int CHORD_G_PIN = 25;
constexpr int CHORD_A_PIN = 26;
constexpr int CHORD_B_PIN = 27;
constexpr int MIDI_TX_PIN = 18;

constexpr uint8_t MIDI_CHANNEL = 0; // MIDI channel 1
constexpr uint8_t VELOCITY = 100;
constexpr uint8_t BASE_NOTE = 60;   // C4
constexpr uint32_t DEBOUNCE_MS = 18;

Adafruit_SSD1306 display(128, 64, &Wire, -1);
HardwareSerial MidiSerial(2);

const uint8_t chordPins[7] = {
  CHORD_C_PIN, CHORD_D_PIN, CHORD_E_PIN, CHORD_F_PIN,
  CHORD_G_PIN, CHORD_A_PIN, CHORD_B_PIN
};
const int8_t degreeSemitones[7] = {0, 2, 4, 5, 7, 9, 11};
const char* degreeNames[7] = {"I", "ii", "iii", "IV", "V", "vi", "vii"};
const char* keyNames[12] = {"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"};
const char* qualityNames[3] = {"Major", "Minor", "7th"};

bool stablePressed[7] = {false, false, false, false, false, false, false};
bool rawPressed[7] = {false, false, false, false, false, false, false};
uint32_t lastButtonChange[7] = {0, 0, 0, 0, 0, 0, 0};
int keyOffset = 0;
uint8_t quality = 0;
int lastEncoderClk = HIGH;
bool lastEncoderButton = HIGH;
uint32_t lastEncoderButtonChange = 0;
bool screenDirty = true;

void sendMidi(uint8_t status, uint8_t data1, uint8_t data2) {
  MidiSerial.write(status);
  MidiSerial.write(data1);
  MidiSerial.write(data2);
}

uint8_t chordRoot(uint8_t degree) {
  return BASE_NOTE + keyOffset + degreeSemitones[degree];
}

void sendChord(uint8_t degree, bool noteOn) {
  const uint8_t root = chordRoot(degree);
  int8_t intervals[4] = {0, 4, 7, -1};
  uint8_t count = 3;

  if (quality == 1) {
    intervals[1] = 3;
  } else if (quality == 2) {
    intervals[3] = 10;
    count = 4;
  }

  const uint8_t status = (noteOn ? 0x90 : 0x80) | MIDI_CHANNEL;
  const uint8_t velocity = noteOn ? VELOCITY : 0;
  for (uint8_t i = 0; i < count; ++i) {
    sendMidi(status, root + intervals[i], velocity);
  }
}

void stopAllNotes() {
  sendMidi(0xB0 | MIDI_CHANNEL, 123, 0);
}

void drawScreen() {
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);
  display.setTextSize(1);
  display.setCursor(0, 0);
  display.println(F("HiChord Lite"));
  display.drawFastHLine(0, 11, 128, SSD1306_WHITE);

  display.setTextSize(2);
  display.setCursor(0, 18);
  display.print(keyNames[keyOffset]);
  display.setTextSize(1);
  display.setCursor(42, 24);
  display.print(qualityNames[quality]);

  display.setCursor(0, 47);
  display.print(F("Hold a chord button"));
  display.setCursor(0, 56);
  display.print(F("Knob: key  Press: type"));
  display.display();
  screenDirty = false;
}

void readEncoder() {
  const int encoderClk = digitalRead(ENCODER_CLK_PIN);
  if (encoderClk != lastEncoderClk && encoderClk == LOW) {
    if (digitalRead(ENCODER_DT_PIN) != encoderClk) {
      keyOffset = (keyOffset + 1) % 12;
    } else {
      keyOffset = (keyOffset + 11) % 12;
    }
    stopAllNotes();
    screenDirty = true;
  }
  lastEncoderClk = encoderClk;

  const bool encoderButton = digitalRead(ENCODER_SW_PIN);
  if (encoderButton != lastEncoderButton) {
    lastEncoderButtonChange = millis();
    lastEncoderButton = encoderButton;
  }
  if (!encoderButton && (millis() - lastEncoderButtonChange) == DEBOUNCE_MS) {
    quality = (quality + 1) % 3;
    stopAllNotes();
    screenDirty = true;
  }
}

void readChordButtons() {
  const uint32_t now = millis();
  for (uint8_t i = 0; i < 7; ++i) {
    const bool sample = digitalRead(chordPins[i]) == LOW;
    if (sample != rawPressed[i]) {
      rawPressed[i] = sample;
      lastButtonChange[i] = now;
    }
    if (sample != stablePressed[i] && now - lastButtonChange[i] >= DEBOUNCE_MS) {
      stablePressed[i] = sample;
      sendChord(i, sample);
      screenDirty = true;
    }
  }
}

void setup() {
  for (uint8_t i = 0; i < 7; ++i) {
    pinMode(chordPins[i], INPUT_PULLUP);
  }
  pinMode(ENCODER_CLK_PIN, INPUT_PULLUP);
  pinMode(ENCODER_DT_PIN, INPUT_PULLUP);
  pinMode(ENCODER_SW_PIN, INPUT_PULLUP);
  lastEncoderClk = digitalRead(ENCODER_CLK_PIN);

  // The NPN MIDI circuit inverts the electrical signal, so invert UART TX too.
  MidiSerial.begin(31250, SERIAL_8N1, -1, MIDI_TX_PIN);
  uart_set_line_inverse(UART_NUM_2, UART_SIGNAL_TXD_INV);

  Wire.begin(OLED_SDA_PIN, OLED_SCL_PIN);
  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    while (true) {
      delay(1000);
    }
  }
  drawScreen();
}

void loop() {
  readEncoder();
  readChordButtons();
  if (screenDirty) {
    drawScreen();
  }
  delay(2);
}