(Teletype) Pre-2.1 Operators and Features


Rounding would be a bit tricky if you wanted a scale other than chromatic, surely?

What I want to be able to do is type the following:

X QNT5 0 2 4 7 9 Y


X QNT5 0 2 4 7 9 IN

And get X quantised to a pentatonic scale. But the post I was originally making, was saying that it’s not straightforward, as there are lots of edge cases. (Doesn’t mean we shouldn’t try though!)


Which is why I was suggesting referring to prior art.

But I’m going to drop out of this thread now. Not sure my comments were actually helpful.


I wonder if there is something in the Ornaments&Crime code that could be leveraged?

Very much in agreement with this.


Don’t sweat it. Take your time :slight_smile: I tried a peek at the source code myself, not as scary as I imagined, but still not quite within my know how.

Re quantisation:

  • I seriously doubt that any of the existing quantisers are context aware. They must have a static strategy for rounding up or down the ill-defined situations. Consider the fact that, to my knowledge, no quantiser offers the melodic minor (where the intervals change depending on whether you’re moving up or down) as an option. Any interesting context awareness would require a non-trivial amount of machine learning.

  • From your list of suggestions, while QNNx does seem to me like the best alternative, it precludes micro tuning. I know I’m not offering a solution, just pointing out the limitation.


I think this looks good - the numbers are the scale steps used aren’t they? Out of twelve possible steps?

I wonder if it would not be easiest way to just always quantize down? I assume that most use cases would imply some kind of randomness as one would program the actual note pitches on a sequencer when it wouldn’t. And in case one would input a more or less linear progression of note pitches it would not make that much of a difference as long as the quantization law is constant.


I’ve always liked unpredictable quantizers. If I want melodic accuracy there are other tools (sequencers, etc.).


I also think it would be nice to be able to support microtonal scales. And have a pony!


I think I’ve done a bad job explaining the problem… one more quick go, then I need to clear my brain for bed time.

So on the whole, quantising incoming CV is a solved issue in the Eurorack space. On the Teletype external CV is represented by the numbers 0-16383.

But in Teletype world, we might also want to fit the numbers 0-127 onto a (e.g.) pentatonic scale. These are numbers that have been created inside the Teletype. That’s where we discussion arises regarding how to handle numbers being exactly half way between 2 notes.

You’d probably be able to get it working on the Teletype for a specific application. The SCLx ops would be useful too. SCLx is the inverse to QNTx.

The syntax would never cope… though you can use the patterns for microtuning.

Yep, it’s 0-11, rather than 1-12 though. Same deal for SCLx.


Would anyone be interested in the turtle being able to optionally interpolate between cells?

(Needed to write this down before I forgot)

(Teletype) 2.1 Firmware Beta (rc2: EVERY et al.)

I guess the same result can be achieved by using CV.SLEW at the end of the signal chain.

I don’t agree for several reasons.

First, I don’t want to use “other tools”, I’d like to keep everything inside my Eurorack system in general and in TT in specific.

Second, if we get a predictable quantizer, those who like unpredictability can add it via DRUNK, RAND, RRAND or TOSS. But it doesn’t work the other way round, i.e. you can’t turn an unpredicatable quantizer into a predictable one.


Assuming that you use the pattern grid for CV data, yes. It can be used for more than that, though.


@wolfgangschaltung, your TELEX expanders can handle some of the quantizing duties for you. They are designed to convert voltage to/from note numbers based on a number of different configurable scales (equal temperament is the default). Many are 12 note scales, but some divide the octave into more/less steps as well. Think of the functionality as auto-tune for your Teletype.

The tuning algorithms use fully rendered tuning tables that are compiled into the firmware. It’s pretty easy to add your own, if you want. I included a bunch of standard and fun ones if you want to exploit micro tunings. They are built out of SCALA files; there is a little utility in my GitHub that helps create your own default set of scales if you are interested. The expanders use these tables to find the nearest pitch and employ a bit of hysteresis to keep things from flopping around too much.

Also, the TXo supports greater resolution than the TT for its output as it has 16bit DACs. When you pass it a note number, instead of a 0-16383 value, it can use the full precision of its DAC to send out the corresponding voltage (or oscillation frequency). This is good if you are experimenting with micro tunings and want things to be more “in tune” with your selected scale.

Now, the expander’s quantization functions are not designed to help you manipulate pitch sets (the issue that @sam was referring to above). The design choice here was to leave that to your TT patch where you have the full language to experiment with.

Here is a patch example that translates equal temperament voltages from TXi IN 1 and outputs them as voltages using Werckmeister Temperament II on TO CV 1. It uses the experimental M! command to pulse the metronome script every 2ms. Use at your own risk. :wink:

M! 2


Instead of passing voltages, TI.IN.N returns a note number. This can then be manipulated or, in this example, passed directly to the corresponding function on the output (TO.CV.N).

There are some more quantization-related functions as well in both devices. For instance, you can also quantize voltages using the TO.CV.QT x y syntax. They are all outlined in the documentation.

Does the above make sense?


Thanks very much for the explanation!

Regarding the unpredictability of quantizers: I wonder (and have not tried it yet!) how the quantizing algorithms react to voltages that are jittery and sometimes touch the “in-between land” 2 quantization steps. Is there some kind of hysteresis used to avoid the resulting notes being as jittery as the input signal?


Yes there is.

It is a pretty simple algorithm that just extends the bounds of a quantization target after it is selected. Also, the TXi has software low pass filters to reduce the jitter on read as well. The unit uses the Teensy’s ADCs, which have 13 bits of usable resolution, for both the PARAM and IN.


it would be great if we had a shorthand increment/decrement alias like ++
something like PN X Y + PN X Y 1 I think is really long for what it does.


That would be difficult to implement. I’ll explore what would be required, but I think it would involve leaving a pointer on the command stack in addition to the value, and as such would be quite a change. Additionally, these pointers would only be used by increment and decrement, so don’t provide much value.


this would be nice, yes, but it’s really outside the language as it is now. i’d like to avoid any outlandish operators like this.

rather, if we wanted to add some sort of operator like PN.ADD that’d be fine.



is increment. but you can change 1 to -1, or 2, or whatever.


PN.ADD would be useful as pattern slots can easily be used for storing variables.
I was thinking more in a general context as incrementing values required extra lines in my scripts because of their length, but yes ++ does seem a bit off in the tt syntax.


I’m pretty new to teletype, so excuse me if I’m incorrect. But I think what you’re suggesting is already implemented in the form of the O operator


I guess you could:


But that’s no more succinct, and it robs the O of carrying other meaning in the script.