Published October 13, 2022 © CC BY-NC

MIDI Merger and Patchbay

A MIDI merger and patchbay with MIDI expression capabilities for the ARKeytar Arduino MIDI controller or other devices, based on Mega 2560.

IntermediateShowcase (no instructions)1,795

Things used in this project

Hardware components

Toggle Switch, SPDT

TaydaElectronics 3PDT STOMP FOOT / PEDAL SWITCH

Rotary Encoder with Push-Button

MIDI 5 pins connector DIN 41524

Stereo jack socket

Metal Enclosure, Electrical / Industrial

Arduino Mega 2560

Software apps and online services

Arduino IDE

Hand tools and fabrication machines

Soldering iron (generic)

Solder Wire, Lead Free

Story

The Concept

The birth of this project is strictly related to the development of my ARKeytar MIDI controller. After I built the ARKeytar, I realized that I wanted to expand its capabilities in terms of musical expression. Also, I needed to route the generated MIDI messages towards my keyboard synth, or towards my PC, through a MIDI interface, to control VST synths.

In order to change the MIDI routing while letting my whole setup connected, I decided to build a MIDI merger with the capability of managing also an expression pedal and a switch pedal.

The MIDI merger and patchbay

Working Principle

Given the need of managing two serial ports (two MIDI inputs, and two MIDI outputs), the Arduino Mega board was chosen since, unlike the Arduino Uno, it is able to manage more than one serial port.

The idea is to keep the ARKeytar MIDI controller and my keyboard synth connected to the MIDI input of the merger, while the two MIDI outputs are directed towards the keyboard synth and the audio-MIDI interface. By means of two SPDT (single-pole double-throw) switches with three positions, one can tell the Arduino the destination MIDI output port for each of the two MIDI inputs.

The MIDI input 1 can be sent to one of the MIDI outputs or to both of them, while the MIDI input 2 can be sent to one of the MIDI outputs or to none of them. The routing of MIDI input 2 includes the possibility not to forward the generated messages, since the connected keyboard can be used to control only its internal sounds, instead of controlling some VST software. Now, by simply moving two switches, I can configure the routing of my MIDI devices.

Six SPDT switches control the MIDI routing, as well as the pedals settings.

The rear panel of the merger presents also two jack ports. One of them can be used to connect a switch pedal. The other one can handle both an expression pedal or a switch pedal. The behaviour can be selected with a switch on the top panel which changes the configuration of the Arduino pins to which the pedal is connected.

Two jack sockets for expression and switch pedals.

The digital pin D2 is set to INPUT_PULLUP when using the pedal as a simple switch. Otherwise, it is set as an output with state HIGH. In this case, the voltage value of the central pin of the stereo jack socket is read with analogRead() on the analog pin A4. The remaining pin is always connected to GND.

A dedicated switch changes the mode of digital pin 2 to accommodate the two possible types of pedal: Output HIGH to use the expression pedal as a potentiometer, and INPUT_PULLUP to use a sustain pedal as a switch.

Once the pedals states are read, MIDI messages are generated if changes happened. The control change destination can be programmed, and the destination MIDI output port can be selected, for each pedal, using switches on the top panel. The Arduino merges the routed incoming messages together with the ones generated following to the pedals action.

An additional switch is present to add some generic setting that can be assigned by editing the code in Arduino IDE. For the same reason, a digital encoder is present. Moreover, additional MIDI messages, like program change messages can be generated with three stomp switches.

All the switches are connected to the Arduino using a pair of shift registers. This was useful mainly to simplify the connection between the front panel and the Arduino Mega, which is screwed to the base. A reduced number of channels was used in this way.

The merger also presents three LEDs for analyzing the type of the incoming MIDI messages. The green and red leds are activated by note on and note off messages respectively, while the blue led is triggered by pitch bend messages, which are the majority of the MIDI messages sent by the ARKeytar, and by control change messages.

Encoder and the three leds that blink based on the type of incoming MIDI messages. Green for note on, orange for note off, blue for pitch bend and control change messages.

Building and Programming

I chose a solid aluminum box as the enclosure for the project. The base dimensions are 189 mm x 121 mm. The thickness of the box, excluding the later additions is 38 mm. Six holes were drilled for the SPDT switches, three for the stop pedals, three for the LEDs, and one for the encoder.

At the beginning, I did not drill the MIDI ports holes since I needed a good alignment with the four MIDI sockets, soldered to the internal circuit.

Placing components after drilling the holes. LEDs holes are not present yet in this phase.

The procedure I followed was:

Soldering all the main circuit, MIDI ports included, to a prototype PCB board. In order to accommodate the Mega inside the merger enclosure with a rigid connection, and without soldering, male pin headers were used. The space between the Mega and the PCB could be used to fit circuits and cables. Room was left also for possible future expansions of the project. MIDI circuits were soldered on the base, together with the sockets, and were connected, to the Arduino serial ports.

Screwing the PCB to the aluminum case base

Opening the four MIDI ports, and Arduino USB holes. For the MIDI ports a 16 mm diameter mill was used instead of a drill bit, since the case wall was slightly oblique while the MIDI sockets were not.

Drilling all the required holes to fit switches, LEDs and encoder. Besides the three LEDs for analyzing the MIDI input, a led was added to indicate that the merger is connected to the power supply and is turned on.

Midi ports.

Since all the switches needed the 5V connection, and another 1 or 2 connections with digital pins, I tried to limit the number of cables connecting the case base and the top panel. Two shift registers were placed under the top panel, so at least the cable mess was limited to the top panel. This helped in keeping some tidiness in the merger base. A ribbon cable was used to connect the front panel and the base.

The ribbon cable (grey) connects the front panel (top) to the base (bottom).

I included the encoder and the stomp pedals since I plan to give them a function like changing settings from a list and sending program change messages. However, they are not active at the moment.

All switches but two, are connected to two digital pins. The switches can be in three positions so that they can deliver the 5V to one of the pins or to none of them when they are in the central position. In this position, both the digital reads are LOW. If one of them is HIGH, the corresponding setting is selected. They can never be in HIGH state at the same time, due to the design of the connections. In this way three possible states are possible.

In particular:

Switch number 1 routes the MIDI input 1 to output 1, to output 2, or to both.

Switch 2 routes the MIDI input 2 to output 1, to output 2, or to none.

Switch 3 selects the digital or analog behaviour of pedal 2. Pedal 1 acts always as a switch

Switch 4 routes the MIDI messages generated with pedal 1 to MIDI output 1 or 2, or to both.

Switch 5 routes the MIDI messages generated with pedal 2 to MIDI output 1 or 2, or to both.

Switch 6 is not currently assigned to any function.

The stomps, instead, can be in two positions only, and are connected to a single digital pin. If a single message needs to be sent at the time of a pressure, the change of state is used to trigger a single message. Otherwise, the state can be used to determine which message should be sent among a set of two messages, like an on/off button.

The three stomps and the encoder (with its button) are not currently assigned to any function.

(1) Midi ports, (2) Pedal jack sockets, (3) Encoder with button, (4) MIDI analyzer LEDs, (5) Routing and setting switches, (6) Stomp switches, and (7) Mega USB port and power led.

Code

MIDI merger v1.11.1

/*
MIDI Merger v1.11.1
2022-10-16
*/

/* MIDI and ShiftIn libraries */
#include <MIDI.h>
#include <ShiftIn.h>
ShiftIn<2> shift;       // Two shift registers


/* A MIDI instance is created for each of the two serial ports used */
MIDI_CREATE_INSTANCE(HardwareSerial, Serial2, M1);
MIDI_CREATE_INSTANCE(HardwareSerial, Serial3, M2);



/* Shift registers variables */
int num;
int incoming;
int newRegRead;

/* Switches state. The variable contains: switch number, first and second pin state */
int s1[3] = {0,0,0};  int s1Old[3] = {0,0,0};
int s2[3] = {1,0,0};  int s2Old[3] = {1,0,0};
int s3[2] = {2,0};    int s3Old[2] = {2,0};

int s4[3] = {3,0,0};  int s4Old[3] = {3,0,0};
int s5[3] = {4,0,0};  int s5Old[3] = {4,0,0};
int s6[2] = {5,0};    int s6Old[2] = {5,0};

/* Encoder and stomps state */
int e[4] = {6,0,0,0}; int eOld[4] = {6,0,0,0};
int f[4] = {7,0,0,0}; int fOld[4] = {7,0,0,0};

/* Leds */
const int ledR = 43;
const int ledG = 45;
const int ledB = 41;
const int ledPow = 39;
int ledList[4] = {ledB, ledR, ledG, ledPow};

/* Pedals variables */
const int p[2] = {3,2};
const int p2A = A4;
int susVal[2];
int susValOld[2];
int ccVal[2];
int sPedal[5] = {0,0,0,0,0};

int expVal[2];
int expValOld[2];
int expcc[2];
int expccOld[2];

int button = 0; int buttonOld = 0;

/* Settings list */
/* 	0. MIDI channel pedal 1, Digital			- Default: ch8
		1. MIDI channel pedal 2, Digital		  - Default: ch8
		2. MIDI channel pedal 2, Analog			  - Default: ch8
		3. CC pedal 1, Digital				 	      - Default: sustain
		4. CC pedal 2, Digital					      - Default: sustain
		5. CC pedal 2, Analog					        - Default: volume
*/
int setting[6] = {8, 8, 8, 1, 1, 2};
/* The settings are:  0.midi channel for pedal 1; 
                      1. midi channel for pedal 2, digital
                      2. midi channel for pedal 2, analog
                      3. index for listcc, cc destination of pedal 1
                      4. index for listcc, cc destination of pedal 2, digital
                      5. index for listcc, cc destination of pedal 2, analog*/
/* Control change number to be selected for expression pedal */
const int listCC[12] = {64, 7, 74, 71, 11, 1, 5, 73, 91, 93, 72, 10};




void setup() {
	/* turn on the "power on led" */
	pinMode(ledPow, OUTPUT);
	digitalWrite(ledPow, HIGH);
	
	M1.begin(MIDI_CHANNEL_OMNI);
	M2.begin(MIDI_CHANNEL_OMNI);
	Serial.begin(9600);

	/* Shift registers setup */
	shift.begin(4, 5, 6, 7);
	if(shift.update())
	incoming = readShiftReg();
	saveShiftReg();
	e[1] = 0;

	/* LEDs pins */
	pinMode(ledR, OUTPUT);
	pinMode(ledG, OUTPUT);
	pinMode(ledB, OUTPUT);
	

	/* pedals */
	pinMode(p2A, INPUT_PULLUP);
	pinMode(p[0], INPUT_PULLUP);

	/* Defines digital/analog pedal behaviour */
	/* Digital */
	if (s3[1] == 0) {
		pinMode(p[1], INPUT_PULLUP);
	}
	/* Analog */
	if (s3[1] == 1) {
		pinMode(p[1], OUTPUT);
		digitalWrite(p[1], HIGH);
	}
	
	/* Blink the leds after setup is done */
	for (int ii=0; ii<=2; ii++) {
		digitalWrite(ledList[ii],HIGH);
		delay(250);
		digitalWrite(ledList[ii],LOW);
	}
}




void loop() {

	shiftReg();
	
	merger();
	merger();
	merger();
	
	pedals();
	
	merger();
	merger();
	merger();

}





void shiftReg() {

	if(shift.update()) {newRegRead = 1;} else {newRegRead = 0;} 
	incoming = readShiftReg();
  
	if(newRegRead){
		saveShiftReg();
	}
}

int readShiftReg() {

	for(int i = 0; i < shift.getDataWidth(); i++){
		bitWrite(num, i, shift.state(i));
	}

	int incomingNumber = 0;
	for (int bitNumber = 8; bitNumber <= 15; bitNumber++) {
		bitWrite(incoming, incomingNumber, bitRead(num,bitNumber));
		incomingNumber++;
	}
	for (int bitNumber = 0; bitNumber <= 7; bitNumber++) {
		bitWrite(incoming, incomingNumber, bitRead(num,bitNumber));
		incomingNumber++;
	}
	merger();
	return incoming;
}



void saveShiftReg() {
	/* Assign shift register values to variables */
	e[1] = bitRead(incoming,0);
	e[2] = bitRead(incoming,1);
	e[3] = bitRead(incoming,2);
	f[1] = bitRead(incoming,3);
	f[3] = bitRead(incoming,4);
	f[2] = bitRead(incoming,5);
	s3[1] = bitRead(incoming,6);
	s6[1] = bitRead(incoming,7);
	
	merger();
	
	s2[2] = bitRead(incoming,8);
	s2[1] = bitRead(incoming,9);
	s1[2] = bitRead(incoming,10);
	s1[1] = bitRead(incoming,11);
	s4[2] = bitRead(incoming,12);
	s4[1] = bitRead(incoming,13);
	s5[2] = bitRead(incoming,14);
	s5[1] = bitRead(incoming,15);
	
  sPedal[1] = s4[2];
  sPedal[2] = s4[1];
  sPedal[3] = s5[2];
  sPedal[4] = s5[1];
	
	
	if (s1[1] == 1) {
		M1.turnThruOn();
	}
	if (s1[2] == 1) {
		M1.turnThruOff();
	}
	if (s1[1] == 0 && s1[2] == 0) {
		M1.turnThruOn();
	}
	if (s2[2] == 1) {
		M2.turnThruOn();
  }
	if (s2[1] == 1) {
		M2.turnThruOff();
	}
	if (s2[1] == 0 && s2[2] == 0) {
		M2.turnThruOff();
	}
	merger();
}



void merger() {
	/* Manages the MIDI routing */
	if (M1.read()) {
		if (s1[2] == 1) {
			M2.send(M1.getType(), M1.getData1(), M1.getData2(), M1.getChannel());
		}
		if (s1[1] == 0 && s1[2] == 0) {
			M2.send(M1.getType(), M1.getData1(), M1.getData2(), M1.getChannel());
		} 
	}

	if (M2.read()) {
		if (s2[1] == 1) {
			M1.send(M2.getType(), M2.getData1(), M2.getData2(), M2.getChannel());
		} 
	}	
	switchLed();
}



void switchLed() {
  /* LED color based on the MIDI message type */
	switch(M1.getType()) {
		case midi::NoteOn:
			ledOn(ledG);
			break;
		case midi::NoteOff:
			ledOn(ledR);
			break;
		case midi::PitchBend:
			ledOn(ledB);
			break;
		case midi::ControlChange:
			ledOn(ledR);
			break;
	}
	switch(M2.getType()) {
		case midi::NoteOn:
			ledOn(ledG);
			break;
		case midi::NoteOff:
			ledOn(ledR);
			break;
		case midi::PitchBend:
			ledOn(ledB);
			break;
		case midi::ControlChange:
			ledOn(ledR);
			break;
  }
	
}



void ledOn(int ledPin) {
	/* Turns on the led having pin number equal to the argument of the function.
	Otherwise, it turns the LED off */
	for (int ii = ledList[0]; ii <= ledList[2]+2; ii = ii+2) {
		if (ledPin == ii) {
			digitalWrite(ledPin, HIGH);
		} else {
			digitalWrite(ledPin, LOW);
		}
	}     
}



void pedals() {
	/* Manages the pedals */

	if (s3[1] != s3Old[1]) {
		if (s3[1] == 1) {
			pinMode(p[1], INPUT_PULLUP);
		} else if (s3[1] == 0) {
			pinMode(p[1], OUTPUT);
			digitalWrite(p[1], HIGH);
		}
		s3Old[1] = s3[1];
	}

	for (int ii = 0; ii <= 1; ii++) {
		
		/* Always proceed with pedal 1 */
		/* Proceed with pedal two if it is set on digital/switch */
		if (ii == 0 || ((s3[1] == 1) && (ii == 1))) {
			susVal[ii] = digitalRead(p[ii]);
			if (susVal[ii] != susValOld[ii]) {
				if (susVal[ii] == 1) {
					ccVal[ii] = 127;
				}
				if (susVal[ii] == 0) {
					ccVal[ii] = 0;
				}
				
				if (sPedal[ii*2+1] == 1) {
					M1.sendControlChange(listCC[setting[ii+3]],ccVal[ii],setting[ii]);
				}
				if (sPedal[ii*2+2] == 1) {
					M2.sendControlChange(listCC[setting[ii+3]],ccVal[ii],setting[ii]);
				}
				if (sPedal[ii*2+1] == 0 && sPedal[ii*2+2] == 0) {
					M1.sendControlChange(listCC[setting[ii+3]],ccVal[ii],setting[ii]);
					M2.sendControlChange(listCC[setting[ii+3]],ccVal[ii],setting[ii]);
				}

				susValOld[ii] = susVal[ii];
				merger();
			}
		}
		
		if (ii == 1 && s3[1] == 0) {
			expVal[1] = analogRead(p2A);
			expcc[1] = map(expVal[1],30,1023,0,127);
			
			if (expcc[1] != expccOld[1] && abs(expccOld[1]-expcc[1])>= 5) {
				if (s5[1] == 1) {
					M1.sendControlChange(listCC[setting[2+3]],expcc[1],setting[2]);
				}
				if (s5[2] == 1) {
					M2.sendControlChange(listCC[setting[2+3]],expcc[1],setting[2]);
				}
				if (s5[1] == 0 && s5[2] == 0) {
					M1.sendControlChange(listCC[setting[2+3]],expcc[1],setting[2]);
					M2.sendControlChange(listCC[setting[2+3]],expcc[1],setting[2]);
				}
				

				expccOld[1] = expcc[1];
			}
		}
		merger();
		
	}

}

Credits

andreagregorini

2 projects • 3 followers

Mechanical engineer based in Milan. Free time musician and keyboard player for The Cinema Show prog band. Photography enthusiast.

MIDI Merger and Patchbay

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

The Concept

Working Principle

Building and Programming

Schematics

MIDI ports on serial2

MIDI ports on serial3

Pedals

Shift registers

Code

MIDI merger v1.11.1

Credits

andreagregorini

Comments

Embed the widget on your own site

MIDI Merger and Patchbay

MIDI Merger and Patchbay

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

The Concept

Working Principle

Building and Programming

Schematics

MIDI ports on serial2

MIDI ports on serial3

Pedals

Shift registers

Code

MIDI merger v1.11.1

Credits

andreagregorini

Comments

Related channels and tags