[sdiy] parallax potentiometer mode in analog; improved potentiometer resolution; also, an idea for successful patch storage in the studio

[cheater cheater]

Hi guys,
Reading the recent thread "analog synths with digital controls? how
does that work?", I was wondering if anyone came across a realization
of the "parallax control" idea completely in analog. I first explain
what parallax mode is and how it is better than other control modes,
then derive an equation for it, in three forms, marked by a line of
equals signs (=). Does anyone know a circuit which would allow the
realization of those equations? Later in this email I discuss a basic
design of a possible circuit. Then, I discuss the ability to
arbitrarily improve the effective resolution of any potentiometer;
this is marked by a line of asterisks (*). I also discuss how patch
storage could be improved with several concepts which are new to the
world of synthesis. This is marked by a line of ampersands (&).

Parallax mode control is an idea used to make patch recall work well
without motorized knobs. Let's review the possible ways you can do
this:

1. override - a knob is at position x. A patch gets loaded and has
that control stored at position y. Initially the synthesis engine
receives y, but as soon as the knob is moved (to, let's say, x+d) then
the synthesis engine receives that new value immediately (x+d). That
one is especially unsuited for analog synthesis, unless one were to
(1) remember the value of x at patch load time (2) make a dead margin,
which means that a minimum absolute value of d must be achieved before
the synthesis engine starts getting the new value of the knob.

2. intercept - A patch gets loaded with the control stored at position
y. The knob on the front panel is at position x, which is different
from y. When you move the knob, nothing happens until it achieves the
value y (i.e. the synthesis engine keeps on receiving y as the value
of the control). When this happens, the knob starts controlling the
synthesis engine directly.

The above approaches both have their drawbacks. The first one requires
complex logic for it to work in analog at all, and doesn't allow you
to make small adjustments to the stored patch. The second one requires
you to search around with the knob; then, you don't end up finding the
actual value, you bump into it. This means the control is fixed at y
for a long time and then suddenly starts changing rapidly (because at
that point, the knob already has a lot of velocity) -- that sounds
very bad.


3. parallax mode. In its simplest, it works like this: you have a knob
at some position and a patch with the control at another position. The
movement of the knob is scaled in such a way that, if you move the
knob all the way to the right, it will gradually move the control to
the maximum position; and inversely if you move the knob to the left
it will gradually move the control to the minimum.

Here's how it works technically.

A patch is loaded with the control at position y, the knob has
position x. When the knob is moved to the right by the amount d, that
amount is converted to the fraction of the space to the right of x -
that is, the space between x and the maximal value of the knob. That
is called h.

So for example, let's say the knob controls a value that can go from 0
to 100. Let's say x is at 20, and the knob is suddenly moved to 25.
That means d is 5; the "space to the right" is 80, and the fractional
representation of the movement calculates to: 5/80 = 1/16.

Then, that fractional movement h is applied to y. That is, the value
to the right of y is reduced by the fraction h.

So for example, let's say y was at 45. The "space to the right" was
55, and 1/16 of that is 3.4375. That means the new value of y is 45 +
3.4375.


So let's write a difference equation for this:

(the difference applied to y) = (something calculated from the old
values of x and y and the difference applied to x)

Delta y = ...


If you don't know difference calculus, notice that "Delta y" is a
single value, it is not "Delta multiplied by y", it's just a way of
designating a single value with two letters separated by a space. It's
like any other name, such as "Pop Tarts". The "Delta" on the left is
written as a triangle, i.e. capital Greek Delta, as opposed to when I
would write "delta", which would be written as a minuscule Greek Delta
that kind of looks like a funny loop.

Now let's consider how we calculated Delta y. "Then, that fractional
movement h is applied to y. That is, the value to the right of y is
reduced by the fraction h". So it's actually the maximum, minus (the
old "space to the right" of y, which had the fraction removed)

Delta y = the maximum, minus (the old "space to the right" of y, which
had the fraction removed)

Delta y = max - ( (max - y) * (1 - h) )

Now let's look at how we calculated h: "When the knob is moved to the
right by the amount d, that amount is converted to the fraction of the
space to the right of x - that is, the space between x and the maximal
value of the knob. That is called h."

The equation for h would then be:

h = (the amount of change of x, calculated as a fraction of the complete space).

That would mean:

h = d / (max - x).

We can use a standard notation for "change of x":

h = (Delta x) / (max - x)

Let's plug that into the old equation for Delta y, "Delta y = max - (
(max - y) * (1 - h) )":

Equation 1: Delta y = max - ( (max - y) * (1 - ( (Delta x) / (max - x) ) ) )

===================================

This can be simplified in two ways. Either by solving for Delta y:

Equation 2: Delta y = (max*y + xy + max*Delta x + y*Delta x) / (max - x)

or by transforming to a neat fraction form:

Equation 3: (max - Delta y) / (max - y) = (max - (x + Delta x) ) / (max - x)


Regarding how such a circuit could work: I am assuming that y would be
stored in a capacitor somewhere, and it would be fed a value from the
ADC at patch load; the capacitor would also be fed current
proportional to the first derivative of the knob value (the
potentiometer would output voltage); that current would be scaled by
the difference between knob position and the position stored in the
capacitor. I am not sure how exactly that would be constructed
exactly, but with some thought that can be figured out. One important
element here is a constant-current blocking circuit, which can be
implemented with an RL filter: input connects through resistor to
junction J, junction J connects through resistor to output, junction J
connects through inductor to ground.

Regarding patch storage: one common issue with patch storage is
insufficient precision  when recalling patches, such that patches get
recalled sounding different. Another issue is that in many approaches
the knob is not directly coupled into the circuit any more, which may
mean lag, insufficient resolution of control (when the knob is
stepped), and in bad implementations control-stepping (the value the
synthesis engine jumps in large steps, like a positional switch,
rather than a potentiometer).

The issue of insufficient resolution is solved here by coupling the
potentiometer output directly to the circuit. That means the
resolution of control is again as good as the potentiometer itself and
your fingers will give you.

**********************************

As an added bonus, you easily create a control of arbitrarily high
resolution (analog noise permitting). Simply add a breaker key in the
lead that puts (Delta x-derived) mark-up current into the storage
(y-value) capacitor. Say you want to precisely control your knob at
the very right maximum, say you want to dial in a precise value
somewhere between 99% and 100%. Obviously the knob's travel is not
going to be precise enough -- a tiny movement will sweep over your
whole range. You'd need to tap the knob lightly to make adjustments.
Instead, move the knob to the 99% position, depress the breaker key,
and with the key depressed, move the knob all the way to 0%, then let
go of the key. The full range of the knob's movement now covers this
one final percentage. Need more precision? You can repeat the
procedure again. One issue with this is that even the smallest jerk to
the left will make big adjustments to the value, which will throw off
your calibration (remember, in parallax mode one side is zoomed out
while another is zoomed in) Another issue is that this control cannot
"zoom in" at an arbitrary point, just at the extremes; I'm not
immediately sure how this could be done, but intuition says it's not
too difficult. Perhaps a separate couple of capacitors as voltage
references to store the "parallax range", rather than assume it is
from 0 to max. This could also solve the previous issue.

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

The problem of insufficient precision can be solved by attempting the
best effort with an ADC (12 bit seems reasonable), and then requiring
the operator to fine-tune the value on the front panel. A very common
example here is recalling oscillator frequencies; not only will the
oscillator, due to its analogue nature, have drifted over time, but
the possible values are also notoriously difficult to store and recall
due to the multitude of effects that can display even the most minute
differences.

A possible patch storage scheme for more complicated patches could be thus:

1. Build patch
2. Separate out a simple sub-circuit, for example: disconnect the VCO
output, so that you have only one vco in a sub-circuit.
3. Make a voice recording, which says for example "tune the frequency
of VCO1 until the beating is at 1 Hz". Then, record a 5-second or
10-second sample of the oscillator output (or as long as you need).
4. Add a small amount of the complete patch to your subcircuit. Make a
new recording.

This way, you can save yourself a small tutorial, which will walk you
through the most delicate steps. Then, just play the tutorial back
whenever you wanted to recall the patch and didn't know how exactly it
worked.

A module could be constructed with the following controls:

1. keyboard input (USB keyboard) for entering text, such as patch name
2. RS-232 terminal output, for displaying a list of patches and an
ANSI GUI which would allow browsing and categorizing them. This could
also be used for keyboard input. This can be used with any standard
terminal, such as a VT-220 or a PC running a terminal emulator. As an
alternative, an ethernet port with a telnet or SSH server could be
used. Any number of embedded computers based on the GNU operating
system could be used. If such a computer is used, a direct HDMI or DVI
output could be used for the monitor as well. A possible hardware base
is a Raspberry Pi computer.
3. a button for designating a new step in the patch build-up procedure
4. a button for recording the explanation
5. a button for recording the sound example, and an associated patch-cord input
6. In "patch build" mode, the above buttons skip to the next step,
play back the explanation, and play back the recorded input
respectively.
7. An USB port for a flash drive, for storing the patches.


During patch recall, the procedure could look like this:
1. Locate the patch you want to prepare. You can do so from the
keyboard, by using the search function and entering a name, narrowing
down by category or other settings, and using the keyboard to select
one from the results list.

2. Possibly play back a stored patch demo. This module should always
be connected to the main output, which means it can play back the
sample for you.

3. Start the tutorial mode.

4. The text output displays notes, for example the patch cord
connections you might need to make in this step. You can play back the
explanation recording, if you prefer that instead of reading the text.
You can play back the demo of the patch as it should be at this point.

5. You connect the output of your current patch to the module's input.
This normally gets directed to the main output and speakers. Then, you
press the "sound example" button. The current patch is muted and the
sound example is played back for comparison.

6. You tune up your patch and try to make it sound as close as
possible to the sound example. Then you go to point 5, playing back
the sound example. If you are satisfied that the patch sounds like the
sound example, you press the "next step" button and return to point 4.
If there are no following tutorial steps (and your patch has been
finished), you are done recalling the patch.

I think such a procedure is preferable to scribbling down notes and
trying to guess what the patch should have sounded like. It is a
centralized facility for precise recall of sounds on an analog
synthesizer.

I wonder what everyone thinks of the ideas in this email.

Thanks for reading!