On tiny voltages. precision, and irrational (non-terminating) decimal numbers
Zero volts is easy, but what does it give you for an E?
0.416666687 volts? 0.40? 0.4166666666666667?
If you feed the vco a known 0v input, or no input at all, and turn on it's quantize function,
does the oscillator jump from C to C# ? It should according to what you wrote.
If it does, maybe it is broken, or just wrong, or is off calibration.
- not one of them produces the results the internal quantizer does
It's not data. There is no 'C' to be recognized on input.
It doesn't know, and all quantizers can do it differently.
Precision is a compromise that computers and we humans apply when choosing how many digits to represent.
The difference between semitones in 1v/oct is ~0.08333333 volts.
(with more ‘precision’ it’s closer to 0.08333333333333332871)
This is a non-terminating repeating decimal. It has an infinite number of digits,
so you could say it has infinite precision in its exact mathematical form, and internally in our voltages,
but that’s not how we talk about those numbers.
If we’re set up to play a C1 if fed 1.000000000 volts, when does the quantizer jump to C#1?
At 1.00100 volts? Or at the more correct 1.08200 volts?
Will it jump to B if it’s fed 0.999 volts?
It could, and in a very few case, that would be correct.
A quantizer rule that says:
‘only an exact 1.0000000v is a C1, anything below is a B0, anything above 1.0000000v is a C#1’
isn’t going to give you that C1 very often, if ever.
What are possible internal quantizer rules to play a C1?
Here's a jump-when-halfway-to-pitch quantizing design:
A 1v/oct quarter step would be ((1.0/12.0) / 2) = ~0.0417
So, if it is fed a voltage between 0.583v and 1.0417v it outputs 1.000 volt (our C1).
Below 0.583v, it’s a B0, so we round down and output (1.000 - 0.0833) = ~0.917 (our B0).
Above 1.0417, we round up to ~1.083333v (our C#1).
We spread this rule across a 10v range and we’ve got a workable chromatic scale quantizer.
But the start and end points of those threshold windows are arbitrary and implementation specific.
Maybe it’s a hard-coded table. Maybe it has to accommodate a slow or meh resolution A/D converter.
(Remember we’re dealing in differences of less than 1/12 of a volt). They all can (and will) do it differently.
If your feed device’s idea of start-end windows are different than your quantizer's, and they probably are,
you’ll get those semitone jump errors that you’re hearing.
--