> teletype : code exchange

Thanks for catching those and for sharing. :pray:It’s like being quoted by the prophet who’s words you live your own life by.

forgot to mention one more thing: it shares the same script for both the buttons and the fader, which is fine for this scene but might cause potential issues if you add more buttons. if you press one of the added buttons and then press the fader it might cause one of the pattern values to change as well. this can be fixed by either using 2 different scripts, or creating the fader and other controls in a different group and then using G.GRPI to check which control called the script.

Just a quick but useful scene, after someone pointed me this module.

Scripts 1-4 make snapshots for left side of the “fader”
Scripts 5-8 make snapshots for right side of the “fader”
The “fader” is the PARAM knob.
You need a TELEX IN.

It can easily be much better but I thought I’d post anyway as a starting point.

4 CV MORPHER



#1
A TI.PRM 1;

#2
B TI.PRM 2

#3
C TI.PRM 3

#4
D TI.PRM 4

#5
X TI.PRM 1

#6
Y TI.PRM 2

#7
Z TI.PRM 3

#8
T TI.PRM 4

#M
CV 1 SCL 0 V 10 A X PRM
CV 2 SCL 0 V 10 B Y PRM
CV 3 SCL 0 V 10 C Z PRM
CV 4 SCL 0 V 10 D T PRM

#I
M 50; M.ACT 1
6 Likes

Oh cool. I thought about doing something similar when I saw that module- but saving input values from the arc instead of tx-i. Do you get any audible stepping when you crossfade? I was thinking a small slew on the cv outputs would be helpful.

1 Like

I didn’t hear anything annoying in my first tests.
But in theory, setting the same slew time as the metronome should work, shouldn’t it ?

1 Like

I’m a new teletype user, I’m documenting my findings on github, in the hope it can be of help to someone else…

9 Likes

Is this the right place to post GridOp ideas? I think this idea qualifies either way because this scene can work without the grid, up to a point anyway.

Any help getting my code more elegant much appreciated.
I’ve been away from the Teletype for a few years. I’m very happy to be back, although my brain does hurt a little after the last few days.

I’ve tried to make a little instrument, based on, and as an homage to Lorre Mill Keyed Mosstone. The way it takes 3 keys, or gates, or both, to create melodies is a lot of fun.

The grid layout is based on the KM.
In the middle are 3 keys. They can combine to make 8 notes (all off is note 1).
Above and below are transpose buttons. Above and below those are faders to tune the transposition for 0 to 12 semitones above goes up, below goes down.
To the left is an envelope loop button which connects the gate in of you envelope with it’s EOC out.
To the right is a simple button which activates CV 4 as a random source (2 and 3 are always on).
The final column on the right shows the currently chosen note from the 8 you can input.

The keyed notes send a gate on note off, which was not my intention. The notes generated by the gates do not. Somehow or other this seems to be quite musical, but I’ve no idea how it has happened. I’m just getting started with all these new (to me) options in TT3.

Apologies for rough video and glare. I’m out of practice with all of that, too. Not sure why this vimeo link hasn’t embedded something here. Is there a size limit? It’s a bit big.

https://vimeo.com/334329615

Scripts 1-3 are note generation from 3 flipped variables. Logic generated extra gates to go with the pseudo random CV (the TR outs were unused).
4 is transposition.
5 is looping the (external) envelope.
6 is pseudo random stuff adding a 4th bit to get 0-15, then messing with that.
7 is an extension of I.
8 is CV note input. This needs more work so these can be changed in real time. Right now the delay to compensate for keyboard latency is still set from an old patch 4 years ago.
M is unused.
I’d like to add a reset button and a ‘hide the transpose functions’ button, but I ran out of lines to make more buttons.

MOSSY

#1
A EZ A
$ 3; $ 6
IF AND B C: TR.P 2

#2
B EZ B
$ 3; $ 6
IF OR A C: TR.P 3
IF EZ OR A C: TR.P 4

#3
C EZ C; $ 6
X + A + * 2 B * 4 C
CV 1 N + P X Y
TR.P 1
G.LED 15 - 7 X 15
DEL 100: G.REC 15 0 1 8 0 0

#4
Z * G.FDR.N 1 G.BTN.V 4
Y - Z * G.FDR.N 2 G.BTN.V 5
CV 1 N + P X Y

#5
IF G.BTN.V 6: TR.P 1

#6
T TIME; TIME 0
D + TOSS + * 2 C + * 4 B * 8 A
L 2 3: CV.SLEW I * TOSS / T 2
CV 2 VV LSH D 5
CV 3 VV - 480 LSH D 5
IF G.BTN.V 7: CV 4 CV 2

#7
G.BTN 4 5 1 6 2 1 2 4
G.BTN 5 5 5 6 2 1 2 4
G.BTN 6 3 1 2 6 1 4 5
G.BTN 7 11 1 2 6 1 4 6
G.FDR 1 1 0 13 1 0 2 4
G.FDR 2 1 7 13 1 0 2 4

#8
DEL 75: X DIV QT IN N 1 N 1
DEL 75: P.INS 0 X
DEL 75: P.L 8
DEL 75: CV 1 N X
DEL 76: TR.P 1

#M

#I
P.N 0; P.L 8; G.RST; Z 0
A 0; B 0; C 0; X 0; Y 0
G.BTN 1 5 3 2 2 0 7 1
G.BTN 2 7 3 2 2 0 4 2
G.BTN 3 9 3 2 2 0 7 3
M.ACT 0; TR.TIME 1 150; $ 7

14 Likes

this is so insane - sounds great! love the look of the grid interface too. i wonder if this could be rigged up for just type?

There’s plenty of room left in the 4 scripts that generate the notes…

A six output shift register thing with a similar note input methodology to this should be possible. If the note indices and just type indices could match, then the L (loop) Op should be able to generate 6. Not certain, but sounds possible.

2 Likes

As I can’t add a 3rd post here, as would be logical, I’m posting the update to this work in progress at the TOP of this post.

Update 051119

Teletype / Grid Ops Rene / Rungler… getting there.

Script 8.
CV input of notes to the melodic sequence pattern. Shift register style. Once there are 16 values, any new first value is added and the 16th (now pushed to 17th) is deleted. Keeping the pattern 16 steps long. These values can be entered at any time.

Scripts 1,2,3
Triggers/Gates 1 and 2 generate the Rungler value. Trigger 1 is the ‘oscillator’, Trigger 2 is the clock. A 4 step sequence/shift register is created and a 4 bit value is generated.

The top row of the grid displays the current rungler value 0-15.

These two trigger/gates also clock the melodic pattern.

Trigger 1 advances the melodic seq by 1 step, Trigger 2, by 4.

Script 4 plays the basic melody. Taking the data generated by scripts 1-3 and the grid.
The 16 steps are represented by a 4 by 4 square of buttons at the centre of the grid. Any of the stages can be muted. The default - unlit button setting - is unmuted.

Script 5 randomises the melody using the Rungler value and the buttons to the left of the square.

Script 6 sporadically transposes the melody using the Rungler, the fader at the bottom of the grid (semitones), and the buttons to the right of the square.

Script 7 generates stepped and smooth CVs from the Rungler.

Here’s a rough video. Apologies for glare making the centre 16 button square effectively one big blur…

https://vimeo.com/335548058

RENE RUNGLER

#1
X EZ X
PN.NEXT 1
$ 4

#2
G.REC 0 0 16 1 0 0
PN.L 0 4; PN.INS 0 0 X
PN.L 0 4
Y + * 4 PN 0 2 * 8 PN 0 3
Z + Y + PN 0 0 * 2 PN 0 1
G.LED Z 0 15; $ 3

#3
L 1 4: PN.NEXT 1
$ 4

#4
G.GBTN.L 0 4 4; A PN.HERE 1
IF EZ G.BTN.V PN.I 1: CV 1 N A
IF EZ G.BTN.V PN.I 1: TR.P 1
G.BTN.L PN.I 1 8; $ 7
IF NZ G.GBTN.C 1: $ 5
IF NZ G.GBTN.C 2: $ 6

#5
B QT DIV Z G.GBTN.C 1 1
EVERY B: PN.INS 1 Z PN 1 15
EVERY B: PN.L 1 16

#6
C QT DIV Y G.GBTN.C 2 1
EVERY C: CV.OFF 1 N G.FDR.N 0
EVERY 2: CV.OFF 1 0

#7
T TIME; TIME 0
CV 2 VV LSH Z 5
TR.TIME 2 15; CV.SLEW 3 / T 2
EVERY Z: TR.P 2
CV 3 VV LSH Y 5
EVERY Y: TR.P 3

#8
DEL 20: D DIV QT IN N 1 N 1
DEL 20: PN.L 1 16
DEL 20: PN.INS 1 0 D
DEL 20: PN.L 1 16
DEL 20: CV 1 N D
DEL 25: TR.P 1

#M
G.GBX 0 0 6 2 1 1 1 6 0 4 4
G.GBTN.L 1 2 4; G.GBTN.L 2 2 4
G.FDR 0 0 7 16 1 0 5 6
TR.TIME 1 150
M.ACT 0

#I
G.RST; X 0; Y 0; Z 0
L A D: I 0
PN.WRAP 1 1; PN.I 1 0;
G.GBX 1 20 0 3 2 2 1 3 0 3 1
G.GBX 2 23 10 3 2 2 1 3 5 3 1
PN.L 1 16; M.ACT 1


I’m working on a Make Noise / Monome Benjolin (meets Rene), with more melodic leanings than Hordijk’s. It’s great when the Hordijk mixes the audio rate and the LFO in the Rungler, but rarely, if ever did I find myself saying - I must record this!

So I’m using the two Maths function generators and sending gates from them into two TT inputs. One is clock, the other it data. From the two we get a 4 stage shift register (pattern 0) from which we get a fluid value from 0-15.

I’m feeding melodic data into pattern 1 using the same method, as the Mosstone Homage above

#8
DEL 10: X DIV QT IN N 1 N 1
DEL 10: P.INS 0 X
DEL 10: P.L 8
DEL 10: CV 1 N X
DEL 12: TR.P 1

I’ve added a few probabilities for events to make things less linear and I plan to make some faders to control those.

Anyhow, right now it sounds like this. Melodic CV playing the STO which seems unsure whethere to sound like a guitar or a sax, and Rungler data playing the QPAS, Twin Peaks style. Rungler also modulating the STO wavefolding.

No other cross modulation, right now, but eventually there will be plenty!

https://vimeo.com/334548670

Note - I had to take the original text from this post and add it to the previous one, so I could post this idea without having 3 consecutive posts.

And any ideas why my vimeo videos aren’t embedding anymore? I posted some just a week or two ago in the All Things Lorre Mill, and they embedded automatically…

13 Likes

So, I’ve been thinking a lot about how to get arrays of notes into TT. I’ve managed a few times using keyboard input to fill patterns with notes and that works, up to a point…
Then it just occurred to me (many may already be doing this) that I have a great device for making sophisticated arrays of notes - Kria, and TT can play Kria.
I’ve also been somewhat obsessed with how Keyed Mosstone creates melodies from various combinations of triggers or gates.
So here’s my, very simple, first attempt.
4 Triggers play 2 sequences in Kria. Kria is ‘played’ in real time to change scales, or anything else you might like. In the audio below only Kria scales and one of the trigger sources are ‘played’.

The script offers two strategies for playing Kria from 4 triggers. One advances Kria by 1 step, 2 steps, 3 steps or resets. That’s the one used in the audio example. The other applies different weights to the triggers to generate a binary number - 0 to 15 and then plays that step.

16 STEP MOSSTONE

#1
KR.CLK 1
KR.RES 2 0

#2
L 1 2: KR.CLK 1
L 1 3: KR.CLK 2

#3
L 1 3: KR.CLK 1
L 1 2: KR.CLK 2

#4
L 1 4: KR.RES 1 0
KR.CLK 2

#5
A EZ A
$ 8

#6
B EZ B
$ 8

#7
C EZ C
$ 8

#8
D EZ D
X + A + * 2 B + * 3 C * 4 D
KR.RES 1 0
L 1 X: KR.CLK 1

#M

#I
A 0; B 0; C 0; D 0

7 Likes

Here is something I’ve been working on this weekend: MetroType. An implementation of the features of the Intellijel Metropolis within a Teletype scene. I warn you that this is an ugly inefficient draft, but it works (I think…mostly). Any improvements & comments are welcome!

Before I get to the code, some explanation of how to use it:
Pattern 0: notes
Pattern 1: repeats
Pattern 2: trigger mode (0 = rest, 1 = single pulse, 2 = repeat pulses, 3 = long pulse)
Pattern 3: slide/skip (0 = normal, 1 = slide, 2 = skip)

Input 8 is clock & input 7 is reset. Currently outputs on TR 1 and CV1. I also intend to add another mode in pattern 3, accent, which will output on TR 2 but it isn’t there yet. It would be much easier to implement accents if there were more patterns!

Another key item is that variable A is mapped to steps/div (read Metropolis manual if you don’t know what this is). Z is mapped to channel (1-4).

Gate length is tied to PARAM, with 16 possible lengths as a division of the clock, same as Metropolis. That is why the magic values of 16 are in scripts 8 & I.

Slide time is also currently tied to PARAM (I know, but I don’t have my TXi in the case right now). It ranges from 62ms to 1 second, with 16 discrete values (which I believe is similar to Metropolis). That is why there is a magic value of 62 in script 3.

If you give it a try let me know how it turns out.

My long term goal is get accents working (again, more patterns would help!), and then to implement Turing Machine-style shift registers (seen earlier in this thread) to pseudo randomly populate patterns. That may be ambitious given the amount of scripts space remaining. I hear you…why implement the Metropolis style sequencing if you are going to populate the patterns randomly? I have a couple of reasons for this. It would be most excellent if I could call another scene to repopulate the patterns…SCENE.P anyone?

Thanks. Geremy tt04s.txt (1.6 KB)

METROTYPE FOR ER-301
$8 CLK - $7 SYNC/RST
P0: NOTES P1: REPEATS P3: MODE
P2: 0-RST 1-SNGL 2-RPT 3-LNG
P3: SLIDE/SKIP
P3: 0-NRM 1-SLIDE 2-SKIP

#1
IF LTE X 0: $ 3; BREAK
IF LTE Y 1: $ 2
IF EQ Y 2: TR.P Z; X - X A
IF EQ Y 3: TR Z 1; X - X A

#2
J PN.HERE 1
IF && Y EQ X J: TR.P Z
X SUB X A

#3
J PN.NEXT 3; K * TI.PRM 1 62
IF EZ J: CV.SLEW Z 0
IF EQ J 1: CV.SLEW Z K
TR Z 0
$ 4

#4
CV Z N PN.NEXT 0
X PN.NEXT 1; Y PN.NEXT 2
J + PN.I 0 1; K PN.L 0
IF EQ PN.HERE 3 2: X 0

#5

#6

#7
$ I

#8
T DIV LAST 8 16
T MUL T PRM
TR.TIME Z T
EVERY A: $ 1

#M

#I
L 1 8: $.POL I 1
T 0; X 0; Y 0; Z 1
L 0 3: PN.I I 0; TR + I 1 0
PARAM.SCALE 1 16
TI.PRM.MAP 1 1 16

#P
8 8 8 8
1 1 1 1
0 0 0 0
63 63 63 63

18 4 2 0
24 3 1 1
20 4 2 0
18 3 1 0
24 4 2 0
20 3 1 0
22 4 3 1
16 5 2 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0

4 Likes

As part of my academic research on language evolution, I’m interested in how simple processes can lead to emergent complexity and thought Teletype would be a good way to explore this musically. Here’s what I came up with:

For this scene I’ve recreated the “Molecular Music Box” that Duncan Lockerby explains in this video:

Here’s the scene:

MOLECULAR MUSIC BOX
@SIMONKIRBY


#1
L 8 39: PN 0 I -1
L 8 39: PN 1 I -1 
L 8 39: PN 2 I -1
L 8 39: PN 3 I -1
L 40 56: PN 0 I 0
L 40 56: PN 1 I 0

#2
P.N 1
IF NE -1 P A: CV 2 N P A
IF NE -1 P A: TR.P 2

#3
P.N 2
IF NE -1 P A: CV 3 N P A
IF NE -1 P A: TR.P 3

#4
P.N 3
IF NE -1 P A: CV 4 N P A
IF NE -1 P A: TR.P 4
A WRAP + 1 A 8 + 7 PN 3 0

#5
P.N 0
IF NE -1 P A: CV 1 N P A
IF NE -1 P A: TR.P 1
$ 2
$ 3
$ 4

#6
IF < A 24: Y PN 0 + 32 A
ELSE: Y PN 1 + 16 A
IF NZ Y: PN.NEXT 2
$ 7
IF < A 24: PN 0 + 32 A Y
ELSE: PN 1 + 16 A Y

#7
X PN.NEXT 0
IF EZ PN.I 0: PN.NEXT 1
X + X PN 1 PN.I 1
C + C PN 2 PN.I 2
PN Y A X; Y % + 1 Y 4

#8
IF EQ T C: $ 6
$ 5
T + 1 T
PN.L 0 PN 3 1; PN.L 1 PN 3 2
PN.L 2 PN 3 3

#M
$ 8

#I
A 8; T 0; C 0
PN.I 0 0
PN.I 1 0
PN.I 2 0
$ 1

#P
7	4	2	4
1	1	1	1
0	0	0	0
63	63	63	63

0	0	4	16
2	12	3	7
3	24	0	4
5	36	0	2
7	0	0	0
9	0	0	0
10	0	0	0
0	0	0	0
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
-1	-1	-1	-1
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0
0	0	0	0

#G
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000

0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0

Wire it up to a bunch of voices - each CV/Trigger pair is a voice. All four is great, but if you only have two or three it’s still worth a try. (Start with CV/Trigger 1). You can modify the rules the system follows using the first screen of the tracker interface. The first column gives the semitone scale the music will be quantised to (up to 8 notes). The second column gives offsets for subsequent loops through the scale (so you can go up octaves for example). The third column gives the note lengths discussed in the video. The first one is the note length until the first “collision” is detected, and the second is what the note length switches to at that point. The video only discusses the case of two note lengths, but you can have up to 8 in my implementation. The final column has the number of metro beats in the loop that the notes get added to (max 32), the number of notes in the scale, the number of offsets, and the number of different note lengths in the pattern.

(Gah - sounds super complicated! But really it’s quite simple once you’ve watched the youtube video!)

Here’s the full version of a performance with this scene, triggering two Plaits and one Rings, into a long looping delay on the Disting. I’m editing the rules on the fly and changing the rate of the scene using triggers from Kria.

Thanks for reading/listening/watching/playing!

19 Likes

spent the afternoon trying to hash out something exactly like this. thrilled to find your post. unfortunately it returns a ‘too many params’ error when i type in the third script (which has me thrown, since it’s… definitely not too many parameters…)

any idea what could be causing that return?

2015 is forever ago so the old scripts might not work directly. Here’s a quantizer script excerpt of my design that works by the same principles.

4 Likes

These are really helpful and I’ve been looking them over. Thanks for your documentation and I’d be interested in asking some questions! I’m a new teletype and new eurorack user. Been looking at the Teletype as a generative driver of the Just Friends module (with a mangroves, w/ and Three Sisters as part of the chain). Hoping to get more in to the whole layout, but getting up to speed with all these modules, the rack flow AND the teletype has been a rough wall to climb.

Anyway, that’s greatly for your work there!

Feel free to ask any questions, I’d be happy to answer anything related to my code (or anything else, if I somehow have a clue)

Edit; what I thought might be interesting was to see the code and immediately hear it used in real life.

1 Like

Thanks! My setup is minimal right now, to say the least, so if anything, I’ll be curious to see how you implemented i2c stuff with the 301 and see if those ideas could be well suited for the JF.

Well you do realize that all i2c to the 301 begins with “SC.” in teletype land, right?

Yup; and altering that for the JF would in theory be replacing that with JF, depending on if the syntax (or ability) match.