Embedded united – Controlling a beagleboard synth with an arduino

About a week ago, reading about the CCRMA satellite workshop on “Interactive design with open embedded computers”  – see here and here – made me realise I had to give a go at controlling my beagleboard hosted digital synth using Critter and Guitari’s Arduino pocket piano.

The great thing about any arduino shield you buy – or any arduino based  project for that matter – is that in the end all you have is an empty hardware shell that you can reconfigure at will to serve other purposes through programming.
If at first my interest for the arduino piano was to explore it as a standalone synth module and what type of synthesis you could do with such a basic configuration, nothing prevented me to use it as an interface to pick up the knobs and buttons value and send them to a more powerful synth engine – like the beagleboard.

But why?

You may wonder why there could be any value to do such a thing. After all, the beagleboard is a potent little computer and plugging any usb MIDI controller just works outside of the box so you’ve got plenty of controlling options…

What suprised me the most when I developed the arduino squealer synth – and recently when playing with a home grown prototype of the audiono – was that no matter how crude the synth engine was, the fact that you had fine control of the synthesis parameters made it extremely alive. As I’ve written already before, I find it extremely puzzling that in this age of  high tech computing where software companies put so much effort in developing complex synthesis techniques, nobody in the industry really cares that to interactively control these synth, everyone is pretty much limited to use the mouse or controllers that have 127 pathetic values.

Compared to that, the resolution of 1024 values that the arduino provides is a huge leap forward and allows a lot more exploration for subtle sweet spots.

Connecting the boards

Getting the arduino and the beagleboard to talk together isn’t a big deal. The arduino has an extremely widespread usb serial port and since the beagleboard runs a standard unix distribution, all you need is to install the FTDI drivers for the serial port to appear. After that, it’s just a matter of having two piece of software (one on the arduino and one on the beagleboard) to agree on the way to communicate.

In order to make things simple, I chose a sub-optimal communication mechanism where the arduino would send text message on the serial line whenever the analog value of the potentiometer would change. Something like

c0:1FF

indicates the first potentiometer changed to the HEX value of 0x1FF.

In terms of communication it’s a bit of data overkill but using the fastest ‘safe’ baud rate reported for the serial port – 115200 – it’s plenty enough for testing 3 pots. MIDI isn’t so much better anyway

On the other side, all beagleboard synth has to do is to open the serial line, listen to incoming data and map the pot value to the internal synth parameters.

Self oscillating filter sweep

To demonstrate the result, I’ve recorded sweeping the filter frequency of a self oscillating LPF using two setups:
First using the MS-20 vst emulation inside Ableton Live and doing the sweep using a usb MIDI controller and then using the beagleboard synth controlled through the arduino pocket piano pots. You can clearly hear the stepping that occurs in the first one while the second one is completely clean. Even though the two filters are fairely different, the difference of behaviour in this case is exclusively due to the different resolution mechanism of the controller

Conclusion

So, if like me, one of your interest in making software run on embedded platform is to be able to interact with a synth in a more ‘physical’ way and not standing behind a DAW with a mouse, having a ‘controller shield’ coupled with the beagleboard make a LOT of sense (or have everything sitting tight together like the beaglebone) . For that reason, I’m eagerly waiting to see if Chris Randall’s BeepCat proposal will ever see the day and, in the mean time, will work on adding a lcd display to the arduino so the beagleboard can display stuff.

1 comments

  1. Hear! Hear!
    Way to much effort goes into compensating the drawbacks of old technology like MIDI!
    Regarding the communications protocol, I agree, it could be much more compact.
    Your current implementation ‘burns’ a lot of the almost 4-times speed advantage over MIDI using this text-based approach.
    (on a side note, I’d love to find out how to speed up serial coms beyond the 115200 bd, USB should be able to handle it)
    Nice article! It shows the way to go! 😉

Leave a Reply

Your email address will not be published. Required fields are marked *