Controlling an Arduino Wavetable Synthesizer with MIDI and Raspberry Pi

In our previous article, we used what we’d learned about the I2C bus and about manipulating analogue voltages to build an Arduino wavetable synthesizer that we can control using the Raspberry Pi’s I2C bus.

This primitive configuration works. But it offers a limited range of notes, and you need to type out Python code to play them. This is not a great aid to musical inspiration.

Wouldn’t it be much better to have every note available, and to sequence them visually?

It turns out that it’s easy to do all of that by connecting existing software to our synthesizer using the Musical Instrument Digital Interface, or MIDI protocol.

What is MIDI?

In the early days of electronic music, there was no standard way for electronic music devices to send and receive detailed instructions to each other. Different manufacturers were developing their own systems, which really restricted musicians in how they could use them together.

In 1981, Dave Smith and Chet Wood of Sequential Circuits proposed the Universal Synthesizer Interface as an industry standard that any manufacturer could use. Representatives from Korg, Roland, Yamaha and Kawai all suggested modifications, which led to the MIDI standard in 1983.

MIDI doesn’t send any audio or sound recordings. It’s a lot more like sheet music. Instead, it sends instructions for what notes are to be played, for how long, at what intensity and so on. The instrument uses these instructions to produce the audio.

MIDI specifies a number of standard hardware connections, which we won’t use here, though they are of obvious interest to device builders.

For this project, we can handle our MIDI messages “in the box” with software.

Your Raspberry Pi is Already MIDI Enabled

Raspberry Pi OS handles MIDI messages using the Advanced Linux Sound Architecture, or ALSA. This is part of the Linux kernel, and lets you route MIDI messages between programs and devices.

To make use of this, we need to install two things: a sequencer program, which generates the MIDI messages, and a Python module to receive them.

Installing a Sequencer

For the sequencer we can use Seq24, a simple and lightweight MIDI sequencer which we can install from the repositories. First, update your operating system:

Then install Seq24.

That’s it!

Connecting This to Python

For a Python module to handle MIDI ports and messages, there’s Mido. To connect this to ALSA, we also need the python-rtmidi back end. Let’s install them.

Now open the python interpreter and import Mido.

To open a MIDI input port for our Arduino synthesizer, use this command:

A MIDI port named Arduino will now be available in ALSA.

Testing That This Works

Click on the Raspberry icon in the top left of the desktop environment to open the application menu and then select Seq24.

You’ll see a window full of bracketed areas. These are sequence containers. Right click on one of them and click New to open a sequence editor.

Click on the button on the left and you can select the Arduino.

Now switch back to the Python interpreter and type a function to display the MIDI messages as they arrive.

Now return to the sequence editor and click on some of the piano keys. You should see note_on and note_off messages appear on the screen, with a number to indicate which note.
Press Control+C to exit this loop when you’ve played around enough.
Can you see where we’re going here? Instead of printing these messages out, we want to write a byte to the I2C bus to tell the Arduino to play the note.

Adjusting the Arduino Sketch

If you need only the notes our synthesizer is already configured to play, you could use the sketch from our last lesson. However, this is a very limited range.
It’s easy though to calculate a frequency from a MIDI note number, using this formula.
The range of MIDI notes goes from 0 to 127. We can pass integers between 0 and 255 in I2C byte, so if we use half of these for “note on” messages, we have 128 to 255 left for control messages.
Let’s use 128 for a “note off” message. If we were making a polyphonic synth, we’d need to specify which note. Our monophonic synth will never have more than one note playing at a time, so we only need the one instruction.
Putting this all together, we can rewrite the readInstruction function like this:

Save this sketch and upload it to your Arduino Uno.

Writing Commands to the I2C Bus

Now switch back to the python interpreter and open the I2C bus, just as we did before.

Now try writing some values to the I2C bus to see if you can make some noise.

Are you hearing the notes? Great.
Now write a loop, similar to the one before, that writes bytes to the I2C bus instead of printing messages.

Now run this loop and try clicking the piano keys again. You should hear the synthesizer play.

You can now get sequencing!

Further Reading

If you need help figuring out Seq24, check out this tutorial.
There’s a lot more to the MIDI protocol than note on and note off messages. If you want to know all about it, this video series by Andrew Kilpatrick gets right into it:

Be sure to check back here soon, because we’ll be covering how to add a simple analogue filter to this synthesizer, to get a much more varied timbre.