Patches

[jbv]

Hello, techno folks

After a few weeks a subsciption to the above listed mailing-lists, 
I noticed that the discussions were mainly about circuitry design 
(which chip to use in VCOs and the like). Of course, lots of very 
interesting and useful infos have been posted on such topics.

As for today, I'd like to enter into a discussion on another topic on
which
I found very few contributions, but which is, in my opinion, one of the
biggest pain-in-the-ass of DIY synths : PATCHES.
I'm not sure whether it is part of the "Favorite designs" discussion...

When I designed my first synths modules (15 years ago), designing and
making PCBs was the first step to overcome. Now it's easy and cheap
because lots of tools are available for design and PCBs can be done
in limited series and for little money by various companies.
Soldering components & ics has always been the easiest part of the job.

But once everything is done and tested, here comes the final step :
putting the circuit into a box, and designing accesses to all controls
(knobs, switches...) and, of course, patches.

Several DIY projects (like the Formant) approach the problem as follows
:
one front panel for every module, featurings all controls and in/outs.
Needless to say that, as soon as an exotic or awkward patch
configuration
is tested, everything gets quickly confusing, and it gets quite
difficult to
access most of the controls. And when it doesn't sound as expected,
it's quite hard to figure out what to change. And of course, most of
patch configurations are almost impossible to reproduce.
This is, I think, one of the main reasons that made preset synths so
popular
in the early 80s.

For the above reasons, I've tried to imagine alternate ways and possible
solutions.
I must point out that I'm not only concerned by the technical /
financial side of that
problem (what kind of chords/plugs to use...) but also by what it
implies in the
ergonomics field.

A) 15 years ago, I found a solution : I used to gather all ins & outs on
one side
of the front panel :

					oooo  0	0
ins & outs --->		oooo	0	<--- controls
					oooo  0	0
					oooo  0 0 0

By convention, each row of ins/outs were related to a set of controls on
the
same level (in volume, out volume, CV in, etc.). I also used to use a
color code
(green plugs for ins, red for outs...).
That way, patch chords almost never interfered with controls, patch
configurations
were less difficult to memorize, and modules could be assembled in
mirror
in racks as below :


module 1--->	O  O   oooo	oooo   O  O		<---module 2
				O      oooo	oooo   O O
				O	O  oooo	oooo   O  O

B) the other solution was to used matrix patches (like in the EMS
models, I think)
where all possible connections are already wired, and some of them can
be validated
by the use of mini-jacks.
This solution erased the complex patch chords problem, and also
introduced a more
rational arrangement of ins & outs. Configurations were also easier to
memorize and
reproduce. However, as far as I remember, these matrix were hard to find
and quite
expensive at that time.
Does anyone know whether the situation is still the same ? (may be such
items
disapeared long time ago...)

C) the third (and quite exciting) approach of the patch problem I've
been thinking of
is a software solution, the idea being to get rid of all plugs and
chords.

Here are some thoughts about it (I still need to spend some time on it,
and I welcome
any suggestion and/or experience in that field) :
		- imagine a utility software that allows "virtual" patching between
"virtual" 
modules (a little bit like OMS / PatchBay on the Mac)
		- the patch configuration data are sent to the synth as MIDI sysex
messages
		- all the patching inside the synth (and between the "real" modules)
are handled
"digitally", that is through a micro-controller and complex analog
multiplexers.
Needless to say that this is the part of the idea on which I need to
spend some more
time. Why ? Because some problems appear right away :
			* if the project features a large number of modules, complexity of
analog multi-
plexing will grow exponentially (or so) with the system.
			* therefore, the first idea that comes in mind is to A/D all ins, and
let the
software (burned in the ROM of the controller) redistributed signals to
the relevant outs (via D/A) according to the MIDI data received from the
computer.
			* but then, a new difficulty concerns the amount of incoming signals
to
be sampled, and the ideal sampling frequency.
			* at first, it seems that CV signals and audio signals must be
considered
from different points of view : 100 or 200 Hz looks like an acceptable
sampling frequency for CV signals (keyboard CV, ADSR, etc.), but audio
ins/outs (when used as control signals) require a much faster sampling
frequency (44.1 KHz actually), which is almost impossible to handle
on most uControllers (run at 12MHz or so) and for a large number of
signals (more than 5 or 6).
Of course, it's possible to handle audio signals (which are fewer
than CVs and gates) in a traditional way (patch chords). But what
if I want to re-route audio signals in CV inputs ?

The soft side of this last approach is exciting, for it allows full
re-use of each configuration. It can also be programmed (patch
configuration changing under certain predifined conditions).
But the problems of the hardware side of thate idea aren't so easy
to overcome.


So, I'm wondering if anyone already worked on something like this.
Or may be, for obvious reasons that I don't clearly see (mainly
because it's quite late here), the whole thing goes straight to a dead
end.
Or may be there are elegant alternate solutions which I haven't
imagined...


Regards - jbv