Teletype haiku

I thought I’d share something I made with the binary quantiser haiku. Here I’ve built a script around it that plays a 6 voice prolation canon (where each of 6 voices play the same pattern but at different speeds and different transpositions within the scale). The speed is controlled by triggers from meadowphysics and the transposition by TXi. The voices are Just Friends, Plaits and Rings. The scales are: 1, 137 and 1165 :slight_smile: Hope you all have a restful festive break!

Full version:

Instagram clip:

7 Likes

a fairy simple script (but a huge discovery to me). a short decay envelope with end of cycle trig out (decay amount controlled by PARAM knob)

#1

CV.SET 1 V 5; CV.SLEW 1 PRM
DEL EXP PRM: CV 1 0
DEL PRM: TR.P 1 -- you can patch the TR 1 to IN 1 to make it recycle

or replace the last line with

DEL PRM: $ 1

i found that it would be a bit more pleasant for adding EXP (expontenial) on second line.
to avoid strange behavior, it is better set min 164 or above by use of PARAM.SCALE min max in I script.

thinking of what to do a adjustable AD function generator. any idea?

3 Likes

Nice! To make it have an attack slope too then you could move the slew to the start of the script and use CV rather than CV.SET for the attack part I guess.

I think it should be possible to make a full ADSR type envelope with a bit of work and using the new POL operators which allow a script to be triggered at the end of gate as well as the start… I wonder if it could be done as a haiku? Sounds like a challenge :wink:

Ok, this works as an ADSR, based on @vinc’s lovely idea. You need to mult your gate into both the first and second trigger inputs (could probably get around this by checking and changing script polarity in the one script but this would likely take it over the haiku limit!).

#1
CV.SLEW 1 A; CV 1 V 10
DEL A: $ 3

#2
DEL.CLR; CV.SLEW 1 D; CV 1 0

#3
CV.SLEW 1 B; CV 1 C

#I
$.POL 2 2

The variables A,B,C and D contain the ADSR values. So, you can set them by typing something like this at the live prompt:

A 100; B 500; C V 1; D 500
6 Likes

I’m currently experimenting with a Hertz Donut mk2 alongside a mk3 to decide which I want to keep (if not both). One thing the mk3 does that I miss on the mk2 is a mode where the modulation oscillator quantizes to pleasant FM ratios. So I thought I’d create a tool for Teletype to generate those offsets, so I can turn the Param knob and have it sweep just those clean ratios.

What I do is set green tracking mode, turn the coarse modulation frequency down to 0 and patch CV 1 from Teletype to the V/OCT modulation input. I set TT’s param knob so A is 3, and fine-tune the modulation osc so the ratio light turns green.

M:
A / PARAM 1024
CV 1 PN 0 A

I determined the pattern values by ear:

740
1410
1833
2370
3055
3340
4109
4971
5650
6178
6610
7060
7333
7862
8300
9230
5 Likes

Studying other people Teletype codes, I came across your haiku and I’ve had to try it. Very nice code!

4 Likes

extracting this from another post: sequence sequencer.
sequence scripts instead of notes!

#I
G.BTX 16 0 0 1 1 1 0 0 16 8
Z 16

#M
G.CLR
G.REC T 0 1 8 -2 -2
L 1 8: $ * I G.BTN.V + T * I Z
T % + T 1 Z

use this with grid or with keyboard in grid visualizer mode. there are 8 rows of 16 columns, representing an 8 track 16 step sequencer. when a step is on it will trigger a corresponding script.

in this demo scripts 1-4 play a note / a chord / a strummed chord (using disting ex with wavetable algo) and scripts 5-8 control the wavetable and filter parameters and delay multiplier on disting ex #2 (running augustus loop delay):

https://www.instagram.com/p/CKsJQSPh6LO/

edit: fixed a small error, thanks to @renegog for spotting it!

8 Likes

My first Haiku!
Revolves around sending a pattern of bipolar VV values from Txo to the instruo Lúbadh’s speed input.

Assuming the playback speed is set as 0 on the Lúbadh:

VV -260 reverse x4
VV -125 reverse x2
VV -35 reverse x½
VV 35 x½
VV 65 x1
VV 125 x2
VV 260 x4

#M
M 900; $1

#1
TO.CV 1 VV P.RND 0
P.N 0; P.L 8; CV 1 V RAND 5
EVERY RAND 5: TR.P 1; TR.P 2
EVERY RRAND 4 6: TO.CV 1 0

https://www.instagram.com/p/CMYJCpFh9H7/?igshid=1t2n7num06law

4 Likes

A little pattern save/recall haiku for adding to scripts with pattern sequences less than 32 steps.
A trigger to 7 will save step 0-31 of pattern 0 to step 32-63.
A trigger to 8 will replace your current pattern data with whatever was in save bank.
This can be done while the pattern is playing at any time without interrupting anything.

Good for making a sequence, letting it devolve into randomness and then returning to the original sequence. I came up with this for a Q bit bloom style fractalising sequencer I am working on that needed to remember the original sequence while replacing the working pattern with new fractalisations.

#7
P.N 0
L 0 31: J P I; P + 31 I J

#8                                 
P.N 0
L 32 63: J P I; P - I 31 J

Its pretty simple.
Its a loop that sets J as the pattern number at the index of the current loop number.
It then adds 31 to the loop number, and sets the pattern number at this new +31 index to J.
Script 8 does the same but in reverse, taking the number from index 32-63, setting J to that, then taking 31 away from the index number, and setting that pattern number to J.
This can be repeated for up to 3 patterns in 1 script e.g:

#7
P.N 0
L 0 31: J P I; P + 31 I J
P.N 1
L 0 31: J P I; P + 31 I J
P.N 1
L 0 31: J P I; P + 31 I J

But with 7 and 8, this would be 12 lines not 4, and wouldn’t be a Teletype Haiku.

9 Likes

Let’s give teletype its own voice with this totally ridiculous teletype drone haiku! I was hoping to be able to play with this at the teletype live coding event but sadly can’t make it, so here it is for your own fun.

Just mix the four trigger outs as if they were audio. I strongly recommend putting them into a filter first and then oodles of reverb for dronetastic enjoyment.

#M
TR.P 1
EVERY 2: TR.P 2
EVERY 3: TR.P 3
EVERY 4: TR.P 4
EVERY 1000: M! RRAND 1 10

#I
L 1 4: TR.TIME I 1; M! 5

Now you can get rid of all those oscillators in your rack that are taking up valuable HP :-).

This is with teletype as the only “voice” through blades into mimeophon and FX AID:

EDIT: you may find you get different tones out of teletype depending on which screen is showing. It’s part of its charm, I feel. You can also do this with CV outs instead of triggers in order to control the volume of each part of the drone voice, but then it isn’t a haiku. Have fun trying to make it track volts per octave :wink:

21 Likes

Control Vivo

#I

O.WRAP 1
O.INC 1
O.MAX 5
O.MIN 0

#M

L 1 5: CV I V O

Fool around with the L values to have the movement shift backwards or forwards.
Change the O.MAX to have the movement wrap around on the previous outputs.

1 Like

is it meant to be L 1 4? unless you use ansible as a teletype expander in which case you can address 8 CV outputs with CV x.

you could also do CV I V % O 4 and play with different increment values.

1 Like

I’d say L 1 5 is an optimal starting point as it leaves one “cycle” of the loop out, and allows for the voltage values to dim a bit before the “cycle back” to the beginning. I hope it makes sense, it’s easier to see the effect in practice. Changing it to L 1 4 makes it a shorter cycle and the movement isn’t as gentle, but it still works. Funnily enough an L 1 6 makes the pattern stop, not sure why, the whole thing works in the same optical illusion way that car wheels can seem to go backwards while you’re on the road, some values make the pattern move backwards, so maybe L 1 6 makes it stop.

Good point! Will try it out, seems like a fun thing to try.

1 Like

that’s because there are 6 possible values for O with your O settings, so a loop with 6 iterations will result in O having the same value at the end of the loop as it did before the loop.

Lil simple Haiku Jam that centers on a nice chord (arp) progession being switched a d with a bit of logic for octave jumps.

A single jf voice incrementally switches between 4 patterns of arps-- C, Eb G & Dm7. random seeded logic of the same incremental number determins whether the sequence will be transposed up by up to 3 octaves.

instruo Lúbadh, MAKEN0ISE Morphagene (in Time Lag Accumulation) and Mutable Instruments Clouds (Looping Delay) turn the single voice sequence into a thick melodic blanket.


JF.MODE 1
O.MIN -1; O.MAX 3; O.INC 1


METRO

EVERY 8 A O; JF.VTR V 10
L 0 4: PN.START I 0
IF EQ O RND 3: JF.SHIFT V 1
ELIF RND 4: JF.SHIFT V O
ELSE: JF SHIFT V 0
JF.VOX 1 N PN.NEXT A V O


PATTERNS

0 4 7 2
4 7 11 5
7 11 14 9
12 16 19 12
7 Likes

I’ve recently crafted a little Teletype poem I call the “Brain Age Theme Arpeggioid Generator” to learn how to use the Stack properly.

// M -----------------------
$ 1                          // a clock

// 1 -----------------------
S: TR.P 1; CV 1 N DRUNK      // put a pulse and a CV on the stack
X ADD X 1                    // a typical counter
IF GT X 16: S.POP            // let the carnage begin !!
IF == X 32: S.CLR; X 0       // and stop it.
PROB 5: DRUNK RND 4          // reset DRUNK every once in a while
PROB 50: DRUNK; DRUNK; DRUNK // ( ^з^)ノ⌒♥*:・。.

What this does is simple: quietly generate 16 stack commands to drive a voice, drop them all like a payload, rinse and repeat. Kinda like the speed-dial sounding arpeggio in the Brain Age theme, you know the one.

The second I tried the Studies out I instantly fell in love with Teletype and I’ve been slowly working my way to unlock its maximum potential. It really does have no limits as far as I’ve been able to toy with it.

10 Likes

Little morning Haiku routine!

Metro

A + 1 WRAP A 1 12
B + 1 WRAP B 1 9
IF EQ A B: C 1; M 200
ELSE: C 0; M RRND 190 200
TR.TIME 1 * A 10; TR.P 1 C
CV 1 QT.S N RRND A 24 0 7

https://www.instagram.com/p/CUW7_mDlOWa/?utm_medium=copy_link

4 Likes

I’ve designed a small 4-verse haiku that’ll turn one of TT’s CV outs into a “Skewable Envelope Generator” (a la 4ms PEG) with some super-fast slewing.

// 1 ---------------------
PARAM.SCALE 0 Z; Z 500     // set Z to desired envelope length
X PARAM; Y ABS - X Z       // put PARAM on X and make Y its inverse, PARAM is now SKEW
CV.SLEW 4 X; CV 4 V 10     // arms slew to attack amount and begins rise
DEL X: CV.SLEW 4 Y; CV 4 0 // after attack is done, arm slew to release time and begin fall

The working of this little script is as follows: First, set PARAM's max value to an envelope length given by Z and make two inversely-related values from PARAM to be used as attack/decay times on X and Y (if one goes up, the other goes down). After this is done, set slew times to the attack/decay rates and switch voltages on/off on time.

This can be a really handy “oh s*** I need an envelope” kinda thing if you have the CV out to spare. You can delete the first line, set Z to a number and X to another number between 0 and the former if you don’t really want to use PARAM. Or h***, go crazy and use IN! The sky’s the limit on this script if you understand it.

9 Likes

Hey everyone, first post here and first published script with Teletype.

I don’t have a hardware version yet but I’m about to fix that next week by DIY-ing a Terminal.
I would never have fallen in love with this thing if it weren’t for the VCV rack plugin and all the awesome youtube videos and threads on Lines! Can’t wait to
try it with my hardware setup.

This script is kinda inspired by the sounds of standing in a grocery store and hearing all of the barcode scanners beeping in random-ish order but I decided to make it a bit more melodic with a Major 7th chord.
Nothing fancy, just really basic random notes quantized and random triggering of gates.

Anyway

Here’s a recording from VCV rack using 4 square waves through low pass gates :slight_smile:
Soundcloud link

And here’s the code:

1

CV.SET R N.C 2 0 RRAND 1 7

PROB 60: TR.P RRAND 1 4

PROB 40: TR.P RRAND 1 4

#M

SCRIPT 1

#I

R.MAX 4

R.MIN 1

6 Likes

There’s this thing I like to do on Teletype that is clocking scripts with M set on a tempo (like a multiple of 120 BPM, for example), then multiplying that speed via probability and stuff.

// M --------------------
M BPM T                   // T is set to a specific BPM, let's imagine it's 120.
PROB 50: T * 120 RRND 1 4 // multiply tempo by a random integer up to 4, sometimes
$ 1; TR.P 4               // idk, clock stuff

This, while it creates some cool ratcheting and funky grooves, you can’t output anything steady off it due to master tempo manipulation. This problem would arise when using up a trigger output for clocking other things like delays and stuff (which is the driving force behind this haiku).

So, while we’re on the topic of clocking delays, some time ago I was doing something similar to this and tried to clock a Chronoblob 2. Needless to say, it was all over the place, so it called for an unsteady groove from a steady one.

Cue this single line:

EV X: $ 1; X RRND 1 4 // yup, groovier than PROB 50:

In the grand scheme of things, this is dastardly simple: every X times, change X and do stuff, not much else to it. But, my mind exploded. I could keep the groovy clocking within Teletype and have a typical clock keeping other things in steady check within a patch. I managed to have my cake and eat it too in terms of generative scripting and delay clocking. It was a revelation to me.

I bring this silly simple little stupid verse here to appreciate how simple things in programming can be so effective, and at times, even mind-expanding.

6 Likes