teletype and friends

there are many amazing things teletype can do. this thread is to talk about one aspect in particular - the fact that teletype is perhaps the perfect companion module that exists. teletype is often treated as something that should be the centre of a patch - rightfully so, considering how powerful it is, but it can be just as powerful acting as an expander or a controller to some other module.

i2c controllable modules (of which there are many now) are the obvious example, of course, but you can also trigger things, generate gates and CVs and simple triangle LFOs using the outputs (or more complex LFOs and envelopes using something like telexo or just friends). you can generate MIDI with i2c2midi module. more importantly, you can script actions - and thus add functionality to an existing module.

this thread is to talk about such uses - how do you use your teletype with other modules? what did it allow you to achieve that wasn’t possible or was difficult to do with the module itself or other modules?

this posts talks about some of the ways to use teletype as a controller or expander: Teletype concepts and thoughts - #2 by scanner_darkly

and other relevant threads can be found here: A user's guide to the wonderful world of teletype ⌨ (check “things you can connect” and “i2c” sections in particular).


It is groundbreaking to me, teletype changed my perspective and ways of playing to modular. It’s a conductor if you will. Even a simple function like TR.TOG and IN can make other modules react, and more importantly not react. With the firmware 4.0 (thank scanner_darkly and friends for making it happen) I would write a simple patch notes on dashboard, to help memorize what the script is about, and the core connection with modules, I can easily rebuild the foundation of a piece and leave room for live patching, sort of improv on a pre written base.


here is an interesting use case: teletype as a tool to control 2 piston honda modules at the same time. i recently got some unidentified wavetable ROMs, and the easiest way to check what they are is to compare them with the known ROMs.

there are 16 wavetables on each ROM with 16 waveforms in each. you can scan through them using 2 knobs/inputs: hither (position in a wavetable) and yon (wavetable selection). to compare wavetables i need to scan through each one - simple enough to turn both knobs at the same time, but why not automate this with teletype?

first, i patch CV outputs - CV outputs 1/2 go to the first honda’s hither/yon, CV outputs 3/4 to the second. PH expects CV range 0…5V, which is easy enough to do on teletype. let’s use the PARAM knob to scrub through hither on both. first, set metro rate to something fast: M! 5 (the exclamation mark allows metro rate to be set below 25ms). and here is the metro script:

CV 1 SCL 0 V 10 0 V 5 PRM
CV 3 SCL 0 V 10 0 V 5 PRM

SCL is a short version of SCALE and PRM is the short version of PARAM. the default range for the PARAM knob is 0…16384 which could also be expressed as 0…V 10. so the script simply is: take the PARAM knob value and scale it from 0…V 10 to 0…V 5 range (which is what PH expects) and send this value to CV outputs controlling hither on both modules.

trying this out i immediately run into a small issue - the two modules respond slightly differently, so i don’t get the desired simultaneous response. thankfully, this is exactly the kind of thing that is easy to fix with teletype. let’s calibrate and use pattern bank 0 to store calibration data for all 4 CVs. first, initialize it by executing L 1 4: P I V 5 - this sets the default maximum values to V 5. i also replace V 5 in the script with the calibrated values:

CV 1 SCL 0 V 10 0 P 1 PRM
CV 3 SCL 0 V 10 0 P 3 PRM

now i can change the values (a handy shortcut here is using [] keys to increment/decrement values in a cell without having to type) while also turning the knob. one of the greatest PH quirks also helps here - when you’re right in between 2 wavetables, it’ll flicker between both, so as long as both do it at the same time it gets me close enough. calibration values could also be stored in variables but using a pattern bank means the values will get saved with the scene.

so now i can use teletype to scrub through wavetables or waveforms simultaneously on both hondas - neat! what else can we do? teletype allows you to slew CVs - let’s do that, and let’s use the PARAM knob to control the amount of slew. the metro script now looks like this (i move the above script to script 7 so i can use it again if i need to recalibrate which i found i do have to repeat every now and then):

J SCL 0 V 10 5000 500 PARAM
IF > PARAM 16300: J 0
L 1 4: CV.SLEW I J

the 1st line scales the PARAM value to 5000…500 range (the value is treated as milliseconds). the 2nd line allows me to set slew to 0 when the knob is fully CW. 3rd line updates slew for all 4 CV outputs, and the final line prints the slew value on the live dashboard - to see it i need to do a couple of things: first, open the scene description for editing with alt-esc and add a line SLEW %1 MS, and then execute LIVE.DASH 1 - this will turn the dashboard on and i can now see the value as i turn the knob (i also add it to to the init screen so that it loads the dash automatically):


now we can hear the sound of atom splitting by simply throwing random CVs at hither/yon (L 1 4: CV I RND V 5) and controlling how fast it morphs with the PARAM knob. fun!

back to the original task - let’s add a script that scrubs through a single wavetable:

CV 1 P 1; CV 3 P 3
DEL CV.SLEW 1: CV 1 0; CV 2 0

very simple - set both CVs to the max value (using calibration data from the pattern bank), then, after they reach the max value, change them back to zero. we can still use the PARAM knob to control

(since CV.SLEW also can return the current slew value, we can use it with DEL instead of specifying the actual value so if we change it, it only needs to be changed in one place).

and another script to step through wavetables:

T % + 1 T 16
CV.SET 2 SCL 0 15 0 P 2 T
CV.SET 4 SCL 0 15 0 P 4 T

variable T is used as the wavetable index, so we increment each time the script is triggered and wrap it back to 0 once it reaches 16. then the value is scaled to the actual voltage, and both CVs are set to that (using CV.SET so that it doesn’t slew since we want to step through instead of morphing).

and with that i can now test the ROMs very easily:

i could use other modules to achieve this, of course, but it wouldn’t be as easy or as immediate as it is with teletype - and now that i have the scene, i can use it whenever i need it.