#include "MIDIUSB.

h"

// constants for selecting multiplexer1 pins

const int selectPins[4] = {13, 12, 11, 10}; // S0~12, S1~11, S2~10 S3~9
const int zInput = 9;

// constants for selecting multiplexer2 pins

const int select2Pins[4] = {4, 5, 6, 7}; // S0~2, S1~3, S2~4 S3~5
const int z2Input = A3;

//constants for midichannel

const uint8_t midiChannel = 0;

//constants for pots and switches that are connected straight to the Arduino input
pins (not using multiplexers)
const int potSPREAD = A2;
const int potTONE = A5;
const int potFBD = A4;
const int potTIME = A1;
const int potWET = A0;
const int switchCHORUSII = 2;
const int switchCHORUSI = 1;

//variables to set the initial state of the peripherals

int sliderLFOState = 0;
int sliderPWState = 0;
int sliderSUBOSCState = 0;
int sliderNOISEState = 0;
int sliderHPFState = 0;
int sliderVCFState = 0;
int sliderRESState = 0;
int sliderENVState = 0;
int sliderMODState = 0;
int sliderKEYBState = 0;
int sliderAState = 0;
int sliderDState = 0;
int sliderSState = 0;
int sliderRState = 0;
int sliderRATEState = 0;
int sliderDELAYState = 0;
int sliderTIMEState = 0;
int sliderPWDCOState = 0;
int sliderPWFILTERState = 0;
int sliderVELENVState = 0;
int sliderVELVOLUMEState = 0;
int sliderPORTAMENTOTIMEState = 0;

int potWETState = 0;
int potTIMEState = 0;
int potSPREADState = 0;
int potTONEState = 0;
int potFBDState = 0;

int switchENVINVERTState = 0;
int switchPWState = 0;
int switchPULSEState = 0;
int switchSAWState = 0;
int switchSQUAREState = 0;
int switchLFOWAVEState = 0;
int switchLFOState = 0;
int switchEFFECTState = 0;
int switchPORTAMENTOState = 0;
int SwitchCHORUSIIState = 0;
int SwitchCHORUSIState = 0;

//seting variables that define the smallest change in value of analog peripherals
(pots and sliders) that will trigger a response from the Arduino
int actionTresholdMax;
int actionTresholdMin;

uint8_t midiCCValue;

//variables to set the initial state for debouncing the swithches and buttons
int lastSwitchPULSEState = 0;
int lastSwitchSAWState = 0;
int lastSwitchSQUAREState = 0;
int lastSwitchLFOWAVEState = 0;
int lastSwitchPWState = 0;
int lastSwitchLFOState = 0;
int lastSwitchEFFECTState = 0;
int lastSwitchPORTAMENTOState = 0;
int lastSwitchCHORUSIIState = 0 ;
int lastSwitchCHORUSIState = 0 ;

// variables to set the initial state of debouncing timers. usingned long needed
here as the numbers get bit very quickly
unsigned long lastDebounceTimeENVINVERT = 0; // the last time the output pin was
toggled
unsigned long lastDebounceTimeSwitchPULSE = 0;
unsigned long lastDebounceTimeSwitchSaw = 0;
unsigned long lastDebounceTimeSwitchSQUARE = 0;
unsigned long lastDebounceTimeSwitchPW = 0;
unsigned long lastDebounceTimeSwitchLFOWAVE = 0;
unsigned long lastDebounceTimeSwitchLFO = 0;
unsigned long lastDebounceTimeSwitchEFFECT = 0;
unsigned long lastDebounceTimeSwitchPORTAMENTO = 0;
unsigned long lastDebounceTimeSwitchCHORUSII = 0;
unsigned long lastDebounceTimeSwitchCHORUSI = 0;

unsigned long debounceDelay = 50; // the debounce time; increase if the output
flickers

void setup()
{

for (int i = 0; i < 4; i++)

 {
pinMode(selectPins[i], OUTPUT); // Set up the select pins as outputs:
digitalWrite(selectPins[i], HIGH);
}
pinMode(zInput, INPUT); // Set up Zinput as an input

for (int k = 0; k < 4; k++)

{
pinMode(select2Pins[k], OUTPUT); // Set up the select pins as outputs:
digitalWrite(select2Pins[k], HIGH);
}
pinMode(z2Input, INPUT); // Set up z2input as an input

void loop() {

byte muxPin = 1;
selectMuxPin(muxPin); // Select the channel of the multiplexer you are reading
int readingSliderKEYB = analogRead(zInput); // and read Zinput
midiCCValue = (readingSliderKEYB / 8); // changing the analog reading to 7-bit
(0-127) value suitable for midi message
if (readingSliderKEYB > (sliderKEYBState + 4) or readingSliderKEYB <
(sliderKEYBState - 4)) // if the value is >4 bigger or smaller than the last saved
value of the slider, then
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 11, midiCCValue};
MidiUSB.sendMIDI(event);
sliderKEYBState = readingSliderKEYB;
} // the value is prepared
to be send as a 7-bit midi-message in the set midichannel and saved as a new value
of the slider

muxPin = 2;
selectMuxPin(muxPin);
int readingSliderMOD = analogRead(zInput);
midiCCValue = (readingSliderMOD / 8);
if (readingSliderMOD > (sliderMODState + 4) or readingSliderMOD <
(sliderMODState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 12, midiCCValue};
MidiUSB.sendMIDI(event);
sliderMODState = readingSliderMOD;
}

muxPin = 3;
selectMuxPin(muxPin);
int readingSliderENV = analogRead(zInput);
midiCCValue = (readingSliderENV / 8);
 if (readingSliderENV > (sliderENVState + 4) or readingSliderENV <
(sliderENVState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 13, midiCCValue};
MidiUSB.sendMIDI(event);
sliderENVState = readingSliderENV;
}

muxPin = 4;
selectMuxPin(muxPin);
int readingSliderRES = analogRead(zInput);
midiCCValue = (readingSliderRES / 8);
if (readingSliderRES > (sliderRESState + 4) or readingSliderRES <
(sliderRESState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 14, midiCCValue};
MidiUSB.sendMIDI(event);
sliderRESState = readingSliderRES;
}

muxPin = 5;
selectMuxPin(muxPin);
int readingSliderVCF = analogRead(zInput);
midiCCValue = (readingSliderVCF / 8);
if (readingSliderVCF > (sliderVCFState + 4) or readingSliderVCF <
(sliderVCFState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 15, midiCCValue};
MidiUSB.sendMIDI(event);
sliderVCFState = readingSliderVCF;
}

muxPin = 6;
selectMuxPin(muxPin);
int readingSliderHPF = analogRead(zInput);
midiCCValue = (readingSliderHPF / 8);
if (readingSliderHPF > (sliderHPFState + 4) or readingSliderHPF <
(sliderHPFState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 16, midiCCValue};
MidiUSB.sendMIDI(event);
sliderHPFState = readingSliderHPF;
}

muxPin = 7;
selectMuxPin(muxPin);
int readingSliderNOISE = analogRead(zInput);
midiCCValue = (readingSliderNOISE / 8);
if (readingSliderNOISE > (sliderNOISEState + 4) or readingSliderNOISE <
(sliderNOISEState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 17, midiCCValue};
MidiUSB.sendMIDI(event);
 sliderNOISEState = readingSliderNOISE;
}

muxPin = 8;
selectMuxPin(muxPin);
int readingSwitchPULSE = digitalRead(zInput);
if (readingSwitchPULSE != lastSwitchPULSEState)
{
lastDebounceTimeSwitchPULSE = millis(); // debouncing the switch. reset the
debouncing timer
}
if ((millis() - lastDebounceTimeSwitchPULSE) > debounceDelay) // If more that 50
ms has passed since the reading was different from last recorder state...
{
if (readingSwitchPULSE != switchPULSEState) // confirm the change of digital
value is real
{
switchPULSEState = readingSwitchPULSE;
if (switchPULSEState == LOW)
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 18, 127};
MidiUSB.sendMIDI(event);
}
else
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 18, 0};
MidiUSB.sendMIDI(event);
}
}
}

lastSwitchPULSEState = switchPULSEState;

muxPin = 9;
selectMuxPin(muxPin);
int readingSwitchSAW = digitalRead(zInput);
if (readingSwitchSAW != lastSwitchSAWState)
{
lastDebounceTimeSwitchSaw = millis();
}
if ((millis() - lastDebounceTimeSwitchSaw) > debounceDelay)
{
if (readingSwitchSAW != switchSAWState)
{
switchSAWState = readingSwitchSAW;
if (switchSAWState == LOW)
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 19, 127};
MidiUSB.sendMIDI(event);
}
else
 {
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 19, 0};
MidiUSB.sendMIDI(event);
}
}
}

lastSwitchSAWState = readingSwitchSAW;

muxPin = 10;
selectMuxPin(muxPin);
int readingSwitchSQUARE = digitalRead(zInput);

if (readingSwitchSQUARE != lastSwitchSQUAREState)
{
lastDebounceTimeSwitchSQUARE = millis();
}
if ((millis() - lastDebounceTimeSwitchSQUARE) > debounceDelay)
{
if (readingSwitchSQUARE != switchSQUAREState)
{
switchSQUAREState = readingSwitchSQUARE;
if (switchSQUAREState == LOW)
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 20, 127};
MidiUSB.sendMIDI(event);
}
else
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 20, 0};
MidiUSB.sendMIDI(event);
}
}
}

lastSwitchSQUAREState = readingSwitchSQUARE;

muxPin = 11;
selectMuxPin(muxPin); // Select one at a time
int readingSliderSUBOSC = analogRead(zInput); // and read Z
midiCCValue = (readingSliderSUBOSC / 8);
if (readingSliderSUBOSC > (sliderSUBOSCState + 4) or readingSliderSUBOSC <
(sliderSUBOSCState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 21, midiCCValue};
MidiUSB.sendMIDI(event);
sliderSUBOSCState = readingSliderSUBOSC;
}

muxPin = 12;
selectMuxPin(muxPin);
int readingSliderPW = analogRead(zInput);
midiCCValue = (readingSliderPW / 8);
 if (readingSliderPW > (sliderPWState + 4) or readingSliderPW < (sliderPWState -
4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 22, midiCCValue};
MidiUSB.sendMIDI(event);
sliderPWState = readingSliderPW;
}

muxPin = 13;
selectMuxPin(muxPin);
int readingSwitchPW = analogRead(zInput);

if (abs (readingSwitchPW - lastSwitchPWState) > 160)

{
lastDebounceTimeSwitchPW = millis();
}
if ((millis() - lastDebounceTimeSwitchPW) > debounceDelay)
{
if (abs (readingSwitchPW - switchPWState) > 160)

{ switchPWState = readingSwitchPW;

midiCCValue = (readingSwitchPW / 8);

midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 23, midiCCValue};

MidiUSB.sendMIDI(event);
}
}

lastSwitchPWState = readingSwitchPW;

muxPin = 14;
selectMuxPin(muxPin);
int readingSliderLFO = analogRead(zInput);
midiCCValue = (readingSliderLFO / 8);
if (readingSliderLFO > (sliderLFOState + 4) or readingSliderLFO <
(sliderLFOState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 24, midiCCValue};
MidiUSB.sendMIDI(event);
sliderLFOState = readingSliderLFO;
}

muxPin = 15;
selectMuxPin(muxPin);
int readingSwitchLFOWAVE = analogRead(zInput);
midiCCValue = (readingSwitchLFOWAVE / 8);
if (abs (readingSwitchLFOWAVE - lastSwitchLFOWAVEState) > 80)
{
lastDebounceTimeSwitchLFOWAVE = millis();
}
if ((millis() - lastDebounceTimeSwitchLFOWAVE) > debounceDelay)
{
if (abs (readingSwitchLFOWAVE - switchLFOWAVEState) > 80)

{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 25, midiCCValue};
MidiUSB.sendMIDI(event);
switchLFOWAVEState = readingSwitchLFOWAVE;
}
}

lastSwitchLFOWAVEState = readingSwitchLFOWAVE ;

byte mux2Pin = 0;
selectMux2Pin(mux2Pin);
int readingSliderA = analogRead(z2Input);
midiCCValue = (readingSliderA / 8);
if (readingSliderA > (sliderAState + 4) or readingSliderA < (sliderAState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 26, midiCCValue};
MidiUSB.sendMIDI(event);
sliderAState = readingSliderA;
}

mux2Pin = 1;
selectMux2Pin(mux2Pin);
int readingSliderD = analogRead(z2Input);
midiCCValue = (readingSliderD / 8);
if (readingSliderD > (sliderDState + 4) or readingSliderD < (sliderDState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 27, midiCCValue};
MidiUSB.sendMIDI(event);
sliderDState = readingSliderD;
}

mux2Pin = 2;
selectMux2Pin(mux2Pin);
int readingSliderS = analogRead(z2Input);
midiCCValue = (readingSliderS / 8);
if (readingSliderS > (sliderSState + 4) or readingSliderS < (sliderSState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 28, midiCCValue};
MidiUSB.sendMIDI(event);
sliderSState = readingSliderS;
}

mux2Pin = 3;
selectMux2Pin(mux2Pin);
 int readingSliderR = analogRead(z2Input);
midiCCValue = (readingSliderR / 8);
if (readingSliderR > (sliderRState + 4) or readingSliderR < (sliderRState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 29, midiCCValue};
MidiUSB.sendMIDI(event);
sliderRState = readingSliderR;
}

mux2Pin = 4;
selectMux2Pin(mux2Pin);
int readingSliderRATE = analogRead(z2Input);
midiCCValue = (readingSliderRATE / 8);
if (readingSliderRATE > (sliderRATEState + 4) or readingSliderRATE <
(sliderRATEState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 30, midiCCValue};
MidiUSB.sendMIDI(event);
sliderRATEState = readingSliderRATE;
}

mux2Pin = 5;
selectMux2Pin(mux2Pin);
int readingSliderDELAY = analogRead(z2Input);
midiCCValue = (readingSliderDELAY / 8);
if (readingSliderDELAY > (sliderDELAYState + 4) or readingSliderDELAY <
(sliderDELAYState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 31, midiCCValue};
MidiUSB.sendMIDI(event);
sliderDELAYState = readingSliderDELAY;
}

mux2Pin = 6;
selectMux2Pin(mux2Pin);
int readingSwitchLFO = analogRead(zInput);
midiCCValue = (readingSwitchLFO / 8);
if (readingSwitchLFO > (lastSwitchLFOState + 160) or readingSwitchLFO <
(lastSwitchLFOState - 160))
{
lastDebounceTimeSwitchLFO = millis();
}
if ((millis() - lastDebounceTimeSwitchLFO) > debounceDelay)
{
if (readingSwitchLFO > (switchLFOState + 160) or readingSwitchLFO <
(switchLFOState - 160))

{ switchLFOState = readingSwitchLFO;

midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 32, midiCCValue};

MidiUSB.sendMIDI(event);
 }
}

lastSwitchLFOState = readingSwitchLFO;

mux2Pin = 7;
selectMux2Pin(mux2Pin);
int readingSwitchEFFECT = analogRead(z2Input);
midiCCValue = (readingSwitchEFFECT / 8) ;
if (readingSwitchEFFECT > (lastSwitchEFFECTState + 160) or readingSwitchEFFECT <
(lastSwitchEFFECTState - 160))
{
lastDebounceTimeSwitchEFFECT = millis();
}
if ((millis() - lastDebounceTimeSwitchEFFECT) > debounceDelay)
{

if (readingSwitchEFFECT > (switchEFFECTState + 160) or readingSwitchEFFECT <

(switchEFFECTState - 160))

{ switchEFFECTState = readingSwitchEFFECT;

midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 33, midiCCValue};

MidiUSB.sendMIDI(event);
}
}

lastSwitchEFFECTState = readingSwitchEFFECT;

mux2Pin = 8;
selectMux2Pin(mux2Pin);
int readingSliderVELVOLUME = analogRead(z2Input);
midiCCValue = (readingSliderVELVOLUME / 8);
if (readingSliderVELVOLUME > (sliderVELVOLUMEState + 4) or
readingSliderVELVOLUME < (sliderVELVOLUMEState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 34, midiCCValue};
MidiUSB.sendMIDI(event);
sliderVELVOLUMEState = readingSliderVELVOLUME;
}

mux2Pin = 11;
selectMux2Pin(mux2Pin);
int readingSwitchPORTAMENTO = analogRead(zInput);
midiCCValue = (readingSwitchPORTAMENTO / 8);

if (abs (readingSwitchPORTAMENTO - lastSwitchPORTAMENTOState) > 160)

{
 lastDebounceTimeSwitchPORTAMENTO = millis();
}
if ((millis() - lastDebounceTimeSwitchPORTAMENTO) > debounceDelay)
{
if (abs (readingSwitchPORTAMENTO - switchPORTAMENTOState) > 160)

{ switchPORTAMENTOState = readingSwitchPORTAMENTO;

midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 35, midiCCValue};

MidiUSB.sendMIDI(event);
}
}

lastSwitchPORTAMENTOState = readingSwitchPORTAMENTO;

mux2Pin = 12;
selectMux2Pin(mux2Pin);
int readingSliderPORTAMENTOTIME = analogRead(z2Input);
midiCCValue = (readingSliderPORTAMENTOTIME / 8);
if (readingSliderPORTAMENTOTIME > (sliderPORTAMENTOTIMEState + 4) or
readingSliderPORTAMENTOTIME < (sliderPORTAMENTOTIMEState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 36, midiCCValue};
MidiUSB.sendMIDI(event);
sliderPORTAMENTOTIMEState = readingSliderPORTAMENTOTIME;
}

mux2Pin = 13;
selectMux2Pin(mux2Pin);
int readingSliderPWDCO = analogRead(z2Input);
midiCCValue = (readingSliderPWDCO / 8);
if (readingSliderPWDCO > (sliderPWDCOState + 4) or readingSliderPWDCO <
(sliderPWDCOState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 37, midiCCValue};
MidiUSB.sendMIDI(event);
sliderPWDCOState = readingSliderPWDCO;
}

mux2Pin = 14;
selectMux2Pin(mux2Pin);
int readingSliderPWFILTER = analogRead(z2Input);
midiCCValue = (readingSliderPWFILTER / 8);
if (readingSliderPWFILTER > (sliderPWFILTERState + 4) or readingSliderPWFILTER <
(sliderPWFILTERState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 38, midiCCValue};
MidiUSB.sendMIDI(event);
sliderPWFILTERState = readingSliderPWFILTER;
}

mux2Pin = 15;
 selectMux2Pin(mux2Pin);
int readingSliderVELENV = analogRead(z2Input);
midiCCValue = (readingSliderVELENV / 8);
if (readingSliderVELENV > (sliderVELENVState + 4) or readingSliderVELENV <
(sliderVELENVState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 39, midiCCValue};
MidiUSB.sendMIDI(event);
sliderVELENVState = readingSliderVELENV;
}

int readingPotSPREAD = analogRead(potSPREAD);

midiCCValue = (readingPotSPREAD / 8);
if (readingPotSPREAD > (potSPREADState + 20) or readingPotSPREAD <
(potSPREADState - 20))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 40, midiCCValue};
MidiUSB.sendMIDI(event);
potSPREADState = readingPotSPREAD;
}

int readingPotTIME = analogRead(potTIME);

midiCCValue = (readingPotTIME / 8);
if (readingPotTIME > (potTIMEState + 4) or readingPotTIME < (potTIMEState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 43, midiCCValue};
MidiUSB.sendMIDI(event);
potTIMEState = readingPotTIME;
}

int readingPotWET = analogRead(potWET);

midiCCValue = (readingPotWET / 8);
if (readingPotWET > (potWETState + 4) or readingPotWET < (potWETState - 4))
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 44, midiCCValue};
MidiUSB.sendMIDI(event);
potWETState = readingPotWET;
}

int readingSwitchCHORUSII = digitalRead(switchCHORUSII); // read the state of

the switch into a local variable:
if (readingSwitchCHORUSII != lastSwitchCHORUSIIState) // if reading is different
from last recorded state
{
lastDebounceTimeSwitchCHORUSII = millis(); // reset the debouncing timer
}
if ((millis() - lastDebounceTimeSwitchCHORUSII) > debounceDelay) // If more that
50 ms has passed since the reading was different from last recorder state...
{
 if (readingSwitchCHORUSII != SwitchCHORUSIIState) //... and the reading still
is different from the last recorded state...
{
SwitchCHORUSIIState = readingSwitchCHORUSII; // ...we believe it's genuine
and update the buttonState...

if (SwitchCHORUSIIState == LOW)
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 45, 127};
MidiUSB.sendMIDI(event);
}
else
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 45, 0};
MidiUSB.sendMIDI(event);
}
}
}

lastSwitchCHORUSIIState = readingSwitchCHORUSII;

int readingSwitchCHORUSI = digitalRead(switchCHORUSI);

if (readingSwitchCHORUSI != lastSwitchCHORUSIState)
{
lastDebounceTimeSwitchCHORUSI = millis();
}
if ((millis() - lastDebounceTimeSwitchCHORUSI) > debounceDelay)
{
if (readingSwitchCHORUSI != SwitchCHORUSIState)
{
SwitchCHORUSIState = readingSwitchCHORUSI;

if (SwitchCHORUSIState == LOW)
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 46, 127};
MidiUSB.sendMIDI(event);
}
else
{
midiEventPacket_t event = {0x0B, 0xB0 | midiChannel, 46, 0};
MidiUSB.sendMIDI(event);
}
}
}

lastSwitchCHORUSIState = readingSwitchCHORUSI; // save the reading. Next time

through the loop, it'll be the lastButtonState:

MidiUSB.flush();

// The selectMuxPin function sets the S0, S1, and S2 pins

// accordingly, given a pin from 0-7.
void selectMuxPin(byte muxPin)
{
for (int i = 0; i < 4; i++)
{
if (muxPin & (1 << i))
digitalWrite(selectPins[i], HIGH);
else
digitalWrite(selectPins[i], LOW);
}
}

void selectMux2Pin(byte mux2Pin)

{
for (int i = 0; i < 4; i++)
{
if (mux2Pin & (1 << i))
digitalWrite(select2Pins[i], HIGH);
else
digitalWrite(select2Pins[i], LOW);
}
}