add teletype stuff

This commit is contained in:
lee2sman 2022-11-05 22:22:55 -04:00
parent 88920b2132
commit 30d4773489
7 changed files with 1136 additions and 0 deletions

BIN
images/gridvisualizer.jpg Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 71 KiB

BIN
images/terminology.jpg Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 170 KiB

150
teletype/advanced.gmi Normal file
View File

@ -0,0 +1,150 @@
# Advanced
## Teletype terminology
Here is a picture to help understand the naming of the various parts of a Teletype command:
=> ../images/terminology.jpg Teletype Command Terminology
COMMAND
: The entire command, e.g. IF X: Y 1; Z 2;.
PRE
: The (optional) part before the PRE SEP, e.g. IF X.
POST
: The part after the PRE SEP, e.g. Y 1; Z 2.
SUB
: A sub command (only allowed in the POST), e.g. Y 1, or Z 2.
PRE SEP
: A colon, only one is allowed.
SUB SEP
: A semi-colon, that separates sub commands (if used), only allowed in the POST.
NUM
: A number between 32768 and 32767.
OP
: An operator, e.g. X, TR.PULSE
MOD
: A modifier, e.g. IF, or L.
## Sub commands
Sub commands allow you to run multiple commands on a single line by utilising a semi-colon to separate each command, for example the following script:
X 0
Y 1
Z 2
Can be rewritten using sub commands as:
X 0; Y 1; Z 2
On their own sub commands allow for an increased command density on the Teletype. However when combined with PRE statements, certain operations become a lot easier.
Firstly, sub commands cannot be used before a MOD or in the PRE itself. For example, the following is **not allowed**:
X 1; IF X: TR.PULSE 1
We can use them in the POST though, particularly with an IF, for example:
IF X: CV 1 N 60; TR.P 1
IF Y: TR.P 1; TR.P 2; TR.P 3
Sub commands can also be used with L.
## Aliases
In general, aliases are a simple concept to understand. Certain OPs have been given shorted names to save space and the amount of typing, for example:
```
TR.PULSE 1
```
Can be replaced with:
```
TR.P 1
```
Where confusion may arise is with the symbolic aliases that have been given to some of the maths OPs. For instance + is given as an alias for ADD and it must be used as a direct replacement:
```
X ADD 1 1
X + 1 1
```
The key to understanding this is that the Teletype uses prefix notation[^polish] always, even when using mathematical symbols.
[^polish]: Also know as Polish notation.
The following example (using infix notation) **will not work**:
```
X 1 + 1
```
Aliases are entirely optional, most OPs do not have aliases. Consult the OP tables and documentation to find them.
## Avoiding non-determinism
Although happy accidents in the modular world are one of it's many joys, when writing computer programs they can be incredibly frustrating. Here are some small tips to help keep things predictable (when you want them to be):
1. Don't use variables unless you need to.
This is not to say that variables are not useful, rather it's the opposite and they are extremely powerful. But it can be hard to keep a track of what each variable is used for and on which script it is used. Rather, try to save using variables for when you do want non-deterministic (i.e. variable) behaviour.
2. Consider using I as a temporary variable.
If you do find yourself needing a variable, particularly one that is used to continue a calculation on another line, consider using the variable I. Unlike the other variables, I is overwritten whenever L is used, and as such, is implicitly transient in nature. One should never need to worry about modifying the value of I and causing another script to malfunction, as no script should ever assume the value of I.
3. Use PN versions of OPs.
Most P OPs are now available as PN versions that ignore the value of P.I. (e.g. PN.START for P.START). Unless you explicitly require the non-determinism of P versions, stick to the PN versions (space allowing).
4. Avoid using A, B, C and D to refer to the trigger outputs, instead use the numerical values directly.
As A-D are variables, they may no longer contain the values 1-4, and while this was the recommend way to name triggers, it is no longer consider ideal. Newer versions of the Teletype hardware have replaced the labels on the trigger outputs, with the numbers 1 to 4.
## Grid integration
Grid integration can be described very simply: it allows you to use grid with teletype. However, there is more to it than just that. You can create custom grid interfaces that can be tailored individually for each scene. Since it's done with scripts you can dynamically change these interfaces at any point - you could even create a dynamic interface that reacts to the scene itself or incoming triggers or control voltages.
You can simply use grid as an LED display to visualize your scene. Or make it into an earthsea style keyboard. You can create sequencers, or control surfaces to control other sequencers. The grid operators simplify building very complex interfaces, while something simple like a bank of faders can be done with just two lines of scripts.
Grid integration consists of 3 main features: grid operators, Grid Visualizer, and Grid Control mode. Grid operators allow you to draw on grid or create grid controls, such as buttons and faders, that can trigger scripts when pressed. As with any other operators you can execute them in Live screen or use them in any of your scripts.
Grid Visualizer provides a virtual grid within the Teletype itself:
=> ../images/gridvisualizer.jpg
It can be very useful while developing a script as you don't have to switch between the grid and the keyboard as often. To turn it on navigate to Live screen and press Alt-G (press again to switch to Full View / turn it off). You can also emulate button presses, which means it can even be used as an alternative to grid if you don't have one, especially in full mode - try it with one of the many code exchange already developed. For more information on how to use it please refer to the Grid Visualizer documentation.
=> https://github.com/scanner-darkly/teletype/wiki/CODE-EXCHANGE CODE EXCHANGE
=> https://github.com/scanner-darkly/teletype/wiki/GRID-VISUALIZER Grid Visualizer documentation
Grid Control Mode is a built in grid interface that allows you to use grid to trigger and mute scripts, edit variables and tracker values, save and load scenes, and more. It's available in addition to whatever grid interface you develop - simply press the front panel button while the grid is attached. It can serve as a simple way to use grid to control any scene even without using grid ops, but it can also be very helpful when used together with a scripted grid interface. For more information and diagrams please refer to the Grid Control documentation
=> https://github.com/scanner-darkly/teletype/wiki/GRID-CONTROL-MODE Grid Control documentation
If you do want to try and build your own grid interfaces the Grid Studies is the best place to start
=> https://github.com/scanner-darkly/teletype/wiki/GRID-INTEGRATION the Grid Studies

44
teletype/index.gmi Normal file
View File

@ -0,0 +1,44 @@
# Monome Teletype Documentation
This is a mirror of useful pages relating to the Teletype module by Monome.
> Algorithmic ecosystem: a dynamic, musical event triggering platform.
=> quickstart.gmi Quickstart
=> advanced.gmi Advanced
=> keys.gmi Keybindings
=> teletype1-scenes.gmi Teletype 1.0 Scenes
=> https://github.com/monome-community/teletype-codex Teletype Codex
---
There are 8 inputs: Each input triggers its numbered script to run. There is also a M metronome script (runs each time the metronome tics) and an I (initialize) script that runs when you select the scene.
A scene is a single collection of the 8 scripts along with M and I scripts. You give your scene a name and optionally a description.
Teletype can also be run in its 'live' REPL mode as well.
## Key-Bindings:
HELP - ALT-H
SCENE WRITE MODE - ALT-ESC
SAVE - ALT-ENTER
COPY - ALT-C
PASTE - ALT-V
CUT - ALT-X
INSERT - SHIFT-ENTER
Monome Documentation CC-BY-4.0
My notes are CC-BY-4.0.

182
teletype/keys.gmi Normal file
View File

@ -0,0 +1,182 @@
# Keys
## Global key bindings
These bindings work everywhere.
```
Key | Action
-------------------------------------------------------------------------
<tab> | change modes, live to edit to pattern and back
<esc> | preset read mode, or return to last mode
alt-<esc> | preset write mode
win-<esc> | clear delays, stack and slews
shift-alt-? / alt-h | help text, or return to last mode
<F1> to <F8> | run corresponding script
<F9> | run metro script
<F10> | run init script
alt-<F1> to alt-<F8> | edit corresponding script
alt-<F9> | edit metro script
alt-<F10> | edit init script
ctrl-<F1> to ctrl-<F8> | mute/unmute corresponding script
ctrl-<F9> | enable/disable metro script
<numpad-1> to <numpad-8> | run corresponding script
<num lock> / <F11> | jump to pattern mode
<print screen> / <F12> | jump to live mode
```
## Text editing
These bindings work when entering text or code.
In most cases, the clipboard is shared between live, edit and the 2 preset modes.
```
Key | Action
---------------------------------------------------------------------
<left> / ctrl-b | move cursor left
<right> / ctrl-f | move cursor right
ctrl-<left> / alt-b | move left by one word
ctrl-<right> / alt-f | move right by one word
<home> / ctrl-a | move to beginning of line
<end> / ctrl-e | move to end of line
<backspace> / ctrl-h | backwards delete one character
<delete> / ctrl-d | forwards delete one character
shift-<backspace> / ctrl-u | delete from cursor to beginning
shift-<delete> / ctrl-k | delete from cursor to end
alt-<backspace> / ctrl-w | delete from cursor to beginning of word
alt-d | delete from cursor to end of word
ctrl-x / alt-x | cut to clipboard
ctrl-c / alt-c | copy to clipboard
ctrl-v / alt-v | paste to clipboard
```
## Live mode
```
Key | Action
---------------------------------------
<down> / C-n | history next
<up> / C-p | history previous
<enter> | execute command
~ | toggle variables
[ / ] | switch to edit mode
alt-g | toggle grid visualizer
shift-d | live dashboard
alt-<arrows> | move grid cursor
alt-shift-<arrows> | select grid area
alt-<space> | emulate grid press
alt-/ | switch grid pages
alt-\ | toggle grid control view
alt-<prt sc> | insert grid x/y/w/h
```
In full grid visualizer mode pressing `alt` is not required.
## Edit mode
In edit mode multiple lines can be selected and used with the clipboard.
```
Key | Action
---------------------------------------
<down> / C-n | line down
<up> / C-p | line up
[ | previous script
] | next script
<enter> | enter command
shift-<enter> | insert command
alt-/ | toggle line comment
shift-<up> | expand selection up
shift-<down> | expand selection down
alt-<delete> | delete selection
alt-<up> | move selection up
alt-<down> | move selection down
ctrl-z | undo (3 levels)
```
## Tracker mode
The tracker mode clipboard is independent of text and code clipboard.
```
Key | Action
---------------------------------------------------------------------
<down> | move down
alt-<down> | move a page down
<up> | move up
alt-<up> | move a page up
<left> | move left
alt-<left> | move to the very left
<right> | move right
alt-<right> | move to the very right
[ | decrement by 1
] | increment by 1
alt-[ | decrement by 1 semitone
alt-] | increment by 1 semitone
ctrl-[ | decrement by 7 semitones
ctrl-] | increment by 7 semitones
shift-[ | decrement by 12 semitones
shift-] | increment by 12 semitones
alt-<0-9> | increment by `<0-9>` semitones (0=10, 1=11)
shift-alt-<0-9> | decrement by `<0-9>` semitones (0=10, 1=11)
<backspace> | delete a digit
shift-<backspace> | delete an entry, shift numbers up
<enter> | commit edit (increase length if cursor in position after last entry)
shift-<enter> | commit edit, then duplicate entry and shift downwards (increase length as `<enter>`)
alt-x | cut value (n.b. `ctrl-x` not supported)
alt-c | copy value (n.b. `ctrl-c` not supported)
alt-v | paste value (n.b. `ctrl-v` not supported)
shift-alt-v | insert value
shift-l | set length to current position
alt-l | go to current length entry
shift-s | set start to current position
alt-s | go to start entry
shift-e | set end to current position
alt-e | go to end entry
- | negate value
<space> | toggle non-zero to zero, and zero to 1
0 to 9 | numeric entry
shift-2 (`@`) | toggle turtle display marker (`<`)
ctrl-alt | insert knob value scaled to 0..31
ctrl-shift | insert knob value scaled to 0..1023
```
## Preset read mode
```
Key | Action
--------------------------
<down> / C-n | line down
<up> / C-p | line up
<left> / [ | preset down
<right> / ] | preset up
<enter> | load preset
```
## Preset write mode
```
Key | Action
------------------------------------
<down> / C-n | line down
<up> / C-p | line up
[ | preset down
] | preset up
<enter> | enter text
shift-<enter>| insert text
alt-<enter> | save preset
```
## Help mode
```
Key | Action
-----------------------------
<down> / C-n | line down
<up> / C-p | line up
<left> / [ | previous page
<right> / ] | next page
C-f / C-s | search forward
C-r | search backward
```

329
teletype/quickstart.gmi Normal file
View File

@ -0,0 +1,329 @@
# Quickstart
## Panel
The keyboard is attached to the front panel, for typing commands. The commands can be executed immediately in *LIVE mode* or assigned to one of the eight trigger inputs in *EDIT mode*. The knob and in jack can be used to set and replace values.
## LIVE mode
Teletype starts up in LIVE mode. You'll see a friendly > prompt, where commands are entered. The command:
```
TR.TOG A
```
will toggle trigger A after pressing enter. Consider:
```
CV 1 V 5
CV 2 N 7
CV 1 0
```
Here the first command sets CV 1 to 5 volts. The second command sets CV 2 to note 7 (which is 7 semitones up). The last command sets CV 1 back to 0.
Data flows from right to left, so it becomes possible to do this:
```
CV 1 N RAND 12
```
Here a random note between 0 and 12 is set to CV 1.
We can change the behavior of a command with a *PRE* such as `DEL`:
```
DEL 500 : TR.TOG A
```
TR.TOG A will be delayed by 500ms upon execution.
A helpful display line appears above the command line in dim font. Here any entered commands will return their numerical value if they have one.
SCRIPTS, or several lines of commands, can be assigned to trigger inputs. This is when things get musically interesting. To edit each script, we shift into EDIT mode.
### LIVE mode icons
Four small icons are displayed in LIVE mode to give some important feedback about the state of Teletype. These icons will be brightly lit when the above is true, else will remain dim. They are, from left to right:
* Slew: CV outputs are currently slewing to a new destination.
* Delay: Commands are in the delay queue to be executed in the future.
* Stack: Commands are presently on the stack waiting for execution.
* Metro: Metro is currently active and the Metro script is not empty.
## EDIT mode
Toggle between EDIT and LIVE modes by pushing **TAB**.
The prompt now indicates the script you're currently editing:
* 1-8 indicates the script associated with corresponding trigger
* M is for the internal metronome
* I is the init script, which is executed upon scene recall
Script 1 will be executed when trigger input 1 (top left jack on the panel) receives a low-to-high voltage transition (trigger, or front edge of a gate). Consider the following as script 1:
```
1:
TR.TOG A
```
Now when input 1 receives a trigger, TR.TOG A is executed, which toggles the state of output trigger A.
Scripts can have multiple lines:
```
1:
TR.TOG A
CV 1 V RAND 4
```
Now each time input 1 receives a trigger, CV 1 is set to a random volt between 0 and 4, in addition to output trigger A being toggled.
### Metronome
The M script is driven by an internal metronome, so no external trigger is required. By default the metronome interval is 1000ms. You can change this readily (for example, in LIVE mode):
```
M 500
```
The metronome interval is now 500ms. You can disable/enable the metronome entirely with `M.ACT`:
```
M.ACT 0
```
Now the metronome is off, and the `M` script will not be executed. Set `M.ACT` to 1 to re-enable.
## Patterns
Patterns facilitate musical data manipulation-- lists of numbers that can be used as sequences, chord sets, rhythms, or whatever you choose. Pattern memory consists four banks of 64 steps. Functions are provided for a variety of pattern creation, transformation, and playback. The most basic method of creating a pattern is by directly adding numbers to the sequence:
```
P.PUSH 5
P.PUSH 11
P.PUSH 9
P.PUSH 3
```
P.PUSH adds the provided value to the end of the list-- patterns keep track of their length, which can be read or modified with P.L. Now the pattern length is 4, and the list looks something like:
```
5, 11, 9, 3
```
Patterns also have an index P.I, which could be considered a playhead. P.NEXT will advance the index by one, and return the value stored at the new index. If the playhead hits the end of the list, it will either wrap to the beginning (if P.WRAP is set to 1, which it is by default) or simply continue reading at the final position.
So, this script on input 1 would work well:
```
1:
CV 1 N P.NEXT
```
Each time input 1 is triggered, the pattern moves forward one then CV 1 is set to the note value of the pattern at the new index. This is a basic looped sequence. We could add further control on script 2:
```
2:
P.I 0
```
Since P.I is the playhead, trigger input 2 will reset the playhead back to zero. It won't change the CV, as that only happens when script 1 is triggered.
We can change a value within the pattern directly:
```
P 0 12
```
This changes index 0 to 12 (it was previously 5), so now we have 12, 11, 9, 3.
We've been working with pattern 0 up to this point. There are four pattern banks, and we can switch banks this way:
```
P.N 1
```
Now we're on pattern bank 1. P.NEXT, P.PUSH, P, (and several more commands) all reference the current pattern bank. Each pattern maintains its own play index, wrap parameter, length, etc.
We can directly access and change *any* pattern value with the command PN:
```
PN 3 0 22
```
Here the first argument (3) is the *bank*, second (0) is the *index*, and last is the new value (22). You could do this by doing P.N 3 then P 0 22 but there are cases where a direct read/write is needed in your patch.
Check the *Command Set* section below for more pattern commands.
Patterns are stored in flash with each scene!
### TRACKER mode
Editing patterns with scripts or from the command line isn't always ergonomic. When you'd like to visually edit patterns, TRACKER mode is the way.
The TAB key cycles between LIVE, EDIT and TRACKER mode. You can also get directly to TRACKER mode by pressing the NUM LOCK key. TRACKER mode is the one with 4 columns of numbers on the Teletype screen.
The current pattern memory is displayed in these columns. Use the arrow keys to navigate. Holding ALT will jump by pages.
The edit position is indicated by the brightest number. Very dim numbers indicate they are outside the pattern length.
Use the square bracket keys [ and ] to decrease/increase the values. Backspace sets the value to 0. Entering numbers will overwrite a new value. You can cut/copy/paste with ALT-X-C-V.
Check the *Keys* section for a complete list of tracker shortcuts.
## Scenes
A *SCENE* is a complete set of scripts and patterns. Stored in flash, scenes can be saved between sessions. Many scenes ship as examples. On startup, the last used scene is loaded by Teletype.
Access the SCENE menu using ESCAPE. The bracket keys ([ and ]) navigate between the scenes. Use the up/down arrow keys to read the scene *text*. This text will/should describe what the scene does generally along with input/output functions. ENTER will load the selected scene, or ESCAPE to abort.
To save a scene, hold ALT while pushing ESCAPE. Use the brackets to select the destination save position. Edit the text section as usual-- you can scroll down for many lines. The top line is the name of the scene. ALT-ENTER will save the scene to flash.
### Keyboard-less Scene Recall
To facilitate performance without the need for the keyboard, scenes can be recalled directly from the module's front panel.
* Press the SCENE RECALL button next to the USB jack on the panel.
* Use the PARAM knob to highlight your desired preset.
* Hold the SCENE RECALL button for 1 second to load the selected scene.
### Init Script
The *INIT* script (represented as I) is executed when a preset is recalled. This is a good place to set initial values of variables if needed, like metro time M or time enable TIME.ACT for example.
## USB Backup
Teletype's scenes can be saved and loaded from a USB flash drive. When a flash drive is inserted, Teletype will recognize it and go into disk mode. First, all 32 scenes will be written to text files on the drive with names of the form tt##s.txt. For example, scene 5 will be saved to tt05s.txt. The screen will display WRITE....... as this is done.
Once complete, Teletype will attempt to read any files named tt##.txt and load them into memory. For example, a file named tt13.txt would be loaded as scene 13 on Teletype. The screen will display READ...... Once this process is complete, Teletype will return to LIVE mode and the drive can be safely removed.
For best results, use an FAT-formatted USB flash drive. If Teletype does not
recognize a disk that is inserted within a few seconds, it may be best to try another.
An example of possible scenes to load, as well as the set of factory default scenes, can be
found at the Teletype Codex
=> https://github.com/monome-community/teletype-codex Teletype Codex
## Commands
### Nomenclature
* SCRIPT -- multiple *commands*
* COMMAND -- a series (one line) of *words*
* WORD -- a text string separated by a space: *value*, *operator*, *variable*, *mod*
* VALUE -- a number
* OPERATOR -- a function, may need value(s) as argument(s), may return value
* VARIABLE -- named memory storage
* MOD -- condition/rule that applies to rest of the *command*, e.g.: del, prob, if, s
### Syntax
Teletype uses prefix notation. Evaluation happens from right to left.
The left value gets assignment (*set*). Here, temp variable X is assigned zero:
```
X 0
```
Temp variable Y is assigned to the value of X:
```
Y X
```
X is being *read* (*get* X), and this value is being used to *set* Y.
Instead of numbers or variables, we can use operators to perform more complex behavior:
```
X TOSS
```
TOSS returns a random state, either 0 or 1 on each call.
Some operators require several arguments:
```
X ADD 1 2
```
Here ADD needs two arguments, and gets 1 and 2. X is assigned the result of ADD, so X is now 3.
If a value is returned at the end of a command, it is printed as a MESSAGE. This is visible in LIVE mode just above the command prompt. (In the examples below ignore the // comments).
```
8 // prints 8
X 4
X // prints 4
ADD 8 32 // prints 40
```
Many parameters are indexed, such as CV and TR. This means that CV and TR have multiple values (in this case, each has four.) We pass an extra argument to specify which index we want to read or write.
```
CV 1 0
```
Here CV 1 is set to 0. You can leave off the 0 to print the value.
```
CV 1 // prints value of CV 1
```
Or, this works too:
```
X CV 1 // set X to current value of CV 1
```
Here is an example of using an operator RAND to set a random voltage:
```
CV 1 V RAND 4
```
First a random value between 0 and 3 is generated. The result is turned into a volt with a table lookup, and the final value is assigned to CV 1.
The order of the arguments is important, of course. Consider:
```
CV RRAND 1 4 0
```
RRAND uses two arguments, 1 and 4, returning a value between these two. This command, then, chooses a random CV output (1-4) to set to 0. This might seem confusing, so it's possible to clarify it by pulling it apart:
```
X RRAND 1 4
CV X 0
```
Here we use X as a temp step before setting the final CV.
With some practice it becomes easier to combine many functions into the same command.
Furthermore, you can use a semicolon to include multiple commands on the same line:
```
X RRAND 1 4; CV X 0
```
This is particularly useful in **INIT** scripts where you may want to initialize several values at once:
```
A 66; X 101; TR.TIME 1 20;
```
## Continuing
Don't forget to checkout the Teletype Studies for an example-driven guide to the language.
=> https://monome.org/docs/modular/teletype/studies-1 Teletype Studies

View File

@ -0,0 +1,431 @@
# Teletype 1.0 Scenes
## 0 TRIANGLE MOUNTAIN
TEMPO ON METRO, SET WITH PARAM KNOB
CV 1 TO OSC FREQ
* 1: RESET POSITION TO 0
* 2: NEXT SCALE
* 3: SHORTEN LOOP
* 4: TOGGLE FORWARD/REVERSE
* 5: THROW CV 2 A NEW NOTE
* 6: RANDOMIZE LOOP LENGTH
* 7: SET ROOT TO CV IN
* 8: ADD 1 SEMI TO CV 4
CHANGE SCALES IN TRACKER.
PATCH CV 2 TO ANOTHER OSC FOR WEIRD COUNTERPOINT
TRY PATCHING CV4 TO CV IN FOR AUTOMATIC TRANSPOSITION.
```
1: P.I 0
2: P.N WRAP ADD P.N 1 0 3
P.I P.END
3: P.END WRAP SUB P.END 1 1 7
4: X EZ X
5: S : CV 2 ADD N P.HERE V 1
S : TR.PULSE B
6: P.END RRAND 1 7
7: Z IN
8: CV 4 N WRAP 0 0 11
M: IF X : P.PREV
ELSE : P.NEXT
CV 1 ADD N P.HERE Z
M SUB 320 RSH PARAM 6
S.ALL
TR. PULSE A
I: L A B : TR.TIME I 40
RE 4 1
```
## 1 RANDOMS
INS CORRESPOND TO OUTPUT JACKS BENEATH:
* 1: RANDOM STATE (TR A)
* 2: RAND DIMINISHED NOTES (CV1)
* 3: BURST GEN (TR B)
* 4: DRUNK SLEWED VOLTS (CV2)
* 5: START/RESET LFO
* 6: 1/F MELODY GENERATOR (CV3)
* 7: (FROM TR D)
* 8: (FROM TR C)
PATCH TR C TO INS, AND TR D TO IN7 FOR LFO FUNCTIONS.
PARAM KNOB SETS BURST RATE.
```
1: TR A TOSS
2: CV 1 N QT RAND 36 3
3: Y ADD 200 RSH PARAM 4
TR.PULSE B
DEL RAND Y : TR.PULSE B
DEL RAND Y : TR.PULSE B
DEL RAND Y : TR.PULSE B
DEL ADD 40 Y : TR B 0
4: Z V RRAND -2 2
CV 2 ADD CV 2 Z
5: T RRAND 10 10000
CV.SET 4 0
CV.SLEW 4 T
CV 4 V 8
DEL T : TR.PULSE C
6: X ADD X RRAND -1 1
PROB 50 : X ADD X RRAND -2 2
PROB 25 : X ADD X RRAND -4 4
PROB 12 : X ADD X RRAND -8 8
PROB 6 : X ADD X RRAND -16 16
CV 3 N WRAP X 0 48
7: T RRAND 10 10000
CV.SLEW 4 Y
CV 4 V 8
DEL T : TR.PULSE C
8: T RRAND 10 10000
CV.SLEW 4 T
CV 4 0
DEL T : TR.PULSE D
M:
I: L A B : TR.TIME I 25
DRUNK 12
CV.SLEW 2 1000
TR.PULSE D
CV.SLEW 3 5
```
## 2 HIDDEN PATH NO PATH
CV 1: OSC FREQ (MAIN)
CV 2: OSC FREQ (DRONE)
TR 1-4: PROBABLE GATES
* 1: CLOCK
* 2: WANDERING STEP
* 3: CV 2 MIRRO CV 1
* 4: STEP FORWARD
* 5: GENTLE WANDER CV 3&4
* 6: JUMP TO START
* 7: SUDDEN TELEPORT CV 3&4
```
1: S.ALL
CV 1 N P.HERE
TR.PULSE A
PROB 80 : TR.PULSE B
PROB 50 : TR.PULSE C
PROB 20 : TR.PULSE D
2: IF TOSS : P.NEXT
ELIF TOSS : P.PREV
3: S : CV 2 CV 1
4: P.NEXT
5: CV 3 V RAND 5
CV 4 V RAND TOSS
6: P.I 0
7: CV.SET 3 V RAND 5
CV.SET 4 V RAND TOSS
8:
M:
I: CV.SLEW 3 500
CV.SLEW 4 200
L 1 4 : TR I 0
P.N 0
```
## 3 4TRACK
NUMLOCK ENTERS TRACKER MODE TO EDIT NOTES
COLS 1-3 ARE NOTES, 4 IS CV 0-1000 FOR OV-10.00V CV/TR OUT PER COLUMN
* 1-4: CLOCK INDIVIDUAL TRACK
* 5: CLOCK ALL
* 6: RESET
* 7: DRUNK POSITION
```
1: P.N 0
CV 1 N P.NEXT
TR.PULSE A
2: P.N 1
CV 2 N P.NEXT
TR.PULSE B
3: P.N 2
CV 3 N P.NEXT
TR.PULSE C
4: P.N 3
CV 4 VV P.NEXT
TR.TOG D
5: P.N 0
CV 1 N P.NEXT
CV 2 N PN 1 P.HERE
CV 3 N PN 2 P.HERE
CV 4 N PN 3 P.HERE
L A D : TR.PULSE I
6: P.I P.END
7: P.I ADD P.I RRAND -2 1
8:
M:
I: L A D : TR.TIME 30
L 1 4 : CV.SLEW 50
```
## 4 MOOD RING
3 VOICE JAZZ BOX GENERATOR
CV 1-3 TO VCO PITCH
TR A-C TO ENVELOPES
TR 1-4 CHANGE ROOT NOTE
* 1: DOWN 2ND
* 2: UP 2ND
* 3: DOWN 3RD
* 4: UP 4TH
TR 5-8 IMPROVISE SCALES
* 5: DOWN 2ND
* 6: UP 2ND
* 7: UP 3RD
* 8: UP 4TH
TR 1 HAS A RHYTHM SET BY METRO TIME.
DRIVE TR1-4 WITH A SLOW CLOCK OR MANUALLY WITH WALK.
DRIVE TR5-8 WITH A FAST CLOCK OR MULTIPLE CLOCK UNPUTS FOR ALGORITHMIC SOLOING.
```
1: X WRAP SUB X 1 0 6
S : CV 1 N PN 0 X
IF EQ X 6 : P.N 3
ELIF EQ X 4 : P.N 2
ELIF EQ 0 MOD X 3 : P.N 0
ELSE : P.N 1
2: X WRAP ADD X 1 0 6
S : CV 1 N PN 0 X
IF EQ X 6 : P.N 3
ELIF EQ X 4 : P.N 2
ELIF EQ 0 MOD X 3 : P.N 0
ELSE : P.N 1
3: X WRAP SUB X 2 0 6
S : CV 1 N PN 0 X
IF EQ X 6 : P.N 3
ELIF EQ X 4 : P.N 2
ELIF EQ 0 MOD X 3 : P.N 0
ELSE : P.N 1
4: X WRAP ADD X 3 0 6
S : CV 1 N PN 0 X
IF EQ X 6 : P.N 3
ELIF EQ X 4 : P.N 2
ELIF EQ 0 MOD X 3 : P.N 0
ELSE : P.N 1
5: Y PN 0 X
P.I WRAP SUB P.I 1 0 14
CV 3 N ADD Y P.HERE
Z ADD 2 MUL 4 TOSS
CV 2 N PN P.N ADD Z X
PROB 70 : TR.PULSE 3
6: Y PN 0 X
P.I WRAP ADD P.I 1 0 14
CV 3 N ADD Y P.HERE
Z ADD 2 MUL 4 TOSS
CV 2 N ADD Y PN P.N Z
PROB 70 : TR.PULSE 3
7: Y PN 0 X
P.I WRAP ADD P.I 2 0 14
CV 3 N ADD Y P.HERE
Z ADD 2 MUL 4 TOSS
CV 2 N ADD Y PN P.N Z
PROB 70 : TR.PULSE 3
8: Y PN 0 X
P.I WRAP ADD P.I 3 0 14
CV 3 N ADD Y P.HERE
Z ADD 2 MUL 4 TOSS
CV 2 N ADD Y PN P.N Z
PROB 70 : TR.PULSE 3
M: S.POP
PROB 50 : TR.PULSE A
DEL MUL T RRAND 1 5 : TR.TOG A
DEL MUL T 4 : TR.PULSE
DEL MUL T 7 : TR.PULSE A
PROB 80 : TR.PULSE B
I: M 750
T 93
L A D : TR.TIME 25
L 1 4 : CV.SLEW I 12
```
## 5 WHITE WHALE REMOTE
MUST CONNECT VIA CABLE
* 1: PRESET 0
* 2: NEXT PRESET
* 3: HARD SYNC, CUT TO KNOB POS
* 4: CUT TO KNOB POS
* 5: PATTERN 0
* 6: QUEUED PATTERN TO KNOB POS
* 7: MUTE TRIGGERS
* 8: UNMUTE TRIGGERS
FOR KNOB SCRIPTS, TRY CHANGING PARAM TO IN,
FOR CV CONTROL!
```
1: X 0
II WW.PRESET X
2: X WRAP ADD X 1 0 7
II WW.PRESET X
3: X RSH PARAM 10
II WW.SYNC X
4: X RSH PARAM 10
II WW.POS X
5: II WW.PATTERN 0
6: X RSH PARAM 10
II WW.QPATTERN X
7: II WW.MUTE1 0
II WW.MUTE2 0
II WW.MUTE3 0
II WW.MUTE4 0
8: II WW.MUTE1 1
II WW.MUTE2 1
II WW.MUTE3 1
II WW.MUTE4 1
M:
I:
```
## 6 MEADOWPHYSICS REMOTE
MUST CONNECT VIA CABLE
* 1: PRESET 0
* 2: NEXT PRESET
* 3: RESET COUNT
* 4: HARD SYNC
* 5: FREEZE 1
* 6: UNFREEZE 1
* 7: MUTE ALL
* 8: UNMUTE ALL
```
1: X 0
II MP.PRESET X
2: X WRAP ADD X 1 0 7
II MP.PRESET X
3: II MP.RESET 1
4: II MP.SYNC 1
5: II MP.FREEZE 1
6: II MP.UNFREEZE 1
7: L 1 8 : II MP.MUTE I
8: L 1 8 : II MP.UNMUTE I
M:
I:
```
## 7 EARTHSEA REMOTE
MUST CONNECT VIA CABLE
* 1: PRESET 0
* 2: NEXT PRESET
* 3: RESET/PLAY PATTERN
* 4: STOP PATTERN
* 5: CHANGE PATTERN TO KNOB
* 6: SET TRANSPOSITION TO KNOB
* 7: TOGGLE CLOCK MODE
* 8: EXT CLOCK
```
1: X 0
II ES.PRESET X
2: X WRAP ADD X 1 0 7
II ES.PRESET X
3: II ES.RESET 1
4: II ES.STOP 1
5: X RSH PARAM 10
II ES.PATTERN X
6: X RSH PARAM 10
II ES.TRANS X
7: Z EZ Z
II ES.MODE Z
8: II ES.CLOCK 1
M:
I:
```