Arduino MIDI Filter

I am working on something that might allow several of my projects to come together, but one issue I’m having is the overheads of processing unnecessary MIDI traffic are causing delays in playing for some of the modules.  So I thought I’d create a MIDI filter that can be used to see all the traffic and filter out any not on a specific channel – sort of like a “MIDI co-processor”.

It turns out this is relatively simple to do.

• I take another look at this idea in a follow-up post here – Arduino MIDI Filter – Revisited.

Warning! I strongly recommend using an old or second hand keyboard for your MIDI experiments.  I am not responsible for any damage to expensive instruments!.

These are the key Arduino tutorials for the main concepts used in this project:

• Arduino MIDI Library

If you are new to Arduino, see the Getting Started pages.

Parts list

• Arduino Uno or Nano
• One of the Arduino MIDI Interfaces
• Source of MIDI data and something to send it to
• Breadboard and jumper wires

The Circuit

This utilises the RX and TX pins using, as you might expect, RX to receive the full, unfiltered MIDI message stream, and TX to send out the filtered stream.

The Code

The basic process is as follows:

Look for MIDI messages and when found:
  Check if it is on a channel we are interested in, IF NOT ignore
  Check if it is a MIDI command we are interested in, IF NOT ignore
  ELSE send the MIDI message

There are several ways that the choice of channels can be specified.  I opted for a “bitmask” as there are 16 MIDI channels, I used a uint16_t type variable – one bit for each channel. If a bit is set to 1, then the corresponding MIDI channel is passed through the filter.

The only thing to watch out for is that the MIDI library may indicate that there is no specific channel associated with a command – this is the case with system exclusive messages for example, so I have to watch out for that.

Also the MIDI library (and MIDI channels) are numbered 1 to 16, but to use as a bitmask I need values 0 to 15.

The code to check the filter looks like this – this will pass through MIDI data on channel 1:

// Use binary to say which MIDI channels this should respond to.
// Every "1" here enables that channel. Set all bits for all channels.
//
//                               16  12  8   4  1
//                               |   |   |   |  |
uint16_t MIDI_CHANNEL_FILTER = 0b0000000000000010;

// rest of code in setup()

void loop () {
  // rest of code in loop()
  byte ch = MIDI.getChannel();
  uint16_t ch_filter = 1<<(ch-1);
  if (ch == 0) ch_filter = 0xffff;
  if (MIDI_CHANNEL_FILTER & ch_filter) {  
    // Now we've filtered on channel, filter on command
    byte cmd = MIDI.getType();
    switch (cmd) {
    }
  }
}

Once I know the message is on a wanted channel I can look at the MIDI command and further filter on that.  In my case I only want to pass on MIDI Note On and Note Off messages.

Putting one of these filters on front of my other synth modules has significantly reduced the overheads of having to process and ignore unwanted MIDI data.

Find it on GitHub here.

Update: This is an update to this code which adds optional “send a program change message” functionality here: Arduino MIDI Filter – Revisited.

Closing Thoughts

This is the kind of processing that would be really useful to be able to embed in a MIDI shield itself – sort of like a “MIDI co-processor” but the shield would need some processing power first.  It would also be nice to be able to select the MIDI channels to pass through using switches or jumpers.

Maybe a simple Uno shield could support an Arduino Nano “co-processor”.  But that might also be a little over the top.  There are other smaller microcontrollers that might be able to do the job instead.

Kevin