Fuzzytron 3000 Source Code

#include <MIDIUSB.h>
#include <ResponsiveAnalogRead.h>

/*
  CC Legend: (channel / control / value)
    Buttons           = Channel 0 / x / 64
    Volume & EQ Knobs = Channel 1 / x / 127
    VU LEDs           = Channel 2 / x / x
    Sliders           = Channel 3 / x / x
    Selection Knobs   = Channel 4 / x / x
*/

// MULTIPLEXERS
  const int sigA = A0;
  const int sigB = A1;
  const int muxPinsA[4] = {8, 9, 10, 11};
  const int muxPinsB[4] = {4, 5, 6, 7};

  ResponsiveAnalogRead mPlexA(sigA, true);
  ResponsiveAnalogRead mPlexB(sigB, true);

  // Multiplexer A Connections
  int gainA, highA, midA, lowA, filterA, pitchA, volA, phonesVol, masterVol, xFade, deckA;
  int defaultGainA = 64, defaultHighA = 64, defaultMidA = 64, defaultLowA = 64, defaultFilterA = 64;
  int defaultVolA = 0;
  int defaultmasterVol = 75, defaultphonesVol = 75, defaultXFade = 64;

  // Multiplexer B Connections
  int gainB, highB, midB, lowB, filterB, pitchB, volB, deckB;
  int defaultVolB = 0;
  int defaultGainB = 64, defaultHighB = 64, defaultMidB = 64, defaultLowB = 64, defaultFilterB = 64;

// BUTTONS
  // Deck 1

  // Deck 2

  // Mixer
  //const int mVol = A5;
  //int defaultMasterVolume = 75;
  //int masterVolume;
  //ResponsiveAnalogRead masterVol(mVol, true);

  // Selection Encoder
  const int selectEncA = 12;
  const int selectEncB = 13;
  int selectEncDir;
  int selectEncState;
  int selectEncLastState;

  // Loop Encoder
  const int loopEncA = 14;
  const int loopEncB = 15;
  int loopEncDir;
  int loopEncState;
  int loopEncLastState;

// SLIDERS

  // Deck 1

  // Deck 2

  // Mixer

// VU LEDs
int l1VU = 2;
int l2VU = 3;
int l3VU = 4;
int l4VU = 5;
int l5VU = 6;

int r1VU = 7;
int r2VU = 8;
int r3VU = 9;
int r4VU = 10;
int r5VU = 11;


// MISC
unsigned long VUTimer;

void setup() {

  Serial.begin(115200);
  Serial.print("Welcome to the FuzzyTron 3000!");

  // Multiplexer
  pinMode(sigA, INPUT);
  pinMode(sigB, INPUT);

  for (int i=0; i<4; i++)
  {
    pinMode(muxPinsA[i], OUTPUT);
    digitalWrite(muxPinsA[i], HIGH);
    pinMode(muxPinsB[i], OUTPUT);
    digitalWrite(muxPinsB[i], HIGH);
  }

  // Selection knob encoder
  pinMode(selectEncA, INPUT_PULLUP);
  pinMode(selectEncB, INPUT_PULLUP);
  selectEncLastState = digitalRead(selectEncA);

  // Loop knob encoder
  pinMode(loopEncA, INPUT_PULLUP);
  pinMode(loopEncB, INPUT_PULLUP);
  loopEncLastState = digitalRead(loopEncA);

  // Set button and knob pins to INPUT and default HIGH
  int pinMin = 0;
  int pinMax = 1;
  for (int i = pinMin; i <= pinMax; i++)
  {
    pinMode(i, INPUT);
    digitalWrite(i, HIGH);
  }

  // Do power on animation
  //powerAnim(40);
}

void loop() {
  // LEDs
  //readVU();

  // DECK A POTS
  gainA = readPot(1, 0);
  highA = readPot(1, 1);
  //midA = readPot(1, 2);
  //lowA = readPot(1, 3);
  //filterA = readPot(1, 4);
  //pitchA = readPot(1, 5);
  //volA = readPot(1, 6);

  // Check for deck A pot changes
  //GAIN
  if (gainA != defaultGainA){
    sendControl(1, 0, gainA); // Send the MIDI signal
    //Serial.println(gainA);
    defaultGainA = gainA;
  }

  // HIGH
  if (highA != defaultHighA){
    sendControl(1, 1, highA); // Send the MIDI signal
    //Serial.println(highA);
    defaultHighA = highA;
  }




  // Read Track selection and loop rotary encoders
  rotaryRead(selectEncA, selectEncB, selectEncState, selectEncLastState, selectEncDir, 0);
  rotaryRead(loopEncA, loopEncB, loopEncState, loopEncLastState, loopEncDir, 1);

  // CUE Buttons

  // DECK ONE
    // GAIN

  // DECK TWO


  // Volume Knobs
    // MASTER VOLUME
    //masterVol.update();
    //masterVolume = map(masterVol.getValue(), 0, 1023, 0, 127);

    //if (masterVol.hasChanged()){
    //  sendControl(1, 1, masterVolume);
    //  defaultMasterVolume = masterVolume;
    //}
}

////////////////////
//   FUNCTIONS    //
////////////////////

// Multiplexer Pin Selection
void selectMuxPin(int deck, byte pin)
{
  for (int i=0; i<4; i++)
  {
    if (deck == 1){
      if (pin & (1<<i))
        digitalWrite(muxPinsA[i], HIGH);
      else
        digitalWrite(muxPinsA[i], LOW);
    }

    if (deck == 2){
      if (pin & (1<<i))
        digitalWrite(muxPinsB[i], HIGH);
      else
        digitalWrite(muxPinsB[i], LOW);
    }
  }
}

int readPot(int deck, int pin){
  if (deck == 1){
    selectMuxPin(1, pin);
    mPlexA.update();
    return map(mPlexA.getValue(), 0, 1023, 0, 127);
  }
  if (deck == 2){
    selectMuxPin(2, pin);
    mPlexB.update();
    return map(mPlexB.getValue(), 0, 1023, 0, 127);
  }
}

// Send the actual MIDI commands
void sendControl(byte channel, byte control, byte value) {
  midiEventPacket_t event = {0x0B, 0xB0 | channel, control, value};
  MidiUSB.sendMIDI(event);
  MidiUSB.flush();
}


// Read the rotary encoders
void rotaryRead(int pinA, int pinB, int state, int lastState, int rotaryDirection, int cc){
  state = digitalRead(pinA);

  if (state != lastState){
    // Clockwise rotation
    if (digitalRead(pinB) != state) {
      rotaryDirection = 1;
    }
    // Counter-clockwise rotation
    else {
      rotaryDirection = 127;
    }
    sendControl(1, cc, rotaryDirection);
  }
  lastState = state;
}


// Master volume VU
void readVU() {
  midiEventPacket_t rx;
  do {
    rx = MidiUSB.read();
    if (rx.header != 0) {

      // Left Lower LED
      if (rx.byte1 == 178 && rx.byte2 == 0){
        digitalWrite(l1VU, HIGH);
        digitalWrite(r1VU, HIGH);
        VUTimer = millis();
      }
      // Left 2nd LED
      if (rx.byte1 == 178 && rx.byte2 == 1){
        digitalWrite(l2VU, HIGH);
        digitalWrite(r2VU, HIGH);
        VUTimer = millis();
      }
      // Left 3rd LED
      if (rx.byte1 == 178 && rx.byte2 == 2){
        digitalWrite(l3VU, HIGH);
        digitalWrite(r3VU, HIGH);
        VUTimer = millis();
      }
      // Left 4th LED
      if (rx.byte1 == 178 && rx.byte2 == 3){
        digitalWrite(l4VU, HIGH);
        digitalWrite(r4VU, HIGH);
        VUTimer = millis();
      }
      // Left Top LED
      if (rx.byte1 == 178 && rx.byte2 == 4){
        digitalWrite(l5VU, HIGH);
        digitalWrite(r5VU, HIGH);
        VUTimer = millis();
      }

/*
      Serial.print("MIDI Signal Received: ");
      Serial.print("HEADER: ");
      Serial.println(rx.header);
      Serial.print("BYTE 1: ");
      Serial.println(rx.byte1);
      Serial.print("BYTE 2: ");
      Serial.println(rx.byte2);
      Serial.print("BYTE 3: ");
      Serial.println(rx.byte3);
      Serial.flush();
*/
    }

  } while (rx.header != 0);

    if (millis()-VUTimer >= 38UL){
      digitalWrite(l1VU, LOW);
      digitalWrite(l2VU, LOW);
      digitalWrite(l3VU, LOW);
      digitalWrite(l4VU, LOW);
      digitalWrite(l5VU, LOW);

      digitalWrite(r1VU, LOW);
      digitalWrite(r2VU, LOW);
      digitalWrite(r3VU, LOW);
      digitalWrite(r4VU, LOW);
      digitalWrite(r5VU, LOW);
    }

}


// Bootup animation
// REMOVED