Ornaments and Crimes extended firmware

Tim Churches edited this page Feb 8, 2017 · 84 revisions

Ornaments & Crimes v1.1.x: Extended Firmware for the Ornament & Crime DIY eurorack module

The documentation on this page refers to v1.1.x firmware for Ornament & Crime. The most recent version of the firmware is v1.2 and documentation for it can be found here.

welcome

  • Ornaments & Crimes is a collaborative open-source project by Patrick Dowling (aka pld), mxmxmx and Tim Churches (aka bennelong.bicyclist). It (considerably) extends the original firmware for the Ornament & Crime (O+C) DIY eurorack module, designed by mxmxmx.

  • There is still a quantising ASR (analogue shift register) function in Ornaments & Crimes, now named CopierMaschine, but several other "apps" have been added. These apps are selectable on-the-fly, without having to reboot the module or toggle the power. Several of these apps are experimental, or perhaps, quirky, in nature, which is not an accident: O+C makes an ideal platform for (relatively) quickly prototyping of ideas and testing them in the eurorack modular synth context. That said, none of the apps are intended to be just toys, and some provide cutting-edge performance and/or capabilities not currently found in any other eurorack module.

  • The O+C module, and the Ornaments & Crimes firmware for it, also break new ground as a polymorphic module: a generic set of inputs and outputs are provided, and the textual OLED display is used to permit re-mapping of these inputs and outputs for each app, and in some cases, for each of the four channels within each app. Further refinement of this polymorphic design pattern is planned. Hard-wired, analogue modules are necessarily single-purpose, but the same is not true of digital modules, in the same way that (say) a modern smartphone can be used for a great deal more than just telephony. We believe that a single, somewhat generic module can serve as an adequate platform for many different purposes and functions. The O+C module does not purport to be the paradigmatic pinnacle of polymorphism - in fact, it was originally designed to fulfil just one purpose (= ASR) - but together with the Ornaments & Crimes firmware suite for it, we hope it provides an interesting and useful early step in the evolution of such multi-purpose modules.

  • The TL;DR version of this documentation: qual, in Seattle, has kindly assembled a very useful "cheat sheet" containing a condensed version of this documentation, available here.

#####The apps currently available in Ornaments & Crimes are:

  • CopierMaschine is an enhanced version of the original quantising digital emulation of a four stage analogue shift register (ASR).
  • Harrington 1200 provides basic neo-Riemannian Tonnetz transformations of triadic chords, triggered by the digital (gate/trigger) inputs.
  • Automatonnetz combines Tonnetz transforms with a "vector" sequencer - it can be both a chord sequencer and a melody sequencer, but not of the usual kind.
  • Quantermain is a quad pitch quantiser for external voltages, with editable scales; it can do clocked (trigger-driven) quantising, or continuous quantising, with a latency of under 100 microseconds; it also features quad Turing Machines, May-Verhulst logistic maps or byte beats as optional, semi-random, internally generated CV sources.
  • Quadraturia is a wavetable quadrature LFO, based on the "Easter egg" in the Mutable Instruments Frames module.
  • Low-rents is a dual Lorenz and Rössler (strange attractor) modulation generator, partially based on the "Easter egg" in the Mutable Instruments Streams module.
  • Piqued is a quad voltage-controlled envelope generator, based on envelope generator code from the Mutable Instruments Peaks module, but extending it with voltage control, additional envelope types, including re-triggering (looping) envelopes, additional segment shapes, adjustable trigger delays, and a unique Euclidean "trigger filter" which turns the app into a Euclidean rhythm generator which can output envelopes, not just gate or trigger pulses.
  • Dialectic Ping Pong is a quad bouncing ball envelope generator, based on a hidden mode of the Mutable Instruments Peaks module.
  • Viznutcracker, sweet! is a quad "byte beat" equation generator, which can be used as an audio source to generate curious but often interesting 8-bit noises and tunes, or which can be clocked by an external source to produce "byte beat" control voltage sequences. "Byte beats" were first described in 2011 by viznut (aka Ville-Matias Heikkilä).
  • References is a simple utility app that outputs specific reference voltages on each channel to help tune or calibrate VCOs and other modules.

For information about the O+C module hardware, including DIY build details, please start here.

Appendices

Startup

Immediately after power-on, the start-up phase is indicated by a line at the bottom of the display which progressively shrinks right-to-left. By default, following start-up phase, the module boots into the last saved app, unless one of the encoders is held down:

  • hold down the Left encoder: Boot into calibration mode (unchanged from the original O+C firmware - please see the calibration procedure here)
  • hold down the Right encoder: Enter the app selection menu

App Selection

The app selection menu can be reached either when the module is first powered on, as described above, or by depressing the right encoder for two seconds or longer (a long press) during normal use.

  • Turn the right encoder to select an app
  • Press the right encoder to switch to the selected app
  • Pressing the Up button (the upper button to the right of the display) while the App Selection screen is displayed toggles encoder acceleration on and off (there is no visual indication of this). Encoder acceleration increases the amount by which values are incremented or decremented on each encoder rotational click when you are rapidly spinning the encoder in value edit mode, rather than advancing it slowly one click at a time. This speeds up sweeping across the full range of values, while still retaining full precision when moving the encoder one step at a time.

Save Settings / Module State

Settings aren't saved automagically. To save the current state/settings, enter the app selection menu (see above), then long press the right encoder (>2s) again to save the module state and make the selected app the default at the next boot. This also saves all the current settings of all apps.

  • The settings are saved permanently in the Teensy EEPROM storage. (The settings storage uses a basic form of wear-levelling. EEPROM memory can only be written to a certain number of times before it becomes unreliable. The EEPROM storage on the Teensy 3.2 used in O+C is good for at least 100,000 write cycles, and probably a lot more. Meaning, you are very unlikely to wear out the EEPROM memory in the Teensy processor in your O+C module with normal use.)

General operation of the apps

Each app has two display pages, a settings mode and a "screensaver" mode. The apps drop into screensaver mode after a short period of inactivity (that is, no user interaction); the timeout period can be set in the calibration menu. Alternatively, long press (> ~ 1.5 sec) the up button to preview the screensaver.

  • In the background, the module functions the same regardless of whether settings are displayed or the screensaver is displayed. When the screensaver is displayed, clicking or rotating either of the two encoders, or pressing the Up or Down buttons will immediately swap to the settings display.

  • In settings mode, for most of the apps, the right encoder is used to scroll up and down the list of available settings, and clicking on the right encoder will toggle edit mode, indicated by one or two small up/down triangles next to the setting. Turning the right encoder when in edit mode will increment (increase) or decrement (decrease) the relevant setting. Clicking again on the right encoder toggles back to settings selection mode.

  • In multi-channel apps, the left encoder selects which of the four channel (A to D) settings are currently displayed (and editable). All channels remain active in the background, all the time, even while editing settings. The channel can be changed even when value edit mode is active, making it easy to edit the same setting on each ofthe four channels.

  • In other apps, the left encoder is used to set a root note or a transposition, or to set frequency or rate. Its exact behaviour is noted below in the documentation for each of the apps.

  • The two buttons to the right of the display (the Up and Down buttons) either transpose notes up or down an octave, or increase or decrease frequency or speed in steps of 32 (with a few exceptions for some apps, as noted below).


CopierMaschine

Works much the same as the original o_C / quantising ASR firmware. Except, the mode now incorporates some of the new/improved quantiser features, including a larger selection of (editable) preset scales as well as advanced user-scale-edit options (for details, see the Quantermain "app" below).

In essence, then, ASR mode works as a cascaded, four-stage sample-and-hold module (see here for a classic exposition). Feed a pulse into the left-most digital input (TR1), and some CV signal (LFO, ADSR, etc) into the leftmost CV input (CV1): on receiving a/the clock, the DAC outputs will be updated, ASR-style: the sampled value will be present at output A, the previous sample values shifted down the remaining outputs B, C, and D.

The ASR mode features additional parameters, including

  • a rudimentary delay (= controlled via the index parameter (CV2))
  • scale 'mask' rotation (CV3)
  • hold (= "freeze" the sample buffer) (TR2), and
  • transposition (in octaves) (TR3, TR4, CV4)

The index parameter works as a delay, sort of: the ASR outputs the sampled values S[x] stored at the buffer locations index * output-stage, ie A = S[i*1], B = S[i*2], C = S[i*3], D = S[i*4]. The default setting or increment is 0 (internally i = 1), in which case things boil down to standard ASR behaviour:

A = S[1], B = S[2], C = S[3], D = S[4]

If the index parameter was set to, say, i = 8, the ASR will now output the values stored in the buffer at locations A = S[8], B = S[16], C = S[24], D = S[32], thus delaying output A by 8 clocks, B by 16 clocks, and so on. Ie, modulating the index parameter doesn't just delay but allows to create different patterns (based on the contents of the buffer). The size of the buffer is 256. When the hold input goes high (using a gate or the like), no further samples will be acquired; when clocked, the four outputs then simply cycle through what's already the buffer (with index= 1, the note value at D will reappear at output A, etc)

Please see the discussion of the Trigger delay menu selection in the Quantermain app documentation below - the same considerations apply to the Trigger delay setting in CopierMaschine.

A brief video demonstration of the CopierMaschine in action, with live audio, is available on YouTube.

Inputs and outputs

I/O Function
TR1 Clock input
TR2 Hold (freeze ring buffer)
TR3 Transpose: Octave up, when high
TR4 Transpose: Octave down, when high (overridden by TR3)
CV1 Sample in
CV2 Index: ring buffer index (= "delay")
CV3 Mask: rotate scale mask
CV4 Transpose: octave up/down (-4/+4)
A, B, C, D ASR outputs 1-4

Controls

Control Function
Left encoder (turn) Select scale in main menu; move cursor in scale edit menu
Left encoder (press) Activate scale in main menu; add/remove note in scale edit menu
Right encoder (turn) Navigation mode: move up and down through the menu items. Edit mode: increase or decrease the value being edited; move scale "mask" in scale edit menu
Right encoder (press) Toggle between menu navigation (selection) mode and value editing mode
Right encoder (long press) App selection menu
Up button Transpose up: one octave
Down button Transpose down: one octave

Available settings (per-channel)

Setting Meaning
scale Current scale
Root Root note for scale
Active notes "scale mask" / active note pattern in the selected scale
Index ring buffer index (= "delay") amount
Mult/att CV "gain", multiplies incoming CV sample value by selected value (range: 0.1 - 2.0)
Trigger delay sets the delay between receiving a trigger (for details see QQ below)

Scale edit:

see here (user-scales are shared across apps).

Screensaver display

Four little "Arabesque" patterns, representing the pitch CV output on each of the four channels.

Possible future enhancements:

  • the current ability to loop through the ring buffer of pitches encountered is half way to providing a more general "CV recorder" function - thus, either extend this app, or provide a seperate app, which can act as a general-purpose CV recorder, similar to the Shakmat Modular Bishop's Miscellany module, either with CV and gate recording on two channels, or just clocked CV recording on 4 channels.

Harrington 1200

This is a relatively straight-forward implementation of neo-Riemannian transformations for generating triad (three note chord) progressions (see the Credits, thanks, acknowledgements, and sources of inspiration section at the end of this document for more details on neo-Riemannian music theory).

In settings mode, the top line of the display shows, from left to right:

  • the current root note for the root (initial) chord
  • the musicological mode (major or minor) for the root chord
  • the three notes comprising the current triad being output. Clicking on the left encoder toggles between note display and display of semitone offset from the root note.

The root note can be changed using the Transpose setting in the menu. The left encoder can also be used to change this setting at any time (such as during live performance). The voltage input on CV1 also changes the root note (i.e. the transposition).

The musicological mode of the root chord is set by Root mode in the menu to either major or minor. Chord inversion is similarly set using the Inversion menu item. The voltage input on CV4 also changes the inversion.

The pitch voltage (scalled to 1V/octave) for the root note appears on output A. The pitch voltages for the three notes of the current triad appear on outputs B, C and D. Thus, to pproduce chords, you should feed the B, C and D outputs into the 1V/octave pitch inputs of three VCOs.

Trigger inputs TR2, TR3 and TR4 are used to apply the P, L or R transformations (see below). Trigger input TR1 resets the current triad back to the root chord.

If multiple triggers are received, the reset input (TR1) always has priority, then all triggered transforms are applied. The order in which they are applied can be set in the menu by the Priority setting.

The neo-Riemannian transformations themselves are quite simple, and "reversible" i.e. applying them twice returns the original triad. The following basic tranformations are used:

  • P (Parallel): Moves the third up or down a semitone, thus P(Cmaj) = Cmin, P(Cmin) = Cmaj.
  • L (Leittonwechsel): Converts a major triad to a minor by shifting the root down a semitone and making the third the root, or from minor to major by moving the fifth up a semitone to become the root.
  • R (Relativ): Converts a major triad to its relative minor, or a minor triad to its relative major.

Internally, the triad is stored in a neutral form (basically just offsets), thus the chord voicing is preserved and can be shifted easily to the quantised root note, and inversions created on-the-fly. For an alternate way of implementing these transformations, see the documentation of the Tonnetz Sequent.

A brief video illustrating the operational principles of the Harrington 1200 app is available on YouTube.

Screensaver display

The current triad (output as pitch CVs on the B, C and D sockets) is shown graphically on the left. The circumference of the circle has 12 points on it, one point for each semitone in an octave, with C at the 12 o'clock position. The current triad is indicated by the three dots, joined to form a triangle. The middle section of the screensaver display shows the last four transformations applied, with the most recent one at the top. The rightmost section indicated the current triad being output, with numbers showing the octave for each note.

Tip: for a pretty display, patch the output of an LFO into CV1 in order to rapidly rotate the root note up and down.

Settings

Setting Meaning
Transpose Shift root/triad in semitones (can be offset by CV1)
Root mode Mode of root triad, either maj or min
Inversion Chord inversion (can be offset by CV4)
Priority Order in which transforms are applied if multiple triggers on TR@, TR3 and TR4 are received simultaneously
Output mode Output mode, with the default being chord, or use tune to output the quantised root on all four output channels

Controls

Control Function
Left encoder (turn) Root note transpose up or down
Left encoder (press) Toggle display of note numbers (semitone offsets from the root note) or names (note: the names are the simplest possible mapping, thus there are no enharmonic substitutions)
Left encoder (long press) Reset to defaults
Right encoder (turn) Navigation mode: move up and down through the menu items. Edit mode: increase or decrease the value being edited.
Right encoder (press) Toggle between menu navigation (selection) mode and value editing mode
Right encoder (long press) App selection menu
Up button Increment chord inversion by 1
Down button Decrement chord inversion by 1

Inputs and outputs

I/O Function
TR1 Reset to root triad
TR2 P transform
TR3 L transform
TR4 R transform
CV1 Root note transposition, quantised to +/- 24 semitones
CV2 Octave transposition
CV3 Post-transformation transposition, quantised to semitones
CV4 Chord inversion
A Quantised root
B, C, D Transformed & inverted triad (also quantised)

Tips

Try using a rhythm generator, such as the Mutable Instruments Grids module, or the ALM/Busy Circuits Pamela's Workout module, or the Rebel Technology Stoicheia module, or some combination of clock division and logic modules, or even a second O+C module running the Piqued app with Euclidean trigger filters engaged, to trigger the P, L and R transformations (via trigger inputs TR2, TR3 and TR4) in varying patterns to create a variety of chord progressions that may or may not be musically pleasing, or interesting, or horrifying.

Possible future enhancements

  • Provide an option which outputs the sum, or other linear combinations, of the pitch CVs for the current triad, on output A, instead of the pitch CV for the root note. No idea if that would be musically useful or not, but it can't hurt to try.

  • add Euclidean trigger/clock filters to the Harrington 1200, so that a single clock input can create a polyrhythmic pattern of triggers to drive the transformations.

  • work out to what use the CV2 and CV3 inputs might be put (maybe for the Euclidean trigger filter mentioned above?)

  • portamento for chord transitions, which may or may not be useful for chords (it is not traditional)

Example tracks

  • La Petite Souris - composed live, in one take, entirely by the Harrington 1200 app, driven by a Mutable Instruments Grids module.
  • Deus ex macchiato - another track composed on-the-fly entirely by the Harrington 1200 app.

Automatonnetz

This app uses the neo-Riemannian transformations implemented in the Harrington 1200 app (see above), but with the sequence of transformations determined not through triggers for each type of transformation, but rather by navigating a 5x5 grid of cells. On each clock input the dx (delta x) and dy (delta y) - hence "vector" sequencer - values are added to the current position on the grid to determine the next cell. The position simply wraps around when it reaches the edge of the grid, and "backwards" motion is also possible. The position and movement can also be fractional, allowing for clock divisions and all kinds of patterns.

Each cell of the grid can contain a neo-Riemannian transformation, or a reset, as well as other parameters. In this app, there are three additional transforms available, which can be represented as a combination of the basic three neo-Riemannian transforms:

  • S (Slide): LPR, example S(Cmaj) = C#min
  • H (Hexatonic): LPL, example H(Cmaj) = A-min
  • N (Nebenverwandt): RLP, example N(CMaj) = Fmin

The implementation computes these in a single transform step however, not sequentially.

Controls

Control Function
Left encoder (turn) Select cell in the grid - the 25 cells are accessed sequentially, row-wise.
Left encoder (press) Toggle between editing overall grid settings or current cell settings
Left encoder (long) Clear/reset grid (the results of this action depends on Clr setting)
Right encoder (turn) Navigation mode: move up and down through the menu items. Edit mode: increase or decrease the value being edited.
Right encoder (press) Toggle between menu navigation (selection) mode and value editing mode
Right encoder (long press) App selection menu
Up button Reset current cell position to grid origin (top left-hand corner of grid)
Down button Increment grid position by one clock step

Grid settings

Setting Meaning
dx Amount of movement along x-axis (horizontal) per clock input
dy Amount of movement along y-axis (vertical) per clock input
Mode Musicological mode of root triad, either maj or min
Oct Move outputs up/down in octave steps
OutA Switch output mode of channel A: root outputs root note, trig outputs a trigger whenever the triad output on B, C and D is transformed, arp arpeggiates the current triad, strm (strum) arpeggiates the triad once only as soon as the triad transformation has taken place (tip: very useful with the Mutable Instruments Elements or Rings modules, or Mutable Instruments Braids in "PLUK" mode)
Clr Sets how the grid is cleared on a long-press of the left encoder. zero clears the grid, rT fills with random transforms, rTev sets each cell's event to randT

Per-cell settings

Setting Meaning
Trfm Determines the transform which is applied when this cell is active; special values are @ (reset) and * (no transform)
Offs Offset in semitones applied while this cell is active
Inv Inversion of the transformed triad
Muta Mutation event that is applied when the cell is left (i.e. on the next clock after the cell's transform is applied). Valid values are shown in the table below. Note that this setting makes the grid self-modifying as the current cell traverses it!
Muta setting Action
none nothing happens
rT__ The transformation for this cell is set to a random value.
r_O_ The transposition for this cell is set to a random value.
rTO_ The transformation and the transposition for this cell is set to a random value.
r__I The inversion for this cell is set to a random value.
r_OI The transposition and the inversion for this cell is set to a random value.
rTOI The transformation, the transposition and the inversion for this cell is set to a random value.

Input/output assignment

I/O Function
TR1 Clock/trigger input to increment steps in the sequencer
TR2 Arpeggiator clock (if mode is arp or stem)
TR3
TR4 If high, inhibits arpeggiator clock
CV1 The voltage on this input is quantised to the root note of triad (before transform) - that is, it provides external voltage control of the root note (same as Harrington 1200)
CV2
CV3
CV4 Modulate triad inversion (same as Harrington 1200)
A Depending on the OutA setting: pitch CVs for quantised root note, arppegio/strum, or trigger out
B, C, D Pitch CVs for the triad after transformation

Screensaver display

Similar to Harrington 1200 app, the current triad (output as pitch CVs on the B, C and D sockets) is shown graphically on a pitch circle on the left. On the right, the last few vector moves are shown as a "snake". The current output triad is also displayed.

Tips

If you wish to use the vector sequencer to play melodies, then set the TRFM (transform) value for every cell in the grid to * (null transform), and set the Offs value for each cell to a specific note offset from the root note that you want to appear in your sequence. Then, as the current cell is moved around the grid by clock/trigger inputs on TR1, the note defined for that cell will be output on output B (with transpositions of the same note sequence on outputs C and D).

Example tracks

  • Oh Tomato Nets! - a track composed in real-time, live, on-the-fly, entirely by the Automatonnetz app.

Possible future enhancements

  • Provide an option which outputs the sum, or other linear combinations, of the pitch CVs for the current triad, on output A, instead of the pitch CV for the root note. No idea if that would be musically useful or not, but it can't hurt to try.

  • Work out to what use the CV2 and CV3 inputs might be put.

  • Provide a mode (or a separate app) that permits 4 independent grids of specific note values to be defined (one of each output channel), so that the apps can act as a vector sequencer outputting 4 distinct "melodies".


Quantermain

4 channel Quantiser, integrates the quantiser from the Mutable Instruments Braids module, but expands it with interactive scale-edit functionalities (48 editable preset scales are included, plus 4 fully user-definable scales (with additional finetune/microtonal edit options)).

The output accuracy should be excellent (is fairly excellent) due to the use of a precision Texas Instruments 16-bit DAC; the input side uses the Teensy internal ADCs, with 12 bits of effective resolution, which should be more than enough for almost all purposes. The trigger-to-quantised-output latency is also very decent: < 100 microseconds.

Input/output assignment

I/O Function
TR1, TR2, TR3 & TR4 Mappable as the trigger input for each channel A to D, independently
CV1, CV2, CV3 & CV4 Mappable as the external CV input to be quantised for each channel A to D, independently
A Output voltage for channel A (quantised if quantisation is enabled)
B Output voltage for channel B (quantised if quantisation is enabled)
C Output voltage for channel C (quantised if quantisation is enabled)
D Output voltage for channel D (quantised if quantisation is enabled)

Controls

Control Function
Left encoder (turn) Select channel, or note in scale in scale edit mode
Left encoder (press) Increment channel by one
Right encoder (turn) Navigation mode: move up and down through the menu items. Edit mode: increase or decrease the value being edited.
Right encoder (press) Toggle between menu navigation (selection) mode and value editing mode
Right encoder (long press) App selection menu
Up button Transpose up one octave for currently displayed channel
Down button Transpose down one octave for current displayed channel

Available settings (per-channel)

Setting Meaning
scale Current scale
Root Root note for scale
Active notes "scale mask" / active note pattern in the selected scale
CV Source external CV source (CV1 to CV4) or internal value sources (Turing Machine or Lgstc (logistic map) or ByteB (byte beats) for the current channel
Trigger source Trigger input source (TR1 to TR4, or cont for continuous quantisation) for the current channel
Clock div Clock divider for the trigger input selected for the current channel (note: the same trigger source may have different clock dividers set in each channel)
Trigger delay sets the delay between receiving a trigger (or gate rising-edge) on the chosen trigger input for the current channel, and the input voltage being sampled. It defaults to Off (no delay beyond the normal latency, which is less than 100 microseconds, typically about 50 microseconds), but available values are 120us, 240us, 360us, 480us, 1ms, 2ms and 4ms. O&C is very fast, and typically will sample an input voltage just a few tens of microseconds after receiving a trigger signal (in triggered/clocked quantisation mode). If a sequencer or some other stepped voltage source is being sent to the quantiser, then that voltage may still be slewing to its new intended voltage when O&C samples it, or if this source is digital, there may be a few tens of microseconds delay before the voltage source reacts to the trigger signal (assuming it is the same trigger signal that has been sent to O&C) and starts to slew to the new voltage. If this is the case, the Quantermain or CopierMaschine apps will be sampling and quantising the previous sequence step CV, or the may be sampling the CV as it is slewing to the new value. In such cases, increase the Trigger delay setting until the new CV is reliably sampled after each new trigger/clock signal is received. Note that use of a shorter trigger delay than that required to reliably sample the input CV may result in "wrong notes", but this may have creative uses, because the wrong notes will still be quantised and constrained to the chosen scale. These considerations only apply when using Quantermain in trigger mode and to the CopierMaschine app, which can only be used with an external trigger) - they do not apply when Trigger Source is set to cont in Quantermain.
Octave Octave transposition up or down (Up and Down buttons also do this) of output CV for current channel, after quantisation. Note that the output range of O+C is about -3V to +6V, but the octave transpose down goes down to -4. Why? Well, the Octave setting is added to whatever the input voltage is for that channel - that's why it goes down to -4. If there is no input voltage for that channel, then setting Octave to -4 will output -3V, as will setting it to -3. But if there is, say, a 1.25V input for that channel, then setting Octave to -4 will result in a -2.75V output, whereas setting it to -3 will result in a -1.75V output.
Transpose Semitone transpose up or down of output CV for current channel, after quantisation
Fine Fine tuning control, adjusts the pitch CV for the current channel up or down in tiny increments.

Method of operation

When used as a voltage quantiser, for each of the four independent channels, the Quantermain app reads an input voltage from the CV source set for that channel and quantises it to the scale and notes set for that channel, and then applies any post-quantisation transpositions that have been specified. Voltages are read an a new quantised voltage is output when the trigger source specified for that channel fires (rising edge of the trigger, clock or gate signal), unless Trigger source is set to cont, in which case quantisation is performed continuously on the input voltage. The latency from receipt of a trigger to output of a newly quantised note is under 100 microseconds, and is typically about 50 microseconds. In continuous quantisation mode, the input voltage is read at an effective rate of about 1 kHz, thus quantisation of the input occurs approximately once every millisecond.

When the CV source is set to Turing or Lgstc, instead of reading a voltage on one of the CV inputs (CV1 to CV4), an internally generated value is used instead (for that channel - you can use Turing or Logistic internal sources on some channels and external CV sources on others).

The Turing source uses a linear-feedback shift register (LFSR) randomly seeded with habit pattern, which is right-shifted by one bit at each clock step (read from the Trigger source for that channel). There is a settable probability that the least-significant bit is randomly each time the pattern is shifted by one. This arrangement was popularised in modular synthesis as the Richter Noise Ring and the Music Thing Turing Machine. The name of the latter module has been borrowed here. References to Turing Machines and LFSRs can be found in the Credits, thanks, acknowledgements, and sources of inspiration section at the end of this document.

If a Turing Machine has been selected as as the CV Source, then the following additional settings are made available:

Setting Meaning
LFSR length Length of the linear feedback shift register, in bits, range 2 to 32
LFSR p Probability that the least significant bit will be flipped when it to copied
LFSR range The range or span of notes available to the LFSR (Turing Machine) from which a note is selected
LFSR p CV src (v1.1 or later only) The control voltage source (none, or CV1, CV2, CV3 or CV4 inputs) used to control the probability. The CV value is added to the probability value set via the LFSR p menu item (see above).
LFSR rng CV src (v1.1 or later only) The control voltage source (none, or CV1, CV2, CV3 or CV4 inputs) used to control the range or span of notes available to the LFSR (Turing Machine) from which a note is selected. The CV value is added to the range value set via the LFSR range menu item (see above).

If a Logistic Map has been selected as as the CV Source, then the following additional settings are made available:

Setting Meaning
Logistic r The r coefficient for the logistic map equation
Logistic range The range or span of notes available to the Logistic Map from which a note is selected.
Log r CV src (v1.1 or later only) The control voltage source (none, or CV1, CV2, CV3 or CV4 inputs) used to control the r coefficient for the logistic map equation. The CV value is added to the r value set via the Logistic r menu item (see above).
Log rng CV src (v1.1 or later only) The control voltage source (none, or CV1, CV2, CV3 or CV4 inputs) used to control the range or span of notes available to the Logistic Map from which a note is selected. The CV value is added to the range value set via the Logistic range menu item (see above).
Logistic seed The seed value to initialise the logistic map (has very little effect, but different values result in different sequences)

(v1.1 and later) If ByteB (byte beats) has been selected as as the CV Source, then the following additional settings are made available:

Setting Meaning
Bytebeat eqn sets the byte beat equation used as the source. See the Viznutcracker. sweet! app documentation for more details of the currently available equations.
Bytebeat range The range or span of notes available to the byte beat equation source from which a note is selected.
Bytebeat P0 Parameter 0 for the byte beat equation - see See the Viznutcracker. sweet! app documentation for more details.
Bytebeat P1 Parameter 1 for the byte beat equation - see See the Viznutcracker. sweet! app documentation for more details.
Bytebeat P2 Parameter 2 for the byte beat equation - see See the Viznutcracker. sweet! app documentation for more details.
Bb eqn CV src The CV input source to vary the byte beat equation used.
Bb rng CV src The CV input source to vary the byte beat range.
Bb P0 CV src The CV input source to vary byte beat equation parameter 0.
Bb P1 CV src The CV input source to vary byte beat equation parameter 1.
Bb P2 CV src The CV input source to vary byte beat equation parameter 2.

Note that the Turing Machine, Logistic Map and byte beat sources all require clock inputs to make then step, and they do not operate when Trigger source is set to cont.

Active note (scale mask) and scale editing

To invoke the active note and scale editor, click the right encoder when the Active notes menu option is selected.

  • turn the left encoder to move the note cursor, click the left encoder to toggle currently selected note on or off
  • Up/Down buttons invert the current note mask
  • turning the right encoder note-shifts the pattern left or right (= rotate scale mask)
  • click the right encoder to exit

Using the note editor (user-scales 1-4):

  • use the right encoder to scroll to the top of the menu, and click the right encoder to select the scale. Choose one of the 4 user-editable scales (USER1, USER2, etc) at the beginning of the list of scales. Click the right encoder again to return to menu scrolling mode.
  • Scroll down to Active notes and click the right encoder to invoke the note editor.
  • turn the left encoder to move to the note you wish to edit. Hold down the left encoder, and use the right encoder to edit the pitch value for that note.
  • the length of the scale can be set by navigating to the final note in the scale, and turning the right encoder to shorten or lengthen the scale. In this way, scales with 4 up to 16 microtonal notes are possible.
  • click the right encoder to exit the note editor

Screensaver display

The screensaver for Quantermain is inspired, possibly on an unconscious level, by the Sick Bay vital signs display in the original Star Trek series. There are four "lanes", one for each channel. In each lane, short lines representing the quantised pitch (on a semitone scale) scroll leftwards. The small triangles to their right move up and down to indicate the octave for that channel. Triggers (a vertical bar) and input voltages (a horizontal bar, left-going for negative voltages, right-going for positive) are indicated above each channel lane (replaced by a bit-pattern display when the sources are set to LFSR (Turing Machine) or logistic map, rather than external CV).

Tips

You can disable quantisation on each channel by setting the scale to Off. When in clocked mode (that is, Trigger source is set to TR1, TR2, TR3 or TR4), then that channel acts as a traditional sample-and-hold (S&H), without any voltage droop, of course. Thus, Quantermain can act as a quad S&H if you want. The only limitation is that the effective maximum sample rate is about 1 kHz, even if the clock/trigger signal you give it is at a higher frequency. This is because the ADCs are only read at an effective rate of about 1 kHz.

Disabling quantisation when using a Turing Machine or Logistic map as a source allows the output for that channel to act as a semi-random modulation source.

Possible future enhancements

  • portamento! Possibly with settable speeds in either direction, and a choice of curves and easing (spring physics portamento, perhaps?)
  • adjustable sampling delay, as in Braids (done!)
  • user-adjustable hysteresis parameters to fine-tune latency vs jitter for various scenarios and use-cases
  • are there any useful ideas or concepts in the Barton User Writable Quantizer that could be added to Quantermain?
  • a two-channel mode, in which two of the output channels, say A and C, emit quantised pitch CVs, and the other two channels, B and D, emit a corresponding gate or trigger, or even better, an envelope. This might be useful with trigger-less or non-clocked quantisation (that is, when Trigger source is set to cont (continuous)), and you want a trigger/gate/envelope to be output with the quantised pitch CV, each time the pitch changes to a different note. Settable delay and/or hysteresis is almost certainly required for such a feature to work reliably, or usefully.

Example tracks

  • Verhulst's Map - a track composed and created in real-time entirely by the Quantermain app, using the quantised output of the internal Logistic map source.
  • Equitable Equations and Melancholectomy- are two trackscomposed and created in real-time entirely by the Quantermain_ app, using the quantised output of the internal ByteB (byte beats) source.

Quadraturia

Quadraturia is a port of of the quadrature wavetable LFO that is available as the "Easter egg" in the Mutable Instruments Frames module. However, Quadraturia adds voltage control over three of the four LFO parameters (as well as CV control of frequency/rate of the LFO, as in Frames). Because the background ISR of O+C runs at 16.6KHz instead of 32KHz as in Frames, the behaviour of Quadraturia may not be identical to the Frames Easter egg, but it should be very close, and is nonetheless a very useful and flexible source of modulation voltages. For more details of how the Frames Easter egg LFO behaves, see the relevant section of the Frames Manual.

Internally, there are four LFOs (LFO1 to LFO4), with LFO2 to 4 running at some ratio of the (master) frequency of LFO1 (by default, that ratio is one, so all the LFOs run at the same frequency). The wave shape, phase of frequency modulation of LFO2 to 4 can be changed, relative to those parameters for LFO1, using the Shape spread, phase/frequency spread and coupling controls (see table below).

IO Function
TR1 Reset phase (all LFOs)
TR2 Freeze (all LFOs stop in their tracks and hold current value while TR2 is high)
CV1 Master frequency
CV2 Wave shape
CV3 Shape spread
CV4 Coupling
A, B, C, D LFO channel outputs

Controls

Control Function
Left encoder (turn) Increase or decrease frequency of master LFO
Left encoder (press) Toggle frequency control between Coarse and Fine control.
Right encoder (turn) Navigation mode: move up and down through the menu items. Edit mode: increase or decrease the value being edited.
Right encoder (press) Toggle between menu navigation (selection) mode and value editing mode
Right encoder (long press) App selection menu
Up button Increment frequency by 32
Down button Decrement frequency by 32

Settings

Setting Meaning
Coarse or Fine (frequency) Frequency, range is 0-255 for coarse adjustment, and each unit of the coarse adjustment is divided into 256 steps for fine adjustment
Shape controls the shape of the primary waveform (LFO1), as shown in the preview waveform
Shape spread sets the difference in wavetable position between each channel (and thus the differences in the wave shape for chennels B, C and D.
Phase/frq spread sets the phase or frequency offset between each channel. Values greater than zero cause the phase to be offset incrementally in channels B, C and D wrt channel A. Values less than zero cause a progressive frequency shift (detune) across channels B, C and D wrt channel A.
Coupling sets the degree of phase-modulation “bleed” between each successive channel.
Freq range (v1.1 and later) sets the frequency range for the quadrature LFOs, with self-explanatory settings of "vslow", "slow", "med", "fast" and "vfast". The faster settings extend into audio range. Note that Quadraturia does not, and is not intended to track 1V/octave.
B freq ratio sets the frequency ratio at which LFO2 (channel B) runs wrt the master LFO (LFO1, channel A). The default is unity, so that it runs at the same frequency as channel A. Available ratios are 4/5, 2/3, 3/5, 1/2, 2/5, 1/3, 1/4, 1/5, 1/6, 1/7, 1/8, 1/9, 1/10, 1/11, 1/12, 1/13, 1/14, 1/15 and 1/16.
C freq ratio does the same as B freq ratio, except for the channel C LFO.
D freq ratio likewise
B XOR A if enabled causes the 16 bits of the channel B LFO current value to be bit-wise XORed with the bits of the channel A LFO current value before being output on channel B. Available settings are Off, or 1 to 8, where the number refers to the number of bit of right-shift that are carried out before bit-XORing. bit-XORing can create digital noise at audio rates, but at slower modulation rates, all sorts of interesting "toothed" or other geometric patterns may emerge - but with very sharp transitions in amplitude. Try feeding it into the cut-off of a LPF (a technique shown in a Bastl video).
C XOR A if enabled causes the 16 bits of the channel C LFO current value to be bit-wise XORed with the bits of the channel A LFO current value.
D XOR A if enabled causes the 16 bits of the channel D LFO current value to be bit-wise XORed with the 16 bits of the channel A LFO current value.

Screensaver display

The screen is divided into quadrants, each showing a rolling display of the output values on each of channels A to D.

Tips

Try mixing the some of the outputs with a DC-coupled mixer (such as the Mutable Instruments Shades or Links modules) in order to create even more complex waveforms.

Possible future enhancements

  • provide a cumulative internal channel mixing function, similar to the QUAD mode for the alternative firmware for the XAOC Batumi module. Possibly provide mappable voltage control over the mixing levels for each channel.

  • add a tap tempo facility, using the tap tempo synchronisation algorithm from the Mutable Instruments Peaks module.

  • add 1V/octave pitch tracking

Example tracks

  • XORtations - a track created live, on-the-fly, using the XOR transformation of two Quadraturia outputs, fed to two Mutable Instruments Braids modules, each with pitch quantising enabled.

Low-rents

Low-rents is a port of the Lorenz attractor modulation generator from the "Easter egg" in the Mutable Instruments Streams module, to which Rössler attractors have been added.

Two independent function generators are provided (referred to here as Generator 1 and Generator 2), with each generator calculating both the Lorenz and Rössler functions simultaneously, using the same phase accumulator, but with the rate/speed of each generator independently settable. Both the Lorenz and the Rössler functions output three values (x, y & z), and various combinations of these can be mapped to the four output channels. The chaotic strange attractors work best as slow modulation functions.

Note that the output voltage range of the O+C module is asymmetrical (about -3V to +6V) - because it was designed to process pitch CVs. Therefore the output of the Low-rents app is not centred about 0V.

IO Function
TR1 Reset phase of generator 1
TR2 Reset phase of generator 2
TR3 Rest phase of both generators
TR4 Freeze (both generators stop in their tracks and hold current value while TR4 is high)
CV1 Frequency/speed of generator 1
CV2 Rho or c parameter for generator 1
CV3 Frequency/speed of generator 2
CV4 Rho or c parameter for generator 2
A, B, C, D Mappable outputs from the two generators (see table below)

Controls

Control Function
Left encoder (turn) Increase or decrease frequency of currently selected generator (1 or 2)
Left encoder (press) Toggle currently selected generator frequency control
Right encoder (turn) Navigation mode: move up and down through the menu items. Edit mode: increase or decrease the value being edited.
Right encoder (press) Toggle between menu navigation (selection) mode and value editing mode
Right encoder (long press) App selection menu
Up button Increment frequency of currently selected generator by 32
Down button Decrement frequency of currently selected generator by 32

Settings

Setting Meaning
Freq 1 Frequency/speed of generator 1, range is 0-255
Freq 2 Frequency/speed of generator 2, range is 0-255
Rho/c 1 Rho (for Lorenz attractor) or c (for the Rössler attractor) parameters for generator 1
Rho/c 2 Rho (for Lorenz attractor) or c (for the Rössler attractor) parameters for generator 2
out A output mapping for output A. Available choices shown in the table below.
out B output mapping for output B. Available choices shown in the table below.
out C output mapping for output C. Available choices shown in the table below.
out D output mapping for output D. Available choices shown in the table below.
Output mapping value Meaning
Lx1 Generator 1 Lorenz attractor x value
Ly1 Generator 1 Lorenz attractor y value
Lz1 Generator 1 Lorenz attractor z value
Lx2 Generator 2 Lorenz attractor x value
Ly2 Generator 2 Lorenz attractor y value
Lz2 Generator 2 Lorenz attractor z value
Rx1 Generator 1 Rössler attractor x value
Ry1 Generator 1 Rössler attractor y value
Rz1 Generator 1 Rössler attractor z value
Rx2 Generator 2 Rössler attractor x value
Ry2 Generator 2 Rössler attractor y value
Rz2 Generator 2 Rössler attractor z value
Lx1+Rx1 Sum of Generator 1 Lorenz attractor x value and Generator 1 Rössler attractor x value
Lx1+Rz1 Sum of Generator 1 Lorenz attractor x value and Generator 1 Rössler attractor z value
Lx1+Ly2 Sum of Generator 1 Lorenz attractor x value and Generator 2 Lorenz attractor y value
Lx1+Lz2 Sum of Generator 1 Lorenz attractor x value and Generator 2 Lorenz attractor z value
Lx1+Rx2 Sum of Generator 1 Lorenz attractor x value and Generator 2 Rössler attractor x value
Lx1+Rz2 Sum of Generator 1 Lorenz attractor x value and Generator 2 Rössler attractor z value
Lx1xLy1 Bit-wise XOR of Generator 1 Lorenz attractor x value and Generator 1 Lorenz attractor y value
Lx1xLx2 Bit-wise XOR of Generator 1 Lorenz attractor x value and Generator 2 Lorenz attractor x value
Lx1xRx1 Bit-wise XOR of Generator 1 Lorenz attractor x value and Generator 1 Rössler attractor x value
Lx1xRx2 Bit-wise XOR of Generator 1 Lorenz attractor x value and Generator 2 Rössler attractor x value

The Rho and c parameters for the Lorenz and Rössler attractors respectively determine the degree of variability in the chaotic generator system. Note that the values have been constrained so that the functions do not collapse, but some combinations of extreme settings may cause the generator functions to collapse completely. If this happens, change the Rho/c setting and send a rest pulse to the relevant trigger input to reset the function generator.

Screensaver display

The screensaver show the A and B outputs in a vectorscope (X/Y) display on the left half of the screen, and the C and D outputs as a vectorscope display on the right half of the screen.

Tips

If you have an oscilloscope capable of displaying X/Y (vectorscope) signals, try patching pairs of the x, y and z outputs from either type of generator into it to observe the classic strange attractor patterns.


Piqued

Piqued is a a port of the envelope generator function from the open-source Mutable Instruments Peaks module. Piqued provides four independently-triggerable envelopes on output channels A to D, with independently mappable voltage-control via the CV1 to CV4 inputs over envelope duration parameters for each segment of each envelope. (v1.1 or later: Voltage control over the Euclidean trigger filter parameters and the trigger delay time is also possible - see below.) Triggers for each of the four envelopes can also be mapped from any of the four trigger inputs (TR1 to TR4). Segment shape (curves) can be set for each segment of each of the four envelopes. A variety of envelope types are available, also independently settable for each envelope, including repeating (looping) envelope types. The shape of each envelope can be visualised while setting parameters. There is also a "Euclidean trigger filter" included, which turns the Piqued app into a quad-channel Euclidean polyrhythm generator, that can output envelopes, not just gate/trigger signals. See the O&C videos page for some demonstrations of Piqued.

Controls

Piqued presents quite a rich UI (user interface), which is harder to describe in words than it is to use. The following explanations should make sense as soon as you see the UI in action. Once experienced, the interface becomes quite intuitive, we think.

Control Function
Left encoder (turn) In menu settings mode, elect the type of envelope. In envelope visualisation mode, select channel A to D to edit (all channels always active)
Left encoder (press) Toggle between menu settings and envelope visualisation and segment duration settings.
Right encoder (turn) Navigation mode: move up and down through the menu items (when in menu setting mode), or move back and forth between envelope segments (envelope visualisation/segment duration setting mode). Edit mode: increase or decrease the value being edited (segment durations when in envelope visualisation mode).
Right encoder (press) Toggle between menu navigation (selection)/envelope segment selection mode and value editing mode
Right encoder (long press) App selection menu
Up button Increase duration for currently selected envelope segment for currently displayed envelope generator (A to D) by 32 (when in envelope visualisation mode only)
Down button Decrease duration for currently selected envelope segment for currently displayed envelope generator (A to D) by 32 (when in envelope visualisation mode only)

Available settings (per-channel)

Setting Meaning
(envelope type) the type of envelope (segment nomenclature is standard: A=attack, D=decay, S=sustain (level) and R=release). Available envelope types are described in the table below.
Trigger input specifies which trigger/gate input, TR1 to TR4, is used to trigger or gate the envelope on the channel currently displayed.
Tr delay mode sets the mode for the trigger delay. If enabled, the trigger delay will postpone the "firing" of the envelope (that is, the commencement of the attack segment of the envelope) for the time set by Tr delay msecs and Tr delay secs (see below). Available trigger delay modes are Off, Queue and Ring. Queue means that subsequent triggers received while a delay period is active are added to a queue for later action, up to a maximum queue depth set by the Tr delay count setting (maximum 32). Further triggers during the delay period are ignored until the number of queued triggers falls below the value set by Tr delay count. Ring is similar except that triggers received after the queue is full will replace the final trigger in the queue.
Tr delay count sets the number of trigger delays that will be stored or buffered for later processing.
Tr delay msecs trigger delay in milliseconds (range 0 to 999 milliseconds). If you set a trigger delay of greater than zero, then the envelope for that channel will not "fire" (commence its attack segment) until the specified delay has elapsed. The delay in milliseconds and the delay in seconds are added together, allowing very fine control over the delay. The "countdown" time for the delayed trigger is shown as a fall bar on the righthand side of the trigger indicator for that channel (at the top of the display).
Tr delay secs trigger delay in seconds (range 0 to 64 seconds) - see Tr delay msecs above`.
Eucl length sets the length of the Euclidean pattern (range 2 to 32 in "beats", where each beat is a received trigger/gate pulse) used to filter triggers for that channel. For a detailed explanation of Euclidean patterns and their use in rhythm generation, see this paper by Godfried Toussaint, or for a brief explanation, see [this presentation}(http://www.maths.usyd.edu.au/u/joachimw/talk2.pdf). Eucl length defaults to Off, which means there is no filtering of triggers.
Eucl fill sets the number of beats in the pattern that let triggers through to "fire" the envelope. If the fill number is equal to or greater than the Euclidean pattern length number, then every incoming trigger will pass the Euclidean filter and fire the envelope for that channel. If the fill number is zero, then none shall pass.
Eucl offset sets the offset (or more accurately, the rotation) of the Euclidean pattern. The combination of pattern length (Eucl length) and number of active beats (Eucl fill) within that pattern length uniquely determines the Euclidean pattern, using the Bjorklund algorithm. For example, if Eucl length is set to 8 and Eucl fill is set to 5, and Eucla offset is set to the default of 0, then the pattern will be 10110110, where 1 is an active beat (triggers are allowed to pass) and 0 is inactive (triggers are blocked). By setting Eucl offset to 1, the pattern becomes 01101101, if set to 2 the pattern becomes 11011010 and so on.
CV1 -> sets the mapping from the CV1 input. The value on CV1 can be ignored (None) or sent to control the duration of one of: Att(ack), Dec(ay), Sus(tain) (level, not duration) and Rel(ease), or (in v1.1 or later) it can be set to control the Euclidean trigger filter parameters: Eleng (Euclidean pattern length), Efill (Euclidean pattern fill, Eoffs (Euclidean pattern offset/rotation), or the trigger delay time (Delay). Note that when set to Eleng or Efill, negative voltages can be used to block all triggers. The input CV values are added to whatever is set for the duration/level or Euclidean parameters or trigger delay time via the menu settings.
CV2 -> same as CV1 ->, but for the CV2 input
CV3 -> same as CV1 ->, but for the CV3 input
CV4 -> same as CV1 ->, but for the CV4 input
Hard reset If set to on, the envelope will instantly restart at zero on the next received trigger/gate, rather than starting from the amplitude that it is at at the time that the trigger/gate signal is received.
Gate high when set to Yes, forces the trigger/gate to high. This is useful when using the looping envelope types, which then just loop continuously, regardless of what is happen on their trigger/gate input, and thus they act as LFOs.
Attack shape sets the shape of the attack segment for the currently displayed envelope. Available shapes are listed in the table below.
Decay shape sets the shape of the decay segment for the currently displayed envelope. Available shapes are listed in the table below.
Release shape sets the shape of the release segment for the currently displayed envelope. Available shapes are listed in the table below.
Envelope type Description
AD Attack-Decay: the attack segment commences on receipt of a trigger or on the rising edge of a gate signal, and the decay segment follows immediately after the attack segment has reached its peak, regardless of whether the gate or trigger signal is still high.
ADSR Attack-Decay-Sustain-Release: just like every other ADSR envelope
ADR Attack-Decay-Release: the attack segment commences on receipt of a trigger or on the rising edge of a gate signal, and the decay segment follows immediately after the attack segment has reached its peak. The sustain level is an inflection point for the decay - when the decay reaches the sustain level, the release segment immediately commences, regardless of whether the gate or trigger signal is still high. See the Tips section below on how to use the ADR mode as an AHR/AHD (attack-hold-release or attack-hold-decay) envelope generator with trigger signals.
ASR Attack-Sustain-Release: the attack segment commences on receipt of a trigger or on the rising edge of a gate signal, and the envelope stays at maximum level for as long as the gate input for it remains high (sustain), and then commences the release segment as soon as the gate signal goes low.
ADSAR is like an ADSR envelope, except that the attack segment re-triggers as soon as the sustain segment is finished, before proceeding to the release segment.
ADAR is like the ADR envelope, except that the attack segment re-triggers as soon as the decay segment has finished, before going into the release segment.
AD loop is like the AD envelope, except that it automatically re-triggers for as long as the trigger/gate input for it is high (see also the Gate high setting)
ADR loop is like the ADR envelope, except that it automatically re-triggers for as long as the trigger/gate input for it is high (see also the Gate high setting)
ADAR loop is like the ADAR envelope, except that it automatically re-triggers for as long as the trigger/gate input for it is high (see also the Gate high setting)
Segment shape Description
Lin Linear (a straight line, equation x = t where t is time)
Exp Exponential (equation x = 1 - e-4_t_)
Quart Quartic (equation x = t3.32)
Sine half a sine wave (equation x = sin(8 * pi * t) )
Ledge almost a square wave, but with rounded corners, when used for attack, gives an immediate (punchy) rise, then a plateau. When used for decay or release, it has a plateau before falling.
Cliff similar to Ledge, but when used for attack, has a delay before rising, when used for decay or release, it falls immediately.
Gate (v1.1) is used when gate outputs are desired. The value rises immediately to maximum in the attack segment, and the value falls immediately to minimum in the decay and release segments. In other words, a pulse is output.
BgDip Big dipper - has one large bump on the way up or down.
MeDip Medium dipper - has a medium sized dip on the way up or down.
LtDip Little dipper - has a little dip (more a ledge) on the way up or down.
Wiggl Wiggles - lots of wiggles on the way up or down.

Inputs and outputs

Trigger input and CV1 to CV4 are mappable per-channel via the menu, as described above. Outputs for envelopes A to D appear on outputs A to D respectively.

Screensaver display

The screen is divided into quadrants, each showing a rolling display of the output values on each of channels A to D. Superimposed on this rolling value line is a representation of the envelope for that channel, as it progresses through its segments.

Tips and tricks

  • the ADR mode can also be used as an AHR (attack-hold-release, sometimes also called AHD (attack-hold-decay)) envelope generator. AHR envelope are useful when you want to generate an envelope with a flat sustain period, which usually requires a gate input with some duration. If you only have trigger signals, that is, short pulses, then you can create an AHR envelope by choosing ADR mode, and setting the sustain inflection point to 255 (maximum). By doing that, the decay segment falls from maximum value to... maximum value - in other words, it's flat! The decay segment time/duration then sets the hold duration after a trigger is received. Also try setting the sustain level in ADR mode to something a little bit less than 255 (say 230), and set the decay shape to Wiggle. Now you have an AHR envelope with a wiggly and slightly downsloping plateau segment. Several variations on this theme are possible.

Possible future enhancements

  • add a configurable delay (between receipt of trigger and start of attack segment of envelope) for each channel, possibly externally CVable (done, but not currently under external CV control) (done in v1.1)

  • add the ability to have the trigger delay take random values (with a settable range), so that there is varying "swing" - both uniform probability distribution within a range, and a Gaussian distribution of delay times around a mean.

  • add more envelope types with more segments (the Peaks envelope model is quite general and allows for an arbitrary number of segments per envelope).

  • add more envelope segment shapes, including a flat envelope with gradually increasing wiggles, for tremolo or vibrato. May need a DC offset setting as well so it could be centred around zero - that would be useful for other envelopes too, perhaps.

  • voltage-controlled envelope segment shape, perhaps? A bit clumsy, but might be interesting, and quite feasible. No change to UI needed, just a few more choices on the CV input mapping menu items.

  • add some of the features from the ADDAC505 Mille Plateaux module, in particular: sustain time (i.e. internally generated gate duration - what a great idea!), and non-zero start and end amplitudes for each segment (also a great idea).

  • add some trigger processors, such as a Euclidean pattern generator, so that a regular clock/trigger input signal can be "filtered" into a rhythmic pattern of generated envelopes. - done!

  • add "anti-Euclidean" (i.e. Golomb ruler) and "divided" Euclidean patterns as shown in this video about the Shakmat Knight's Gallop module.


Dialectic Ping Pong

Dialectic Ping Pong is a port of the bouncing ball envelope generators from the Mutable Instruments Peaks module source code (these are not exposed in the official Peaks firmware, but are available on Peaks with the Dead Man's Catch alternative firmware installed). These generators implement a simple but effective simulation of the physics of a ball that is thrown into the air with a certain velocity, from a certain height, and which then returns to Earth (or a planet of your choice) under the influence of (configurable) gravity, and then bounces (with a settable "bounce loss" simulating how hard the ball is pumped up, if it is a basketball), before being pulled back to Earth and bouncing again, and so on.

Controls

Control Function
Left encoder (turn) Select channel A to D to edit (all channels always active)
Right encoder (turn) Navigation mode: move up and down through the menu items. Edit mode: increase or decrease the value being edited.
Right encoder (press) Toggle between menu navigation (selection) mode and value editing mode
Right encoder (long press) App selection menu
Up button Increase gravity by 32
Down button Decrease gravity by 32

Available settings (per-channel)

Setting Meaning
Gravity g, the acceleration due to gravity, from 0 (no gravity) to 255 (gravity on a massive alien planet)
Bounce loss The amount of energy lost by the ball at each bounce (0 to 255). Higher values act like a deflated basketball.
Amplitude Initial amplitude (height) of the ball when the envelope is triggered, 0 to 255.
Velocity Initial velocity of the ball when the envelope is triggered - the size of the kick or impulse imparted to the ball, if you like. Note that high values will cause the ball to bounce off the roof of the gymnasium that houses these envelopes.
Trigger input Trigger input source (TR1 to TR4) for the current channel
CV1 -> Mapping of the CV1 input to a parameter for the selected channel. Values are "off", "grav" (gravity), "bnce" (bounce loss), "ampl" (initial amplitude), and "vel" (initial velocity).
CV2 -> As for CV1->, but for CV2.
CV3 -> As for CV1->, but for CV3.
CV4 -> As for CV1->, but for CV4.
Hard reset If set to on, the envelope will instantly restart at the currently set initial amplitude, rather than starting from the height that the ball happens to be at the time when the trigger is received.

Inputs and outputs

Trigger input and CV1 to CV4 are mappable per-channel via the menu. Outputs for channels A to D appear on outputs A to D respectively.

Screensaver display

The screen is divided into quadrants, each showing a rolling display of the output values on each of channels A to D.


Viznutcracker, sweet!

This is a experimental implementation of several byte beats signal generators. "Byte beats" are equations, expressed usually as a single line of programme code, typically involving various bit-level operators, which when evaluated with an incrementing phase value at audio rates produce all manner of harsh digital noises, some of which sound musical, or at least, interesting. "Byte beats" were first described in 2011 by viznut (aka Ville-Matias Heikkilä).

The output, if used as an audio signal, usually needs to be fairly heavily filtered through a low-pass filter to remove at least some of the unpleasant digital "screech" due to high-frequency aliasing and other effects which are characteristics of byte beats. This digital aliasing is a fundamental characteristic of the way byte beats work, and isn't due to any hardware limitations of the O+C module.

The Viznutcracker, sweet! app current provides access to 8 different byte beat equations, although it is anticipated that more will be added in further versions. The app provides four independent byte beat generators, on channels A to D, which all run independently. The equation, speed/frequency and three equation parameter values (p0, p1 and p2) can be set via the menus and/or voltage-controlled for each generator via mappable CV inputs.

Perhaps uniquely amongst byte beat generator modules, the Viznutcracker, sweet! apps permits the byte beat generators to be run at very slow rates, and because the O+C module outputs are DC-coupled, they can therefore be used as sources of stepped control voltages. For example, the outputs can be fed into a quantiser (such as another O+C module) to create potentially interesting pitch sequences (possibly even melodies...). Furthermore, the app allows each byte beat equation to be incremented by an external clock/trigger input, so that these stepped voltages can be generated in synchrony with other external processes.

Available settings (per-channel)

Setting Meaning
Equation Byte beat equation (see table below)
Speed 0 to 255. 255 equates to a 16.6 kHz sample rate (i.e. the phase accumulator advances 16,666 times per second). There is a rough quadratic scaling of lower rates, meaning that 0 is quite slow.
Parameter 0 The first adjustable parameter in the chosen equation. Range 0 to 255, but some parameter settings in some equations do not produce any output, or do not produce output for all values of the phase accumulator (be patient!)
Parameter 1 ditto for the second adjustable parameter in the equation
Parameter 2 ditto for the third adjustable parameter in the equation
Loop mode Enables loop mode, in which the phase accumulator is constrained to loop between specific start and end values, instead of between 0 and 4,294,967,296.
Loop begin ++ Coarse loop begin point, range 0-255
Loop begin + Medium loop begin point, range 0-255
Loop begin Fine loop begin point, range 0 - 255
Loop end ++ Coarse loop end point, range 0-255
Loop end + Medium loop end point, range 0-255
Loop end Fine loop end point, range 0 - 255
Trigger input Specified which of the 4 trigger inputs (TR1 to TR4) is used for the trigger input for Step mode, or when Step Mode is off, which trigger input is used to reset the phase accumulator for that channel.
Step mode When set to on, the phase accumulator is incremented when a trigger or clock pulse is received on the digital (trigger) input specified by the Trigger input setting. When set to off, a trigger (or rising edge of a pulse or clock) received on the trigger input specified by the Trigger Input setting will reset the phase accumulator (the t variable in byte beat equations), which has the effect of resetting the byte beats "tune" or "melody" back to its beginning, or back to the start of the loop start point if loop mode is enabled.
CV1 -> specifies which parameter CV1 is mapped to for this channel. Choices are off, eqn, spd, p0, p1, p2, beg++, beg, end++, end.
CV2 -> ditto for CV2
CV3 -> ditto for CV3
CV4 -> ditto for CV4
Equation name Source of equation
hope "atmospheric, hopeful" from http://royal-paw.com/2012/01/bytebeats-in-c-and-python-generative-symphonies-from-extremely-small-programs/
love the equation by stephth via https://www.youtube.com/watch?v=tCRPUv8V22o at 3:38
life the second equation listed at from http://xifeng.weebly.com/bytebeats.html
age "Arp rotator" via Microbe Modular Equation Composer Ptah bank
clysm "BitWiz Transplant" via Microbe Modular Equation Composer Ptah bank
monk "Vocaliser" via Microbe Modular Equation Composer Khepri bank
NERV "Chewie" via Microbe Modular Equation Composer Khepri bank
Trurl "Tinbot" via Microbe Modular Equation Composer Sobek bank
Pirx "My Loud Friend" via Microbe Modular Equation Composer Ptah bank
Snaut ""A bit high-frequency, but keeper anyhow" via Microbe Modular Equation Composer Khepri bank
Hari "The Signs" via Microbe Modular Equation Composer Ptah bank
Kris "Light Reactor" via Microbe Modular Equation Composer Ptah bank
Tichy "Alpha" via Microbe Modular Equation Composer Khepri bank
Bregg "Hooks" via Microbe Modular Equation Composer Khepri bank
Avon "Widerange" via Microbe Modular Equation Composer Khepri bank
Orac "Abducted" via Microbe Modular Equation Composer Ptah bank

Screensaver display

My God, it's full of stars!

Tips

  • as noted above, use the byte beat generators at very slow rates to generate DC control voltages. Feed these to a quantiser to produced pitch sequences, or pass them through a portamento or slew-limiting module to create interesting smooth modulation signals, or use them as-is, to modulate filters etc.

  • process the byte beats outputs running at audio rates through a low-pass or shelf filter to remove some of the high-pitched screech

  • process the output through band-pass filters (such as the Mutable Instruments Shelves filter), or other complex filtering arrangements subject to slow modulation (by another O+C module, perhaps)

  • process the output through a VCA and/or filter with a percussive envelope to produce interesting, well, percussive sounds. Use the same trigger or gate signal used to fire the envelopes also reset the phase on the byte beat generator. Use slow modulation to slowly vary the frequency/rate, and/or to "scrub" loop start and end points in order to vary the nature of the percussive sound.

Possible future enhancements

  • add more byte beat equations (16 more added in v1.1!)
  • investigate whether smoothing of the byte beat value stream is useful when they are used a modulation sources
  • investigate whether digital filtering of the byte beat audio stream is feasible, or useful

Examples

  • Viznutcracker, sweet! - a track created using the Viznutcracker, sweet! app as the only sound source, except for a bass drum from a Mutable Instruments Peaks module.

References

References is a simple utility app which outputs fixed reference voltages. These are handy when calibrating other modules, such as VCOs.

Note that unlike all the other apps, the settings for references are not saved and will revert tot he defaults eat time the module is powered on. This is to save EEPROM storage space - saved settings were not regarded as critical for this app.

Controls

Control Function
Left encoder (turn) Select channel A to D to edit (all channels always active)
Right encoder (turn) Navigation mode: move up and down through the menu items. Edit mode: increase or decrease the value being edited.
Right encoder (press) Toggle between menu navigation (selection) mode and value editing mode
Right encoder (long press) App selection menu
Up button
Down button

Available settings (per-channel)

Setting Meaning
Octave sets the octave range. Note that the octave numbering is such that C for octave 0 is 0V, C for octave 1 is 1V and so on.
Semitone sets the semitone offset wishing each octave range. One semitone increment is 0.08333333333V (83.333333mV).
Mod range oct sets the number of octaves to automatically jump up or down. This can be useful when adjusting trimpots on VCOs.
Mod rate (s) sets the rate (as a period in seconds) at which the reference voltage jumps up or down by the number of octaves set by Mod range oct.

Inputs and outputs

No inputs are used. Reference voltages for channels A to D appear on outputs A to D respectively.

Screensaver display

The screen is divided into four channel lanes (columns), with the same layout as the Quantermain screensaver, except that the output voltage (rounded to the nearest millivolt) is shown as the top of each lane (column). Note that the minus signs for negative voltages are quite small due to the limited display space, and can be quite hard to see.

Possible future enhancements

  • lots of things! The current References app is really just a placeholder. Some possibilities:
    • simple approximate quad channel voltmeter which measures and displays voltage on each of the CV inputs (to nearest 0.01V (nearest 10 mV).
    • quad channel BPM (beats per minute) meter using the trigger inputs
    • quad channel frequency meter, using the CV inputs.

CHANGELOG

Changes between v1.0 and v1.1

  • removal of some redundant code and unused libraries

  • changes to the encoder direction setting when in calibration mode to accomodate the swap in GPIO pin assignment for the right encoder introduced in version 2c and later of the O&C PCBs - see setting encoder directions on the calibration wiki page.

  • Quantermain

    • mappable input CV sources to control the built-in LFSR (Turing Machine) probability and range parameters have been added - yes, voltage-controlled Turing Machines!
    • mappable CV input sources to control the built-in Logistic Map R and range parameters have been added, so now the Logistic Map can also be voltage-controlled.
    • byte beat equations have been added as a third internal source for the quantiser, with a range of parameters that can be voltage controlled. Thus, rather than creating audio output using byte beats (which is still possible using the Viznutcracker, sweet! app), uniquely, the Quantermain app can create four independent channels of quantised pitch voltage streams driven by clocked byte beat equations. We believe this is a completely novel application of byte beat equations, and one which produces surprisingly musically interesting results (here is an example).
  • Quadraturia

    • a frequency range parameter for the quadrature LFOs has been added, with self-explanatory settings of "vslow", "slow", "med", "fast" and "vfast". The faster settings extend into audio range. Note that Quadraturia does not, and is not intended to, track 1V/octave.
    • output amplitude parameters for each channel have been removed (they weren't much use, it could be done in an external mixer anyway, and they wasted precious settings storage space).
  • Piqued

    • voltage control over the Euclidean trigger filter parameters and the trigger delay time is now possible. Input CVs can be mapped to control the Euclidean trigger filter parameters: Eleng (Euclidean pattern length), Efill (Euclidean pattern fill, Eoffs (Euclidean pattern offset/rotation), or the trigger delay time (Delay).
    • added an new envelope type: Gate. This can be used when gate outputs are desired. The value rises immediately to maximum in the attack segment, and the value falls immediately to minimum in the decay and release segments. In other words, a gate pulse is output.
  • Viznutcracker, sweet!

    • eight new byte beat equations have been added, bringing the total to 16. These new equations are also available as sources in the Quantermain quantiser app (see above).

Credits, thanks, acknowledgements, and sources of inspiration

Credits (who did what)

We welcome contributions from others (ideally via pull requests on GitHub) to the Ornaments & Crimes firmware, and we will acknowledge any such contributions in detail. To make such detailed acknowledgements easier, we have documented here the contributions of the original developers of O+C and the Ornaments & Crimes firmware. If you make a contribution which is included the firmware, we'll add your name!

Hardware

  • Max Stadler (aka mxmxmx):
    • all hardware and circuit design
    • PCB layout
    • hardware debugging
    • build and calibration instructions and procedures

Firmware

  • Max Stadler:

    • overall firmware framework and hardware interfacing abstractions
    • original menu system design (still used) and calibration procedures
    • original ASR and quantiser code, which became the CopierMaschine app
    • lots of testing, debugging, and tweaking of code
  • Patrick Dowling (aka pld)

    • design and implementation of loadable "apps" framework
    • conversion to interrupt and event-driven operation
    • writing of super-fast double-buffered DMA custom OLED display driver
    • design and implementation of the scale editor used in the CopierMaschine and Quantermain apps, and the porting of the Mutable Instruments Braids note quantiser code
    • creation of an enhanced menu framework
    • porting of original ASR code by Max Stadler to the CopierMaschine app
    • the debugging displays
    • design and implementation of the Harrington 1200 app, including the neo-Riemannian tonnetz transformation classes
    • design and implementation of the Automatonnetz vector sequencer app
    • design and implementation of the Quantermain quad quantiser app, based on the CopierMaschine app, and including implementation of Turing machine internal source for it
    • design and implementation of the Quadraturia app, including porting the Mutable Instruments Frames Easter egg quadrature LFO code, and design and implementation of the waveform preview display
    • design and implementation of the Piqued app, including porting of the Mutable Instruments Peaks envelope generator code and creation of the very nifty envelope visualisation display
    • lots of the end user and system documentation
    • lots of tweaks and improvements to the ham-fisted code written by Tim Churches
    • lots of testing, debugging, and tweaking of other code
  • Tim Churches (aka bennelong.bicyclist):

    • design and implementation of the Low-rents app, including porting of the Mutable Instruments Stream Easter egg Lorenz attractor code, and addition of Rössler attractor
    • design and implementation of the Dialectic Ping Pong app, including porting of the bouncing ball physics simulation from the Mutable Instruments Peaks source code
    • design and implementation of the Viznutcracker, sweet! byte beats app, including the curation and porting of byte beats equations from various sources (see app documentation above for acknowledgement of those sources).
    • suggesting the Harrington 1200 app and naming it, and design of the "circle of fifths" chord display using in its screensaver (and in the Automatonnetz screensaver)
    • suggesting that the fcd72 vector sequencer might be used, somehow or other
    • addition of May-Verhulst logistic maps as an internal source for the Quantermain app
    • naming of the Quadraturia app, and addition of frequency division and XOR capabilities to it
    • addition of trigger delays and Euclidean pattern filters to Piqued
    • addition of settable and additional segment shapes to the Piqued app
    • quite a lot of this documentation
    • lots of testing, debugging, and tweaking of code

Thanks

  • Enormous thanks to Olivier Gillet of Mutable Instruments for all of the wonderful open-source module code which we have ported to and re-used in O+C
  • Paul Stoffregen for creating the open-source Teensy platform and associated firmware libraries used by the O+C module
  • Bret Truchan for permission to use byte beats equations which he collected, devised and curated for the excellent Microbe Modular Equation Composer module, which is highly recommended for anyone interested in byte beats
  • Stephen from Noise Engineering for helpful notes and info about the neo-Riemannian transformation implementation in his Tonnetz Sequent module, which is highly recommended for anyone interested in tonnetz harmonies.

Acknowledgements and sources of inspiration


Known Issues and Things to be checked or improved

  • the 16.6 kHz DAC update rate means that audible digital aliasing is present when the output is used as an audio source - which is why the only app intended as an audio source is Viznutcracker, sweet!, which, as a byte beat generator, depends on lots of horrible digital aliasing and related digital artefacts to create its distinct sound. That said, several of the other apps can produce signals in the audio range, but you may need to use them with a low-pass filter to remove some of the aliasing noise (if you wish - some people like the inharmonic "sizzle" of digital aliasing). Anyway, just be aware that O+C is intended to be used as a pitch CV generator, and as a slow modulation CV source, not as audio oscillator or audio signal generator. In theory, some of the digital aliasing may "bleed through" into the audio domain even when the O+C is used as a modulation CV source (eg as an envelope generator or LFO modulating a VCF cut-off or VCA gain). We have not found that to be a problem in practice, but if it does become apparent, then you can always interpose a low-pass filter between the O+C and whatever is being modulated. WMD make a module exactly for this purpose: the Quad Anti-aliasing Filter (QAAF). However, this is unlikely to be required. Note that for its original designed purpose, as a module that deals with or generates pitch CVs, the 16.6 KHz DAC update rate is not a problem.
  • when used as an LFO (that is, the Quadrature app), the waveform is not symmetrically bipolar, because the output range of the module is -3V to +6V. This can be corrected by adding -1.5V to each output, so that the output range is shifted from -3V to 6V, to -4.5V to +4.5V. The Mutable Instruments Shades module is excellent for doing such level shifting (and voltage scaling), but there are many other utility modules which can do the same. The Lorenz and Rössler functions output by the Low-rents app are similarly asymmetrical - they also range from -3V to + +6V, due to the hardware design of O+C.
  • note names and input/output voltage may not match in Harrington 1200/Automatonnetz modes => fixed!
  • root quantization and output not verified yet => verified!
  • No chromatic scale in quantizer mode (see roadmap)
  • More flexible quantiser implementation in 4x mode
  • SCALA-style scale definitions => using Braids' quantizer
  • Check hysteresis/ADC jitter since I've been able to find settings where it's "stuck" between two steps in cont mode => internally ADC sampling/smoothing improved, seems good enough
  • bit-mask or other way to choose which notes in scale are active
  • (meaningful) linking of channels and/or offsets? => Source CV is selectable, original source is used as transpose
  • extend tonnetz to support other chord modes (augmented, diminished) and maybe more transforms?
  • CV control of dx/dy and other parameters in Automatonnetz
  • a note grid sequencer app
  • a quad free-running LFO app, possibly implementing some of the features of the Modcan Quad LFO module.
  • port some of the clock and gate/trigger logic capabilities of the temps utile module to O+C. The functionality of the Bastl Little Nerd module could also be replicated, although with only 4 outputs, but 4 independent clock inputs, instead of just 2. The Malekko Varigate is also worthy of study.
  • (per loopt on MW): "For the piqued app you could implement an additional 281-mode with two AD envelopes and two of the CV outputs spitting out gates (EOR of AD1 and EOD of AD2)...Any plans of implementing more env stages with loops? Or some gate logic for conditional looping, as in Gate 1 AND Gate 3 are high -> loop Env2."
  • The ideas behind XronoMorph might make for an interesting generative rhythm/melody sequencer? See http://www.synthtopia.com/content/2016/04/27/free-app-for-os-x-windows-xronomorph-lets-you-explore-new-theory-of-rhythm/

You can’t perform that action at this time.
You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.
Press h to open a hovercard with more details.