Tutorials

Each tutorial builds one thing from nothing, on real hardware, and explains what it is doing as it goes. They are longer than the user guide's pages and shorter than its reference: the guide tells you what a setting is, a tutorial tells you when to reach for it.

Read them in any order. Every one says at the top what it will teach you and what gear it needs, and the tags below say what sort of ground it covers.

How Controls Work

beginner controls MIDI messages preset editor

A preset built from an empty page, one control at a time: a fader, a dial, a list, a pad and a note. It covers the three kinds of control, the two numbers every control keeps - the one on screen and the one in the message - and how to send a Control Change, a 14-bit Control Change, a Program Change and a note. No instrument needed; the editor's console catches everything.

Letting the Instrument Do the Typing

beginner MIDI learn SysEx controls

A preset built by turning knobs rather than typing: the controller listens, and the editor writes down the message type, the parameter and the range. It covers both ways in, everything MIDI learn can hear, how it finds the value byte of a SysEx message - and the places where it guesses wrong, and what Change type does about them afterwards.

How Events Put More on One Page

expert mode control events groups Lua

A knob can be turned, but it can also be pressed and touched, and a label can be told to watch a MIDI parameter. Together they hold far more on one page than it has knobs. Builds a filter that switches its own type, a display that costs no knob, pads that change the page, and an envelope that knows which of its knobs you touched.

A History Worth Keeping

beginner revisions releases preset editor

Your presets are backed up whether you do anything or not; that keeps them safe, not intelligible. A short tutorial on the other half: saving with a sentence, clearing out the automatic saves, giving a version a number, getting back to the one that worked, and branching an old revision off into a preset of its own.

Making a Number Say What It Means

beginner Lua formatters controls

A control shows a number because that is all a MIDI message carries. Seven short Lua functions that turn those numbers into what the instrument's own screen would say - percentages, milliseconds and seconds, signed tunings, L and R, note names, decibels, and the difference between one voice and two. Written for people who have never written a line of code, and every one of them is there to be copied.

Six Switches in One Byte

basic mode SysEx controls preset editor

Writing an instrument's own messages by hand, a byte at a time, for a preset that switches the six operators of a Yamaha DX7. The interesting byte is the one six controls share: the DX7 spends a single bit on each operator, so six switches ride in one value byte - and the editor draws it while you build it.

One Message, Many Controls

expert mode SysEx devices Lua

An instrument's whole parameter change format written once, on the device, instead of once per control. Eight DX7 controls share one five-byte template: a parameter number too big for a single byte, a channel byte a script works out as it sends, and - the thing a local template cannot do - the same template listening, so turning a knob on the synthesizer moves the control it belongs to.

Asking the Instrument What It Is Playing

expert mode patch request SysEx devices

The controller asks the synthesizer what it is playing, and the synthesizer answers with its whole sound in one message. Builds the request, the header that picks that answer out of the traffic, and the rules that take bytes - and bits - out of it into eight controls at once. Ends with a pad that asks, so the preset needs no computer to stay in step.

Ten Bytes That Spell a Name

expert mode Lua patch request controls

The one thing a patch dump carries that no mapping rule can reach: the name of the sound. Lua reads the ten bytes that spell it, a text box shows them, the controller's own keyboard edits them, and ten parameter changes put the result back into the synthesizer.

Thirty-Two Ways to Wire Six Operators

expert mode custom control Lua graphics

A number that means a picture, drawn as one. The Algorithm dial becomes a custom control: a rectangle the script paints, a knob the script answers, and the DX7's thirty-two operator arrangements drawn as boxes and lines. Covers the paint callback and the display thread, the pot callback, and the repaint you always have to ask for yourself.

Using iConnectivity Routers

setup MIDI routing USB host DAW

Connecting the controller to a mioXL or mioXM over a single USB cable, and the routes a working setup needs. Custom port names, several controllers on one network, and a synthesizer brought in behind them and recorded from a DAW.

Debugging a Preset's Lua Script

expert mode Lua debugger preset editor

The script runs on the controller, so this stops it there - at a line you choose, while the instrument is playing - and reads its variables, its call stack and the controller's threads. Every place a preset's Lua can run, stopped in turn: formatters, value functions, events, timers, MIDI callbacks and painting.