This projects takes another look at the Arduino Multi Mozzi String Synth and takes a slightly different approach to create a simple four-note polyphonic version of the string synth.
To combine the outputs I’m using my Simple Passive Audio Mixer, but that isn’t necessarily required.
It also relies on (and builds in capability to support) the Arduino MIDI Filter.
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:
If you are new to Arduino, see the Getting Started pages.
Parts list
- 5x Arduino Nano
- 4x 270Ω resistors
- 4x 100nF capacitors
- Female and male headers
- Stripboard and jumper wires
- Some kind of MIDI receive module (see Arduino MIDI Interfaces)
The Circuit
Once again, the “circuit” is optional as it could be linked up using jumper wires and USB power, but also once again I’m trying to make it easy to power and chain the boards together whilst supporting a Mozzi Output Circuit and allow me to pass MIDI from one board to the next.
There are now two choices for the RX-TX links.
The previous project daisy-chained the TX and RX links so that the MIDI messages were passed on from one Nano to the next. This allows for a single input linked to the first board and supports true polyphony but isn’t very responsive especially when used with a digital audio workstation sending it whole reams of MIDI data.
So now there is a second option in the circuit:
- There is now a jumper that allows each Nano to either take its RX input from the previous boards RX (so they all see the same MIDI data and can process it themselves) or the previous boards TX (so it will only see a MIDI message if the previous board decides to pass it on as per the previous project).
- There are now power and RX/TX links for a fifth Nano that can act as an Arduino MIDI Filter to optimize away any unnecessary MIDI messages.
Here is a close-up of the jumper headers in the circuit. Note that there is a cut in the tracks between the two jumpers on the bottom line. If the jumper is placed over these then all RX lines are linked together. If the jumper is placed across the bottom two tracks then the RX is linked to the previous board’s TX. This is repeated for each of the “sound” Nanos.
I haven’t put in a jumper for the filter Nano as that will always have its input to the RX pin and pass on its output via its TX pin. If the circuit is to be used in the future without a fifth filter board, then a simple jumper wire can connect RX to TX where that Nano would have been installed.
For further build details of how to get to this point, refer to the previous post.
The Code
The fifth Nano uses the code from the Arduino MIDI Filter.
If the boards are used in the original RX-TX mode, then the code from the Arduino Multi Mozzi String Synth should be used on the other four boards and the filter needs to be configured with the MIDI channel of the boards.
If the boards are using the new RX-RX mode, then each board is essentially now an independent unit using the code from the original Arduino Mozzi String Synth. Of course, if they are all programmed to the same MIDI channel then all you will have is all four synths playing the same notes at the same time, so the essence of this update means that each synth should now be treated independently and have its own MIDI channel and the filter should be programmed to let all four channels through.
There are two other optimizations to the original string synth code that improves the MIDI handling:
- The Mozzi CONTROL_RATE is set to 256. This value has to be a multiple of two. As this increases there is a danger of starving the processor of processing time, but for what I’m doing 256 seems manageable. This has the advantage of reducing the time between checking for MIDI data which makes MIDI handling much more responsive.
- The MIDI library is initialised with the Use1ByteParsing set to false. This means the MIDI library is free to handle all MIDI data sitting on the input queue. When this is set to true (the default) it will only handle one message value every time the MIDI.read call is made. Again this speeds up the responsiveness of the MIDI handling significantly at the expense of less time spend in the updateControl() function itself.
Neither of these updates interferes with the actual audio production from Mozzi which takes place in a higher priority piece of code calling the updateAudio() function.
These updates have been added to the original code, so here are the GitHub links to the two variants:
Closing Thoughts
There are further optimizations possible that could retain the “single instrument” feel of the original Multi Mozzi String Synth. For example if the MIDI filter could use the chaining algorithm from the Multi synth but assign the “next note” to a different MIDI channel to be sent to the right board directly.
Another optimisation might be implementing a MIDI filter on a board with more serial ports so that each voice has a direct connection from the filter and doesn’t see any traffic destined for other boards. This might also allow a faster link between boards than the default 31250 baud rate that MIDI requires.
Another possibility would be to create the combination of boards as a single instrument and use a non-serial port (possibly non-MIDI) protocol between them instead. There are many other inter-board physical and software protocols available on an Arduino – RX/TX serial ports is just one, and the easiest to map MIDI to, but I could also use SPI, I2C or some kind of bespoke raw digital IO linkup. But this would mean that the voicing boards would no longer accept MIDI directly and would always need an interfacing module to be of use.
Kevin
Simple DIY Electronic Music Projects 