#223

It’s not quite the same thing, but you can kinda do this already by calling a script recursively using a DEL. For example, if you want a virtual M of 100ms on script one, you’d put this somewhere in the script:
DEL 100: $ 1
I guess that’s not ideal in case you want to set the rate from the outside, but in that case you could use a variable or an unused table entry to store the rate value.

#224

I’d love to have a CV.P op that worked like TR.P but for the cv outs.

CV 1 V 5
DEL 10: CV 1 V 0

works but takes up space :sweat_smile:

2 Likes
#225

Have you been peeking at my notes? :stuck_out_tongue:
I think it would want two companion OPs: CV.P.TIME for setting ping length, and CV.P.LEVEL for voltage level.
IMHO the level control is actually the most interesting aspect of this concept! Would be great for applications that are trigger-level sensitive (pinging, etc.).

10 Likes
#226

time and level would be amazing companions! :heart_eyes:

#227

@SimonKirby thanks for the kinds words! very nice to hear :slight_smile:
would be fantastic if this functionality could be added.

also on a related note it seems that
TO.TR.M.DIV x y no longer works. it has been a while but i recall that working??? @bpcmusic maybe you are aware of this? i admit i have not been following all the developments lately, but i am trying to catch up!

#228

Here it is: Teletype patch from scratch / sorta tutorial video

1 Like
#229

Had a go with N.S today. Was surprised that it wraps every octave, making every octave something awkward that I need to handle separately…

Is it possible to disable wrapping?

If not I hope it’s not too late to discuss if it should wrap in the first place…

2 Likes
#230

It’s typically not too hard to work around the wrapping, but I agree that maybe the N.x OPs should have some octave math built in.

What’s your intended use?

#231

My intended use is: everything!!! I’m aware that extra code can be added to get to different octaves, but it just seems backwards to me. Say we’re in C-major and I want a couple of 9th chords Cmaj9 (C E G B D) and Fmaj9 (F A C E G), I’d like to just pick my root degree, say 8 and 4 (C up, F down) and build the chord from there using +2. Ok, you might argue that we’re not discussing chords here, but I like to generate melodies by relating them to the chord playing at any given time, so I need to know which notes are in the, say 9th chord. Up till now I’ve been using P to store scales, works fine, but takes up the first 16 rows for two octaves, I imagine with N.S I could free some of that pattern space up.

Here are a few examples that I did recently:

  1. Store progressions of root notes degrees in patterns, and calculate 7th chords by adding multiples of 2, like # 7 in this scene controls rings
    https://github.com/attejensen/a773_teletype/blob/master/jitter.txt
    sound like this:
  1. Choose steps from a scale over multiple octaves with a knob, # 5 in this scene
    https://github.com/attejensen/a773_teletype/blob/master/healthyh.txt
    sounds like this:
  1. Generative melody, #7 in this scene
    https://github.com/attejensen/a773_teletype/blob/master/shall_we_dance.txt
    sounds like this:
3 Likes
#232

The more I think about it the more I think a simpler N.S would be more useful, I would prefer 0 indexed (so that % works cleaner) and a more general way of working with scales, I feel like the church modes have too much space, compared to other scales…

I’ll see if I can come up with something more concrete. Anyone using N.S and have feelings about this?

#233

I stopped using N.x in favor of the QT.x OPs since most of my melodies are based on complex LFOs from outside Teletype. So you are probably in the best position to judge how to make the N.x OPs useful for a generative melodic sequence.

For a “more general” way of working with scales, you could take a look at how QT.B generalizes a 12tet scale as a bit mask. I think it’s a really powerful approach because you can toggle individual bits to add or remove from your scale. My worry about a hypothetical N.B OP is that interfacing with it might be just as script-intensive as replicating its functionality “raw”. Can you say from your perspective whether this is true?

Thinking about increasing utility of N.x OPs: the octave math definitely should be baked in. Maybe that plus an N.B OP is sufficient?

1 Like
#234

I’ve had octave wrapping implemented on the N. ops for a while on my private build. Good reminder to get it tidied up and into a PR!

3 Likes
#235

I too would love built in octaves in the N.S. op. Like @a773, I also store my scale in a pattern, so I can construct generative melodies across more than one octave. It feels a bit redundant to store the scale manually since I almost always use rather standard church scales.

Would be cool to be able to have e.g.
9, 5, 0 —> Eb’’, G’, C’ (for c minor)

1 Like
#236

Thanks for the input so far. I have two ideas that I think would work well, need to play a bit to get the details in place.

Which . suffix should I aim for? Any systematics here? Was thinking either N.A or N.R for the first and N.Q for the other, are those free?

#237

Yep! Go for it…

1 Like
#238

Random idea - thought I’d throw it out there.

Scenario: I tend to call a lot of scripts in a loop because I might need to do 2-3 things rather than one thing. So for example:

1:
L 0 3: $ 2

2:
// do a couple
// things in a loop

Script 2 basically ends up getting burned with 4 empty lines leftover.

What if there was an op that let you identify what script called the current script? Then you could get a little more mileage out of a script like script 2 above. Let’s pretend that op is called $.C (get calling script).

1:
L 0 3: $ 3

2:
L 1 16: $ 3

3:
IF EQ $.C 1: //do something for script 1
IF EQ $.C 1: //do something else for script 1
IF EQ $.C 2  //do something for script 2
IF EQ $.C 2  //do something else for script 2

The big limitation I can see is that the IF syntax on each line only leaves room for shorter ops on the other side of the colon…

1 Like
#239

That is a cool idea!

Ternary ? OP to the rescue :smiley:

1 Like
#240

if you use a variable you can make conditions shorter:

#1
L 0 3: A 1; $ 3

#2
L 1 16: A 2; $ 3

#3
IF EQ A 1: //do something for script 1
IF EQ A 1: //do something else for script 1
IF EQ A 2: //do something for script 2
IF EQ A 2: //do something else for script 2

can also store the condition itself in a variable (at the cost of losing a line):

#3
J EQ A 1; K EQ A 2
IF J: //do something for script 1
IF J: //do something else for script 1
IF K: //do something for script 2
IF K: //do something else for script 2

another variation of this is using the same script for regular duties as well as being an extension for init:

#I
I 1; SCRIPT 8

#8
IF I: // init stuff
IF I: I 0; BREAK
// regular stuff
5 Likes
#241

The second example looks great! The first and last one raise questions for me (and I may be in the wrong thread at this point so feel free to relocate :wink:)

Example 1: is that valid syntax? I didn’t think you could have semicolon separated ops on the same line as a colon op but maybe I’m remembering wrong or remembering old news. If it is valid does it execute both of those in a loop?

Example 3: does local I get passed from the calling script if you aren’t calling via an L op?

#242

yeah, you can have several semicolon separated statements after a modifier. if the modifier is a loop, it will execute all of the statements on each iteration (so in my example it will continue assigning 1 to A which isn’t necessary but allows us to save a line, otherwise you’d have to set A before you execute the loop).

you just can’t have several modifiers on the same line: EVERY 5: L 1 4: SCRIPT 2 is not allowed, for instance.

and yeah, local I gets passed from the calling script regardless of whether you call a script from a loop.

2 Likes