l a u t e r Z E I T
The Taxonomy of Arpeggiator Sync

Plus MIDI-syncable LFOs and pattern/groove sequencer sync!
Recommended classification and design practice.

MC-909

 

To make comments, corrections, constructive criticism and/or suggestions please do so on this forum thread.

 

Introduction

When a musical instrument manufacturer describes its product's ability to synchronize arps and LFOs to external MIDI clock, it really is almost useless information without further knowledge of the underlying triggering mechanics. Does it sync to external beat clock? Does it latch into the Master's groove or pattern cycles? Does an initial key press reset its own beat clock? This document hopes to give both keyboardists and synth makers a common language for describing synchronization methods.

 

Background

Since the creation of the MIDI (Musical Instrument Digital Interface) standard in 1983, musicians and producers have reaped the benefits of this incredible protocol for connecting electronic devices in a multitude of ways. Of particular interest here is the real-time clocking of MIDI devices for synchronizing slaved synthesizer arpeggiators. This discussion also bears heavily upon the sync behavior of sequencers (linear & pattern) and LFOs (Low Frequency Oscillators).

Despite many instruments claiming and ability to sync to MIDI clock, their timing behavior may or may not serve the musicians actual expectations. Reading through many user forum, one frequently finds frustrated keyboardist posting the likes of "bad arp timing" or "arp won't sync to external clock." This document aims to identify different sync behavior of arps/LFOs so that users and equipment designers can clearly communicate their true timing/triggering capabilities.

Most pre-MIDI synthesizers have an external clock/gate input signal, whereby one pulse triggers the next note of an arpeggiator pattern (or LFO re-triggering). Very predictable behavior. With MIDI clock, the world has been blessed and cursed with infinite sync possibilities...

 

Keyboardists' Frustration

Often a synth's arpeggiator design implentation is contrarty to users' expectations. Please look at a couple examples of rightfully frustrated keyboardists on this Virus Access forum:

These synth users are expecting (respectively) Beat Sync and Key Sync behavior. But instead they are finding an independent, free-running beat clock, albeit tempo accurate. The maddening behavior is also found in the Waldorf Blofeld (V1.16b2) arpeggiator while under EXT clock sync. These synths - while correctly keeping tempo as Slave - are nonetheless ignoring the Master's MIDI Beat info. (See below for details) The connected instruments' beat clocks are randomly out of phase with each other.


Hierarchy of MIDI clock/beat/groove

A MIDI clock "tick" (or pulse) represents 1/24th of a quarter note, or 1/96th note. The common way of specifying its resolution is 24 PPQN (Pulses Per Quarter Note). A MIDI "beat" represents a 1/16th note, or SIX MIDI clock "ticks." The hierarchy going from finest resolution to coarsest is as follows:

  1. Timebase or sequencer resolution in PPQN.
         ticks = [MIDI clock ticks] * timebase_PPQN/24
  2. MIDI timing clock = 24 PPQN
  3. MIDI beat clock = 1/6 of MIDI timing clock ^
  4. Groove/pattern clock *
  5. MIDI SPP (Song Position Pointer), specified at MIDI beat clock resolution

^ Beat clock is reset with either a MIDI Real-Time START message OR the combination of System Common message SPP (Song Position Pointer) followed by Real-Time CONTINUE.

* Depending on manufacturer terminology, a pattern or groove might be several measures in length, in other cases a pattern is shorter than a measure. Regardless, time signature or pattern length must be accounted for in the sequencer's clock math.


 

Taxonomy of Arp/LFO Synchronization

When a musical instrument manufacturer describes its product's ability to synchronize arps and LFOs to external MIDI clock, it really is almost useless information without further knowledge of the underlying triggering mechanics. Does it sync to external beat clock? Does it latch into the Master's groove or pattern cycles? Does an initial key press reset the arp's internal beat clock?  The various triggering behaviors are each desirable in different situations.  Ideally, the synth offers these as user-selectable modes, at either a patch (preferable) or global level.

So how do we simply and accurately classify arpeggiator, LFO and sequencer sync and triggering behavior? Let's try this:

Desirable Modes:

  • KEY SYNC - per Korg terminology - upon first key down, the next arpeggiator note or LFO triggers, thereby resetting the Slave's internal beat clock at the next clock tick (at either MIDI or timebase resolution). Subsequent key down (while another key is pressed) will not reset beat clock. Note that even within this mode classification, there is a noticable, tacticle difference between implemntations resetting the beat clock at timebase vs MIDI clock resolution. [i.e., 96 PPQN vs. 24 PPQN.]
  • BEAT SYNC - The Slave instrument receives and processes any Master MIDI real-time messages; START, STOP, CONTINUE as well system common message SPP, thereby adjusting its internal beat clock accordingly. Upon key down, the slave arpeggiator / LFO will not trigger until the next BEAT Clock. [aka BEAT QUANTIZE]
  • PATTERN or GROOVE SYNC - The slave instrument sets its arp/pattern/LFO mid-phase such that the arp/LFO locks in to the Masters pattern/groove cycles. So if an arp has rests or glides at specific parts of the pattern, those rhythmic elements will always concur with the groove's.
  • PATTERN LATCH - Arp or sequencer waits until the beginning of the next pattern cycle (or measure) to trigger notes. Once the "latch" occurs, the device is subsequently in GROOVE SYNC.

Buggy / Undesirable Modes:

  • BEAT ASYNC [TEMPO MATCH ONLY] - This is an extremely undesirable implementation, found in Waldorf Blofeld arp. BAD! Notes get triggered only on Slave's asynchronous beat clock. The Slave instrument only receives MIDI clock and disregards Master's START, STOP, CONTINUE and SPP messages. The result is a random beat phase relationship between Master and Slave. In other words, the synth is not resetting its beat clock to the first key after a "hands off" condition. It manifests as a sloppy, arrhythmic effect.
  • DOUBLE TRIGGERING - Some users have reported cases where an arp attempt processing two notes at once on the same clock tick.

 

Examples by instrument:

  • Roland MC-909 - Capable of BEAT SYNC, GROOVE SYNC or PATTERN LATCH
  • Roland Jupiter-6 (Eurpoa MIDI v2 firmware, forthcoming) - GROOVE SYNC
  • Korg Radias (and most Korgs) - Capable of KEY SYNC or BEAT SYNC
  • Korg Volca Keys/Bass/Beats - Capable of GROOVE SYNC (via MIDI) or BEAT SYNC (via TTL clock)
  • DSI Tempest (sequencer) - Capable of GROOVE SYNC
  • DSI Tempest (LFOs) - Capable of KEY SYNC and BEAT SYNC
  • DSI Prophet 12 (Arp & LFOs) - Capable of KEY SYNC
  • Mutable Instruments MIDIpal : arpeggio - Capable of KEY SYNC (clk=INT) and GROOVE/BEAT SYNC* (clk=EXT) [*proper SPP implementation with LauterZeit firmware]
  • Mutable Instruments MIDIpal : syncltch - Capable of PATTERN LATCH*
    [*Note: proper SPP implementation with LauterZeit firmware]
  • Waldorf Blofeld - BEAT ASYNC - Terrible! - No way for the Master to reset the Slave's beat clock. Random, inconsistent behavior. Although the Blofeld user manual describes different "Pattern Reset" modes, neither works correctly.

 

Why MIDI Song Position Pointer (SPP) matters

There are two ways for a Master device to instruct the Slave to reset its Beat clock - START and SPP (Song Position Pointer). This is required for BEAT SYNC, GROOVE SYNC and PATTERN LATCH modes.

[Note that the only mode which is exempt from processing START and SPP+CONT messages is KEY SYNC, becasue in this isolated case, the keybaordist is controlling the Beat phase. However, in all cases the Slave must maintain an internal timebase clock which is synced to the Master clock.]

There are many situations (both in a studio and live) where a master sequencer might require a start cue (or restart) at some arbitrary beat within a song or pattern. Without processing Song Position Pointer the arpeggiator/LFO has no way of knowing which MIDI Clock ticks relate to the MIDI Beat or Measure/Pattern/Groove triggering. For example, if an arp is set to 16th note resolution – and if ignoring START, STOP, SPP, CONT messages – then it probabilistically has only a one-in-six (16%) chance of syncing correctly. At 8th note resolution, the odds are worse; only one-in-twelve (8%) chance of guessing right. The Waldorf Blofeld (V1.16b2) is notorious for exhibiting this kind of inconsistent arp timing. [A real shame too, because it is an amazing sounding synth.]

One of the common misconception of SPP is that it is continuously transmitted, like MTC (MIDI Time Code.) This is not so. The only time a device should transmit an SPP message is while it's sequencer is stopped. So it should only occur between STOP and CONTINUE messages.

Many musicians, composers, producers and engineers still heavily rely on correct MIDI Song Position Pointer for linear composition/performance.

List of SPP compliant devices:

  • All Roland MIDI sequencers, drum machines and workstations (except MSQ-700)
  • All Yamaha MIDI sequencers, drums machines and workstations
  • All Ensoniq sequencers and workstations
  • All Elektron drum machines and sequencers
  • Most Akai MPCs
  • Akai DD8plus / DR16pro / DR8 (requires MIDI card installed)
  • Korg Volca series (Beats, Bass and - yes -Keys!)
  • Most 1990s and newer Korg keyboards
  • All Korg MIDI sequencers and workstations
  • GliGli Prophet 600 fast firmware hack
  • Roland MKS-70 / JX-10 firmware update by Frédéric Vecoven
  • Roland JP-6 Europa v2 firmware
  • Roland VS series studio recorders
  • Kenton Pro Solo MkII (only partial SPP implementation)
  • Most Alesis drum machines and sequencers
  • Avid ProTools
  • Ableton Live (transmit only, no receive)
  • Apple Logic
  • DSI Tempest
  • Mutable Instruments MIDIpal (in the LauterZeit firmware)
  • Doepfer Dark Time sequencer (SPP forthcoming in firmware V1.3)
  • JLCooper PPS-2 and PPS-1 v3 synchronizers

 

Recommended Practice for Instrument Designers

Slave arps, sequencers and/or LFOs should have the following implementation for maintaining modes KEY SYNC, BEAT SYNC and GROOVE SYNC.

For KEY SYNC:

if (new_key_down && no_previous_keys_down)
{
    beat_clock_ticks = 0;
}

Note for the following pseudocode lines that a MIDI START message sets SPP = 0;

For BEAT SYNC:

if (SPP updated)
{
  seq_clock_ticks = ((SPP * 6) + [# of MIDI CLKs
     following CONT message]) * (timebase_PPQN / 24);
  beat_clock_ticks = seq_clock_ticks % beat_PPQN;
}

// elsewhere in code...
if (!(++seq_clock_ticks % beat_PPQN))
  ++beat_clock_ticks;

For PATTERN or GROOVE SYNC:   [use modulo arithmetic]

if (SPP updated)
{
  seq_clock_ticks = ((SPP % (([# bars in pattern]
     * 16 * time_sig_numerator)/time_sig_denominator))
     * 6 + [# of MIDI CLKs following CONT message])
     * (timebase_PPQN / 24);
  beat_clock_ticks = seq_clock_ticks % beat_PPQN;
}

The underlying assumption here with GROOVE SYNC is that when the Slave device is in Pattern/Loop mode, it responds to SPP as if it were playing a song composed of only the current pattern looped forever.  Linear/Song mode, of course, requires additional calcualtions, accounting for varying length patterns chained in sequence.

Dealing with MIDI clock latency would be a nice feature for many synths implenting BEAT SYNC or GROOVE SYNC.  With these modes, sync-shift or sync phase (-/+) should be either a global parameter (for system compensation) and/or a patch parameter whereby the user can offset the arp trigger timing early or later to the MIDI beat clock. The latter is useful for timbres with attack times so that the peak amplitude coincides with the beat. Such an offset value would be at a higher resolution than MIDI clock, i.e. internal timebase (PPQN), or better, microseconds or percent (%) attack time.

In KEY SYNC mode, however, such latency compensation is NOT needed since the keyboardist is instinctively, manualy performing the timing adjustment.


Variations on Master Clock transmission

Some gear, while as Master, will continuously transmit MIDI CLK, even when it’s in STOP mode. Doesn’t seem to be a bad thing, so long as the Slave device knows to ignore* any CLKs seen between SPP and CONT messages. Only CLKs after the CONT message should advance the Slave’s sequencer position beyond the SPP.

* A clarification on this point. The Slave device is only ignoring these interstitial MIDI clocks ticks with respect to positioning and beat clock calculations. However, these clock pulses should not be ignored for the purpose of maintaining a synchronized internal timebase.

Examples of devices which always transmit MIDI clock, even while STOPed:

  • Roland MSQ-700
  • Roland MSQ-100
  • DSI Tempest
  • Elektron MachineDrum

Examples of devices which ONLY transmit MIDI CLK following a START or CONT message and ceasing after STOP message:

  • Roland MC-50
  • Ensoniq EPS
  • Innerclock Systems' Synq-Lock / Sync Gen II Pro

 

Interim Solutions and Work-Arounds

If your particular synth is not behaving the way you want it, then perhaps look into other arp boxes. The Mutable Instruments' MIDIpal is a great little tool overcoming some of these beat and pattern sync issues. Use its "arpeggio," "syncltch," "divider" and "cc lfo." apps. Here is a solution to force any MIDI synth into Beat Sync arpeggiation.

Also check out Innerclock Systems' Sync-Shift mkII.

 

MIDI Clock Jitter and Latency (for further reading)

MIDI Clock Jitter/Latency is a whole other point of discussion, beyond the scope of this document. For your edification on this topic, please visit Innerclock Systems' well prepared manifesto. Also check out A.D.A.M.BABY's Sync or Swim? page and Omega Recording Studios' excellent articles MIDI Beat Clock and the Three Dimentions of Sync Part 1 - Part 2

MIDI Manufactures Association

Appendix

The relevant MIDI messages in Hex notation:

  • CLOCK: 0xF8    (System Real-Time)
  • START: 0xFA    (System Real-Time)
  • STOP:  0xFC    (System Real-Time)
  • CONT:  0xFB    (System Real-Time)
  • SPP:   0xF2 [LSB] [MSB] (System Common)

 

Written by Michael Lauter