> teletype : code exchange

While scanning through some of the old posts I became really fascinated by the idea of storing pages of grid buttons states and trig patterns as binary. Not coming from a computer science background binary is still a little cryptic to me. After a lot of frustration about how to actually use BSET/BCLR I slimmed the code down to 2 scripts and documented it all here because writing things out helps me a lot.

I’m new to all this so if anything could be better/cleaner please help me out.

#I
G.BTX 0 0 0 1 1 1 3 8 16 6
G.FDR 0 0 7 8 1 2 3 8

#8
J + G.BTNY A; K G.BTNX
IF G.BTNV: P J BSET P J K
ELSE: P J BCLR P J K
A * G.FDRN 6
L 0 95: $ 7

#7
K + A / I 16
G.BTN.V I BGET P K WRP I 0 15
3 Likes

thank you! incredibly helpful to a fellow binary struggler

1 Like

that’s great, thanks for documenting it! i’ve linked it to one of the grid studies.

noticed a couple of typos, under “Manage presses” point 5 should say 96 in “Loop 95 times” and under “Update buttons” in “32-47 becomes 3” it should be 2 instead.

2 Likes

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…

8 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

13 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…

11 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

6 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

2 Likes