Linux Audio Mixer Controller

#include <Arduino.h>
#include "USB.h"
#include "USBMIDI.h"
#include "USBHIDConsumerControl.h"

// Forward declarations
uint8_t rawToMidi(int raw);
void tapConsumerKey(uint16_t key);
void sendFaderIfMoved(uint8_t index);
void readMasterEncoder();
void readMasterButton();
void readMediaEncoder();
void readMediaButton();
void readSinkMuteButtons();

USBMIDI MIDI;
USBHIDConsumerControl ConsumerControl;

constexpr uint8_t MIDI_CHANNEL = 1;
constexpr uint8_t FADER_CC[4] = {16, 17, 18, 19};
constexpr uint8_t MASTER_CC = 7;
constexpr uint8_t MUTE_CC = 20;
constexpr uint8_t SINK_MUTE_CC[4] = {21, 22, 23, 24};

constexpr uint8_t FADER_PINS[4] = {1, 2, 3, 4};
constexpr uint8_t SINK_MUTE_BUTTON_PINS[4] = {5, 6, 7, 8};
constexpr uint8_t SINK_MUTE_LED_PINS[4] = {9, 10, 11, 12};
constexpr uint8_t ENCODER_CLK_PIN = 14;
constexpr uint8_t ENCODER_DT_PIN = 21;
constexpr uint8_t ENCODER_SW_PIN = 38;
constexpr uint8_t MEDIA_ENCODER_CLK_PIN = 39;
constexpr uint8_t MEDIA_ENCODER_DT_PIN = 40;
constexpr uint8_t MEDIA_ENCODER_SW_PIN = 41;

constexpr int ADC_MIN = 40;
constexpr int ADC_MAX = 4055;
constexpr int FADER_SEND_DEADBAND = 14;
constexpr unsigned long FADER_INTERVAL_MS = 8;
constexpr unsigned long BUTTON_DEBOUNCE_MS = 25;

int lastSentRaw[4] = {-10000, -10000, -10000, -10000};
uint8_t masterValue = 100;
int lastMasterClock = HIGH;
int lastMasterButtonReading = HIGH;
int stableMasterButtonState = HIGH;
unsigned long lastMasterButtonChangeMs = 0;
int lastMediaClock = HIGH;
int lastMediaButtonReading = HIGH;
int stableMediaButtonState = HIGH;
unsigned long lastMediaButtonChangeMs = 0;
int lastSinkMuteButtonReading[4] = {HIGH, HIGH, HIGH, HIGH};
int stableSinkMuteButtonState[4] = {HIGH, HIGH, HIGH, HIGH};
unsigned long lastSinkMuteButtonChangeMs[4] = {0, 0, 0, 0};
bool sinkMuted[4] = {false, false, false, false};
unsigned long lastFaderReadMs = 0;

uint8_t rawToMidi(int raw) {
  return static_cast<uint8_t>(constrain(map(raw, ADC_MIN, ADC_MAX, 0, 127), 0, 127));
}

void tapConsumerKey(uint16_t key) {
  ConsumerControl.press(key);
  ConsumerControl.release();
}

void sendFaderIfMoved(uint8_t index) {
  const int raw = analogRead(FADER_PINS[index]);
  if (abs(raw - lastSentRaw[index]) >= FADER_SEND_DEADBAND) {
    lastSentRaw[index] = raw;
    MIDI.controlChange(FADER_CC[index], rawToMidi(raw), MIDI_CHANNEL);
  }
}

void readMasterEncoder() {
  const int clockNow = digitalRead(ENCODER_CLK_PIN);
  if (clockNow != lastMasterClock && clockNow == LOW) {
    if (digitalRead(ENCODER_DT_PIN) != clockNow) {
      if (masterValue < 127) ++masterValue;
    } else if (masterValue > 0) {
      --masterValue;
    }
    MIDI.controlChange(MASTER_CC, masterValue, MIDI_CHANNEL);
  }
  lastMasterClock = clockNow;
}

void readMasterButton() {
  const int reading = digitalRead(ENCODER_SW_PIN);
  if (reading != lastMasterButtonReading) lastMasterButtonChangeMs = millis();
  if (millis() - lastMasterButtonChangeMs >= BUTTON_DEBOUNCE_MS && reading != stableMasterButtonState) {
    stableMasterButtonState = reading;
    MIDI.controlChange(MUTE_CC, stableMasterButtonState == LOW ? 127 : 0, MIDI_CHANNEL);
  }
  lastMasterButtonReading = reading;
}

void readMediaEncoder() {
  const int clockNow = digitalRead(MEDIA_ENCODER_CLK_PIN);
  if (clockNow != lastMediaClock && clockNow == LOW) {
    if (digitalRead(MEDIA_ENCODER_DT_PIN) != clockNow) {
      tapConsumerKey(CONSUMER_CONTROL_SCAN_NEXT_TRACK);
    } else {
      tapConsumerKey(CONSUMER_CONTROL_SCAN_PREVIOUS_TRACK);
    }
  }
  lastMediaClock = clockNow;
}

void readMediaButton() {
  const int reading = digitalRead(MEDIA_ENCODER_SW_PIN);
  if (reading != lastMediaButtonReading) lastMediaButtonChangeMs = millis();
  if (millis() - lastMediaButtonChangeMs >= BUTTON_DEBOUNCE_MS && reading != stableMediaButtonState) {
    stableMediaButtonState = reading;
    if (stableMediaButtonState == LOW) {
      tapConsumerKey(CONSUMER_CONTROL_PLAY_PAUSE);
    }
  }
  lastMediaButtonReading = reading;
}

void readSinkMuteButtons() {
  for (uint8_t i = 0; i < 4; ++i) {
    const int reading = digitalRead(SINK_MUTE_BUTTON_PINS[i]);
    if (reading != lastSinkMuteButtonReading[i]) lastSinkMuteButtonChangeMs[i] = millis();
    if (millis() - lastSinkMuteButtonChangeMs[i] >= BUTTON_DEBOUNCE_MS && reading != stableSinkMuteButtonState[i]) {
      stableSinkMuteButtonState[i] = reading;
      if (stableSinkMuteButtonState[i] == LOW) {
        sinkMuted[i] = !sinkMuted[i];
        digitalWrite(SINK_MUTE_LED_PINS[i], sinkMuted[i] ? HIGH : LOW);
        MIDI.controlChange(SINK_MUTE_CC[i], sinkMuted[i] ? 127 : 0, MIDI_CHANNEL);
      }
    }
    lastSinkMuteButtonReading[i] = reading;
  }
}

void setup() {
  analogReadResolution(12);
  for (uint8_t i = 0; i < 4; ++i) {
    pinMode(FADER_PINS[i], INPUT);
    pinMode(SINK_MUTE_BUTTON_PINS[i], INPUT_PULLUP);
    pinMode(SINK_MUTE_LED_PINS[i], OUTPUT);
    digitalWrite(SINK_MUTE_LED_PINS[i], LOW);
    lastSinkMuteButtonReading[i] = digitalRead(SINK_MUTE_BUTTON_PINS[i]);
    stableSinkMuteButtonState[i] = lastSinkMuteButtonReading[i];
  }

  pinMode(ENCODER_CLK_PIN, INPUT_PULLUP);
  pinMode(ENCODER_DT_PIN, INPUT_PULLUP);
  pinMode(ENCODER_SW_PIN, INPUT_PULLUP);
  pinMode(MEDIA_ENCODER_CLK_PIN, INPUT_PULLUP);
  pinMode(MEDIA_ENCODER_DT_PIN, INPUT_PULLUP);
  pinMode(MEDIA_ENCODER_SW_PIN, INPUT_PULLUP);

  lastMasterClock = digitalRead(ENCODER_CLK_PIN);
  lastMasterButtonReading = digitalRead(ENCODER_SW_PIN);
  stableMasterButtonState = lastMasterButtonReading;
  lastMediaClock = digitalRead(MEDIA_ENCODER_CLK_PIN);
  lastMediaButtonReading = digitalRead(MEDIA_ENCODER_SW_PIN);
  stableMediaButtonState = lastMediaButtonReading;

  MIDI.begin(MIDI_CHANNEL_OMNI);
  ConsumerControl.begin();
  USB.begin();
}

void loop() {
  readMasterEncoder();
  readMasterButton();
  readMediaEncoder();
  readMediaButton();
  readSinkMuteButtons();

  if (millis() - lastFaderReadMs >= FADER_INTERVAL_MS) {
    lastFaderReadMs = millis();
    for (uint8_t i = 0; i < 4; ++i) sendFaderIfMoved(i);
  }
}