8Heads

An eight-head stereo tape delay for the Music Thing Workshop Computer, played from a Music Thing 8mu. There's one loop of tape, recorded from both audio inputs, with eight playback heads along it, one for each 8mu fader.

Each head has its own time, volume, pan, stereo width and feedback. The feedback goes back onto the tape through a low-pass and high-pass filter and a tape model (saturation, hiss, wow, flutter and dropouts). Times glide, so moving a fader or the Main knob bends the pitch of what's already on the tape, the way a tape machine does.

It is built on the same structure as CVSeq and WaveSeq: the same 8mu paging and fader pickup, the same USB host/device split, the same style of SysEx protocol and web editor.

The 8mu

The eight faders are the eight heads. The buttons act when you let go:

Faders pick up: after a page change, a fader does nothing until you move it to (or past) the stored value, so nothing jumps. The 8mu's LEDs show the stored values on the current page.

Tilting the 8mu plays the mix. Both tilts ignore about 15° either side of flat, so just holding it changes nothing.

Rate and Bits pages (B, pressed twice and three times)

These downsample each head separately, for lo-fi voices alongside clean ones.

• Rate: the head's sample rate, from the tape's full 24 kHz (fader at the top) down to about 250 Hz (bottom). The head holds each sample until its own clock ticks, with no smoothing filter, so it aliases on purpose: crunchy, metallic, and pitched down where the rate is low.
• Bits: the head's bit depth, from the tape's full 12 bits (top) down to 1 bit (bottom). It rounds to the nearest step, so silence stays silent.

Both act on the head before its feedback is taken. A crushed head that feeds back gets crunchier on every repeat. A clean head's feedback stays clean even if another head is crushed.

Presets saved before these pages existed load with every head at full rate and 12 bits.

Reverse page (A, pressed twice)

Each fader has three zones:

A reversed head plays the tape back in slices as long as the head's time, each slice backwards, arriving on average about one head-time later. That's the classic reverse-delay sound. A short fade (4 ms) at each slice boundary hides the join. Wow and flutter don't apply to reversed heads.

Clocked, the slices follow a beat grid shared by every clocked head. The beat is the clock on Pulse In 1, tap tempo, or, when nothing is synced, the free-time pulse (the Pulse Out 1 rate). A slice a whole number of beats long starts on a beat. A shorter one (say 1/8) starts on the beat and repeats within it, and odd lengths (3/16) cycle against the beat in a fixed pattern. The grid restarts when a jack goes into Pulse In 1 or a tap tempo is first set. The grid follows the clock's actual timing, so a wobbly clock doesn't throw the slices around. If a slice drifts a little off the grid, the head is drawn back by nudging its speed. If it's well off (after a tempo change, or when a head first joins the grid), it fades out, moves, and fades back in over a few milliseconds, so there's never a click. On the 8mu, the Reverse page's LEDs are off for forwards, dim for reverse and bright for reverse clocked.

Presets saved before the Reverse page existed load with every head forwards.

FX page (D, pressed twice)

Time

Free (nothing in Pulse In 1, no tap tempo): each fader sets its head from 0 to 0.5 s, and Main multiplies all of them by ×¼ (fully down) to ×4 (fully up), with ×1 at the centre. The longest delay is about 2.2 s.

Synced (a jack in Pulse In 1, or after tapping a tempo): each head is a whole number of sixteenths of a bar of four, from 1/16 (fader down) to a whole bar (fader up), with Pulse In 1 taken as quarter notes. Main chooses a ratio in nine equal zones: /4, /3, /2, ×⅔, ×1 (centre), ×1½, ×2, ×3, ×4. A time longer than the tape is halved until it fits.

Synced mode starts as soon as a jack is in Pulse In 1, detected with the Computer's normalisation probe. The tempo follows the clock from its second pulse; until then it uses the last tempo it had (120 bpm at power-up).

Panel

Presets

On the card: there are eight presets in the program card's flash (its last 4 kB sector, which every card has, so a 2 MB card is enough). Save and load them with the 8mu alone (hold D or A and move a fader), or from the web editor. At power-up the card loads whichever preset you last saved or loaded.

In the browser: the web editor keeps as many presets as you like, exports and imports them as JSON, copies any of them into a card slot, and backs up the card's eight presets.

Web editor

Open web/index.html in Chrome or Edge, plug a computer into the Computer's USB socket, power-cycle the module, then press Connect card & 8mu. The editor draws the tape with each head at its live delay, shows the tempo and the knobs, and lets you edit every page, freeze and tap. An 8mu plugged into the computer is passed on to the card through the editor.

With two 8mus and several Workshop editors open (8Heads, MatrixVerb, CVSeq, WaveSeq), each 8mu drives one editor and each editor uses one 8mu: it takes the one it had last time if that's free, otherwise any free one. The picker at the top shows every 8mu and who has it; choose one to take it, and Identify flashes its LEDs to tell which is which. With one 8mu it drives whichever editor you last clicked in. Closing an editor frees its 8mu. Use windows side by side rather than tabs: Chrome slows background tabs.

The card chooses its USB mode once, at power-up: if the port is supplying power (an 8mu, or nothing yet), it's a USB host for the 8mu; if a computer is plugged in, it's a USB MIDI device called 8Heads for the editor. The card runs on its own either way. The protocol is documented in sysex.h.

Tips

• Ping-pong: give two heads a width of 0 (so each takes the mono sum), pan one hard left and one hard right, and give the right-hand one some feedback. The built-in Ping-pong preset in the editor does this.
• Runaway: with X above the centre, feedback can go past 100%, and the tape then settles into its own saturation rather than clipping hard. Pull the low-pass down to tame it.
• Freeze, then play the heads: freeze the tape, then move the Time faders or Main: the heads slide around the frozen loop with tape-style pitch bends.

How it works

• The tape is a buffer in RAM: stereo, 12 bits a sample, at 24 kHz (about 2.2 s). Recording at half the output rate is what makes the tape long enough, and it gives the echoes a slightly darker sound than the dry signal, as on real tape.
• Heads read between tape frames with linear interpolation, and each head's delay glides (a one-pole of about 80 ms, limited to 1.5× tape speed), which produces the pitch bends.
• All the DSP is fixed-point, and the per-head control work is spread across the 32-sample control period so that no single sample has too much to do.
• A 16 MB card doesn't help here. Flash is far too slow to write a delay line to in real time, so the tape has to live in the RP2040's 264 kB of RAM, which limits it to about 2.2 s. Presets use flash, but they only need 4 kB.

Building

mkdir build && cd build
cmake .. && make

Needs the Pico SDK (built and tested with 2.1.1). EightMU.h and ComputerCard.h are copied from Demonstrations+HelloWorlds/PicoSDK/ComputerCard. The binary runs from RAM (copy_to_ram), so the USB core can write presets to flash while the audio core keeps running.