The last (whew) of this round of new modules is a voltage controlled trigger sequencer or, perhaps a better term, trigger sequence generator. It can function as a Euclidean rhythm generator, but it can also create other rhythms via different means. It is designed in Kosmo format, though it can presumably be adapted to any other format capable of supplying enough positive voltage for 5 V voltage regulators.

## What it does

Rather than sending triggers in a sequence that is completely specified by the user, the G.E.A.R. Sequencer creates sequences based on user specified parameters.

It offers a choice of four algorithms:

**G**ap sequence**E**uclidean sequence**A**DC sequence**R**andom sequence

(Hence the name G.E.A.R. Sequencer.) Each algorithm is governed by up to four parameters whose values the user can dial in on potentiometers, or they can be set and dynamically altered using control voltages.

Within limits of program memory and programmer sanity, there is no reason more algorithms could not be added, but these are the four implemented so far.

## Algorithms

**Euclidean sequencing** is familiar and I won’t go into the details here — see http://cgm.cs.mcgill.ca/~godfried/publications/banff-extended.pdf if you need them. The sequence pattern is determined by two parameters: Repetition period (*P*) and number of triggers (*T*). The algorithm distributes the *T* triggers as uniformly as possible among the *P* sequence steps. A third parameter, the offset (*O*), governs not the pattern itself but where the pattern starts/stops relative to where the period starts/stops.

A more novel algorithm is the **gap sequence,** based on the procedure underlying linear scales in tuning theory and the Three-gap Theorem in mathematics — not that you need to know that. I’m not aware of any prior use of this idea for trigger sequencing although I would be quite surprised if no one else has done it before. In a gap sequence the pattern is defined by three parameters: *P*, *T*, and the generator (*G*). For a given *P* and *T* there is exactly one Euclidean sequence, but there are up to *P*/2 gap sequences corresponding to different generators. Again, the position of the sequence start relative to the period can be specified by *O*. You can find details of the algorithm here, or in prior blog posts here and here.

An **ADC sequence** uses a pattern based on digitization of an analog control voltage. You specify *P* and a value to digitize, *V*, as well as, again, *O*. The sequence pattern is the first *P* bits in the digitization of *V*. This is similar to something the Barton Musical Circuits BMC006 Voltage To Rhythm Converter does (though the BMC006 does a lot more with the idea).

A **random sequence** is fairly self explanatory. For a given *P* and *T*, the algorithm distributes *T* triggers randomly within *P* steps. The random pattern is then repeated indefinitely, offset by *O* as with the other types, until a new sequence is requested. Another “parameter” is the throw (*Th*). The value of the throw is not used to determine the pattern, but if it changes, a new random pattern will be chosen.

## Photos

## Demo

## Documentation

- Schematic
- PCB layout: front, back
- BOM
- Build notes
- Implementation details
- Gap sequence algorithm
- Usage notes

## GitHub repository

Schematics, KiCad design files, Gerbers, docs here: