Livid Instruments Code

Livid Instruments' new control surface boasts not only an unusual flexibility — courtesy of its custom editing software — but also some fine handmade wooden end‑cheeks...

While the first years of the 21st century may be looked back on as the decade which gave birth to the fashion for innovative USB controllers, things don't seem to be slowing down as we slip into the twenty‑teens. We've seen grid‑oriented controllers from Monome, Novation and Akai, and now Livid Instruments have followed up on their Ohm64 controller (reviewed in the April 2010 edition of SOS) with a new and rather flashy box called the Code.

The Ohm64, and its predecessor, the Ohm, had their roots in popular DJ and VJ culture, with a design based around a central grid of numbered trigger buttons accompanied by faders, knobs and a DJ‑style crossfader. A more recent product called the Block was essentially a portable, cut‑down Ohm64 with a more minimal appearance. The Code is something a little different: the matrix of buttons is gone, replaced by a regimented layout of rotary encoders with integrated LED rings (rather like those you'd find on some digital mixers, or on keyboards like the Nord Modular G2 or the Novation Remote MkII). Clearly, this device is aimed at users who wish to concentrate on shaping and mixing sound or video, rather than triggering and slicing. In many ways, though, the Code and the Ohm64 are similar: they're built from the same materials, with the same styling, and have many features in common.

First Impressions

The Code is exclusively powered by USB and so features just a USB socket and MIDI I/O ports.

The Code arrived in a box with a Livid Instruments sticker and a T‑shirt, but with no printed manual or bundled CD. A search on Livid's web site uncovered a Wiki page describing the Code in considerable detail, although the basic MIDI functionality is fairly obvious, and much can be worked out just by plugging the unit in and approaching it like any other MIDI control surface. Livid's web site also offers some downloadable software packages (which we'll look at shortly); the Code Editor, in particular, provides extensive access to the Code's MIDI functions. There's no bundled license for Livid's VJ software as there is with the Ohm64.

The Code hardware is a brushed aluminium box with wooden end‑cheeks, mirroring the most recent design iteration of the Ohm64. (If you buy directly from Livid, there are various options for different colours of aluminium finish and different kinds of wood.) The only connectors are in a recess on the left hand side: a USB socket and two unlabelled MIDI ports (the left is MIDI in, the right is MIDI out). The Code is purely USB powered, and quite power‑hungry at that: it takes close to the maximum permitted current on a USB port, so you may have to experiment with powered hubs if you use lots of USB devices.

The top-panel encoders have a smooth travel — there's no obvious stepping from one value to the next. Each encoder has an integrated push button, and below each encoder is a dedicated white indicator LED. Flanking the encoder bank to the left and below are a set of backlit silicone buttons like the ones on the Ohm64: each encoder row and column has a button, and an additional large button at the bottom left carries the Livid logo.

So much for the hardware: if we want to see the LEDs, we need to plug the unit in and start 'doing some MIDI'...

Switching On

The parameter screen in the Code Editor.

The Code is USB class-compliant, so it doesn't need any special drivers. My attempts to use the early review unit with a 2010 MacBook Pro were unsuccessful, due to a firmware problem in the Code's USB interface, which has since been resolved: currently‑shipping Codes should work fine, and a free (Windows‑only) firmware loader allows older Codes to be provided with the fix. When I plugged it into a 2006 MacBook Pro, I was up and running straight away.

When plugged into a computer USB port, the Code appears as a device with two MIDI inputs and two outputs. Mac OS X names the device 'Code' and refers to its MIDI ports as 'Controls' and 'Port 2'; if you're using Windows, it may appear as 'USB Audio Device' and you'll be faced with less friendly port labels.

Once plugged in, the Code is powered but still rather inert: the rotary encoders and their LED rings only work properly once there's some MIDI software running on the host (the software doesn't actually have to be communicating with the Code itself).

Fire up your favourite MIDI application and the Code comes to life. Turning an encoder causes LEDs in the encoder ring to light up and show the control's current value. There are 13 LEDs per ring, which, by my calculations, means a display of 26 distinct values, as two adjacent LEDs light up to indicate an intermediate value, while no LEDs means zero or off. All the LEDs are blue, except the highest, which is green, so the minimum (off) and maximum (MIDI 127) settings are easily noticeable. The intermediate display patterns are clearly much lower resolution than the MIDI values being generated, but give a reasonable indication of what's going on, roughly comparable to eyeballing the coloured 'thumb' on the cap of a standard potentiometer. (I notice that the middle LED of a ring lights up on its own for the MIDI value 64, so 'centre' is unambiguous.) A very minor irritation: the encoder knobs are quite tall and closely spaced, so you need to be looking at the front panel almost straight‑on to get an unencumbered view.

The encoder LEDs might be relatively low‑resolution, but the encoders themselves send a complete range of MIDI control values, and at a higher level of precision than pots: while a conventional pot can travel less than a complete turn, the Code's encoders require nearly a turn and a half to cover the full MIDI range, allowing pretty accurate control.

By default, the encoders send MIDI to the Code's USB port, and controller messages appear on the 'Code Controls' port in the computer. Pressing the top of an encoder generates a note message (as well as a rather loud click from the encoder itself — possibly too loud for intimate gigs), and the 13 silicone buttons also generate notes. Since the encoders aren't detented, pressing one will sometimes cause it to turn slightly, generating a spurious controller message. As the whole point of encoders is to track software parameter values, this isn't a major problem — there won't be any sudden jumps in value — but this jitter is still something to be aware of.

The controller and note assignments arrive on MIDI channel 1 and are numbered sequentially, as you might expect, but all can be changed by the Code Editor, as we'll see.

So far, so good: we have a (pretty) box of MIDI controller knobs. Things get more interesting when we send MIDI data to the Code as well, using the Code Controls input port. An encoder's MIDI value is set by sending the same controller message that the encoder outputs: a new value tells the encoder that it now has that value, and the encoder ring LEDs update to reflect it. Sending an encoder's 'push' note message back to the device causes the encoder's solitary white indicator LED to illuminate. The silicone buttons contain green LEDs, which respond to their respective note messages. There's no way to detach an encoder's value from its LED ring — MIDI local control is always on — but the white indicator, and silicone button LEDs, operate independently by default and so, without software support or configuration, won't operate at all.

As with the Ohm64, the Code's two physical MIDI ports allow it to operate as a conventional one‑in, one‑out MIDI interface (appearing on the software side as 'Port 2'). By default, there's no connection between these ports and the Code's top‑panel controls.

Configuring The Code

We've seen how the Code works as a conventional MIDI control surface, but to truly see what it's capable of, and to change its behaviour, we need to fire up the Code Editor, which is a free, open‑source download from Livid's web site.

The editor is very similar to the one provided for the Ohm64 (in fact, they share the same online manual), and is similarly a bit rough-looking around the edges, but it works well enough. When launched, the editor searches for an attached Code and displays a programming panel.

Rather than explain the intricate details of the editor (all of which are documented online), I'll outline its main features and explain what it allows the Code to do.

The editor window shows a stylised graphic of the Code's top panel; various modal sub‑windows can be opened or closed over this graphic, including a floating window for setting the behaviour of each control. Every encoder and button can have its MIDI message reassigned, but while the encoders can only send (and receive) controller messages, buttons can send and respond to notes or controllers. MIDI channels can be set individually or assigned to a global channel.

By default, encoders work in an 'absolute' mode, sending or receiving MIDI values from zero to 127. They can be set to a relative mode, sending messages indicating rotation rather than position, which allows for an indefinite range of values in software: the encoder LEDs display a distinct pattern to indicate this mode. There are many different MIDI coding schemes used by encoders: the Code's scheme is to alternate between the values zero and one for turning left, and between zero and 127 for turning right. This protocol isn't recognised at all by Ableton Live, but did work with a hastily downloaded demo version of Traktor. You'd need to do a bit of research with your software of choice if you wanted to use it with the Code's relative encoder mode. A dedicated overlay panel in the editor allows indicator and button LEDs to be set or cleared, and an image can be loaded on to the indicator LEDs for display at very low resolution.

The Code supports the traditional MIDI modes, such as Local Control On/Off and Omni Mode. (Local On causes the button and indicator LEDs to directly respond to button and encoder presses.) The MIDI Merge switch causes the Code's controls to send MIDI data to its physical MIDI Out port, merged with the computer's MIDI data coming out via USB; this is also how you'd use the Code as a 'stand‑alone' MIDI controller. (I've written 'stand‑alone' in quotes, because it needs to be attached to running MIDI software to function at all.) These MIDI modes can be saved into the Code itself. The editor also provides a MIDI Thru function for routing the Code's controls to other MIDI ports on the computer (working only when the editor is running).

The editor supports presets for the Code. Each preset includes MIDI assignments for the controls and the state of each indicator and button LED. Preset selection can be incremented or decremented via MIDI messages from the Code, and the LED display component of presets can be changed independently. Preset selection is supported only in the editor; the Code itself can only store a single preset.

Conclusions

The Code is a nicely conceived follow‑on from Livid's earlier button‑matrix controllers, and should satisfy the urges of MIDI controller jockeys (myself included) who dislike the parameter‑value jumping associated with potentiometers and (non‑motorised) faders. The LED encoder rings are visually iconic and operate in a logical and well‑designed manner. As on the Ohm64, the MIDI sockets are a nice bonus for those of us who still work with MIDI hardware.

It's hard to find fault with the Code, and my niggles are largely a matter of taste: I'd have preferred stepped encoders (to eliminate the jitter), a lighter, less noisy touch to the encoder buttons, and a lower profile to the top panel. The non‑support for Ableton's relative encoder mode could be considered a drawback, but then you'd probably want to use the Code as a native device instead.

All in all, the Code is a neat little package. If encoders and LED rings float your boat, you should check it out.