At the start of this project I wasn't planning on having any kind of sound/patch storage or management within the vintage toy synthesiser, however as the project progressed I was more and more finding the need to quickly save and recall patches for both testing and demoing the functionality of the sound synthesis engine. In the end I decided to implement an external desktop application to handle this.




Synthesiser patch management allows the user to save the sound parameter settings into a 'patch' so that a particular sound can be quickly recalled at a later time. It is a common features on commercial synthesisers, however I originally decided not to include patch management on the vintage toy synth for the following reasons:

  1. Patch management works best on synths that have relative or stateless controls (e.g. rotary encoders, which just increment or decrement a stored value in the backend) with an LCD for displaying control/parameter values, as opposed to absolute controls (e.g. potentiometers, which set a specific value determined by their position). This is because, unless you have motorised controls, loading a patch doesn't change the physical state of the controls, meaning that with pots it would cause them to be potentially complete out-of-sync with the backend. I didn't want to add an LCD to the piano as it would take away the vintage aesthetic of the object, as well as adding cost and implementation time to the project. Also I like the fact that with pots a user can glance at the panel and instantly see all the parameter values.
  2. Another reason an LCD is so important for patch storage is so that the user knows what number patch they are saving or loading. A minimal patch storage interface could be implemented using a set of toggle switches that represent patch numbers using a base-2 numeral system, however this would have involved an extra set of controls on the panel that I initially didn't think I could add, in regards to both space on the panel and connections to the Arduino Pro Mini.


However as the project progressed I kept finding myself wanting to save the sounds I was able to create with the synth, which would make the device a lot easier to demo once finished. However by this point the front panel was already constructed so adding any extra controls on the synth was out of the question. However after giving it a bit of thought I realised that I could simply implement patch management in a separate external application that runs on a desktop/laptop computer which communicates with the synth via MIDI, which would work with the existing synth hardware. I therefore set about developing a Mac OS X GUI application using the C++ framework JUCE, and you can see the code for this in the project Github repo here.


Having an external patch manager application isn't my preferred solution as it means you'll always need a computer with a MIDI interface to save and load patches, however from an interaction design perspective it could be considered a better implementation over adding an LCD to the synth. I recently attended MiXD 2016, a music interaction design symposium hosted by Birmingham Conservatoire's Integra Lab research group, where keynote speaker Jason Mesut stated that it could be considered inferior to add costly and complex LCDs and displays to products such as digital musical instruments when most of us already carry smartphones/tablets/laptops with us at all times - devices that can easily be used to control other digital devices.


How it Works


The patch manager application, which is called 'VTS Editor', is very simply and just relies on the correct MIDI messages being sent between the application and the synth in order for it to work correctly.


Saving a patch works as follows:

  1. A specific MIDI CC 127 value is sent from the application to the synth to request all patch data
  2. The synth sends back all the current patch data in the form of the parameters MIDI CC messages (the same as the ones that come from the synths panel)
  3. Once the synth has sent all patch data it sends a 'finished' MIDI CC value so that the patch manager application knows it has got a complete patch
  4. The patch data is encoded into lines of text and saved into its own text file


Loading a patch is even simpler:

  1. A patch text file is decoded into patch parameter values
  2. The patch parameter values are sent to the synth as a stream of MIDI CC messages


I've called the application 'VTS Editor' rather 'VTS Patch Manager' as in the future I'd like this application to become a full software editor for the synth (essentially an extended virtual version of the synths panel), however that's beyond the scope of this design challenge. However I have already implemented a couple of extra controls/features within the editor application that aren't related to patch loading/saving:

  • Reset Synth to Panel Settings - triggers the sound engine to be set to the current panel settings. This functionality also happens when the synth is turned on so that the panel and the backend are in sync.
  • Disable/Enable Synth Panel - temporarily disables the synths panel controls (except for the volume control) from doing anything. I need this as unfortunately I'm still getting some very occasional panel potentiometer jitter, so this allows the user to load a patch without any jitter changing the way it should sound. Eventually I hope to get rid of this control once I've fixed the pot jitter issues.


The Interface


Below is a screenshot of the current VTS Editor interface:

VTS editor


A couple of notes on the interface and its controls:

  • Loading a patch is done using a window that displays all saved patch files
  • It includes controls for setting which MIDI input and output the vintage toy synthesiser is connected to


It's also worth noting that I haven't yet finished the general look-and-feel of the interface - eventually I want it to use the same colour scheme and font as that of the synths front panel.


Sound Demos


Here is a quick and rough video previewing a couple of demo sounds I have made with the vintage toy synthesiser.  I'm neither a sound designer nor a keyboardist so don't expect anything mind-blowing, plus I've still got a couple of tweaks to do to the sound engine, however this should give you an idea of the range of sounds that you can create with the synth. There is also a bit of noise (possibly ground loop/hum) in the recording. At the end of the project I'm hoping to do a much better video that covers all the features and controls of the synth, as well as some high-quality patch demos and recordings. Enjoy!



Just to be clear, all sound is coming directly from the BeagleBone Black within the synth itself, and I'm only using the MacBook to send patch change information to the synth via MIDI.