The ProMIDIco System: Control Pro Tools plug-ins with a MIDI controller and Controllermate software!

This tutorial can be shared in any form under a Creative Commons attribution only license.

Introduction

This tutorial explains in step-by-step detail how to set up a system that will enable you to control plug-in parameters in Pro Tools with a simple MIDI control surface and ControllerMate software (Mac only). The tutorial is comprised of a video, the text document your are reading, and optional downloadable example files. (Download the files and a pdf of this text document.)  It is a follow-up to this video, which introduces the concepts explained here.

For demonstration purposes, I use a Novation SL Zero Mk II control surface and the Avid Mod Delay III plug-in. The method detailed will work with any MIDI control surface that has “endless knobs” (also called encoders). Please see the last section of this document for a detailed discussion of the MIDI control surface requirements. If you are comfortable with basic MIDI programming, you should be able to complete this tutorial.

I have been using this system for a couple of months in my own studio, and it has been working well. It is a powerful method to control plug-ins with a hardware interface. I actually don’t know of any other approach that gives you similar functionality!

The Problem

A little discussion and context about the overall problem of getting a MIDI control surface to control plug-in parameters in Pro Tools is in order. The core of this problem is that a Pro Tools project presents a virtually infinite amount of possible parameters to be controlled. A hardware control surface will almost certainly have far fewer physical controls than there are parameters.

There are many commercially available products that attempt to solve this problem, using different approaches and form factors.

I’ve tried many of these hardware based systems for controlling Pro Tools. They have all fallen woefully short of being actually useful (to me) in the task of controlling plug-in parameters.

At a minimum, a useful system should be an improvement over using the mouse and keyboard. These efforts at integrating such a control surface into my workflow have led me to a well-defined set of desired behaviors for my ideal system, and hence to the development of the method explained in this tutorial.

The design approach of this system comes in part from an “epiphany” I had recently. I was contemplating this inherent difficulty of controlling the huge amount of plug in parameters in a Pro Tools session with a small number of physical controls. As I was ruminating on how much more fun it was to work on an analog console, it struck me that such a console was by definition a “limited” system (duh)! I realized that incorporating some “limitations” by design into a system for hardware-based Pro Tools control makes this a much more solvable problem.

The system outlined here incorporates some carefully considered limitations. The main one is that it is dedicated to the task of controlling plug-in parameters. The task of controlling other aspects of Pro Tools is left to other methods.

Another major design constraint is that in its realization, it relies on creating a user-defined set of “preferred” plug-ins, as well as the specific parameters within them to be controlled. Once this set of plug-ins and parameters has been chosen, the control surface can be mapped and physically labeled with the parameter names for easy navigation. This approach can be characterized as “one knob, one function.” In this aspect, it reflects the design of a physical “channel strip” with its dedicated controls. (It also parallels the Hotkey Matrix with its “one key, one command” principle.)

Desired Behavior of a Control Surface in Pro Tools

These are the core requirements:

• If the plug-in window is on the screen, I can control the parameters with the hardware controls.
• There is no paging, swiping, mode switching, or extra steps to use a physical control.
• It should work with as many plug-ins from different developers as possible.
• I can create my own mappings for parameters to knobs. Any onscreen parameter can be mapped to any physical controller.
• The plug-in window should not have to be in a specific location on the screen to work.
• I have control over the controller “ballistics” and resolution. (In particular, I want to avoid controls that have jumpy and unpredictable acceleration characteristics, going from too slow to too fast.)
• There should be no parameter "pass through” required. (This is also referred to as “parameter pick up”.)This occurs when the setting of a physical control does not match the setting of an onscreen control. The user has to move the fader until it gets to the point where the values converge, and when it passes through the point, it will “pick up” the control of the on-screen parameter. Instead, the given controller should start adjusting the parameter from wherever it is as soon as the user starts to turn it. (By definition, such a system has to use “endless knobs” or motorized faders.)
• I want to be able to choose my own MIDI control surface, and use multiple devices together. A smaller size is preferred, as it keeps the controls in the “sweet spot” in front of the monitors (both computer and speakers).
• The extra software needed to make the system operate should be reliable, relatively lightweight on system resources, and easy to maintain.
• It should be future-proof, meaning safe from being broken by changes that Avid makes to Pro Tools. 
• It should be affordable. 

The system I have developed comes very close to meeting these requirements, with a couple of limitations.

• The MIDI controller must have "endless knobs" that can be set to a "relative mode" of outputting MIDI continuous controller data.
• The plug-in window must be the “active” window in Pro Tools. When you open a plug-in by clicking on the insert slot, or using the drop down menu in a plug-in window, it is the active window. However, if you click off the plug-in window, it will no longer be the active window. Instead, the controls start to affect whatever window was clicked on. Clicking back on the plug-in window makes it active again. This is not ideal, but I haven’t figured out a work-around yet.
• The plug-in must have its individual onscreen controls in the same position every time the plug-in GUI window opens. Most plug-ins are like this. Some plug-ins, like EQ’s, require the user to make a default preset with a set number of bands so the controls stay in the same position. I have found a few FabFilter plug-ins that will simply not work, as their onscreen controllers move around based on what you are doing in the interface, in particular the Pro Q and Pro MB. The Pro C compressor plug-in does work.

Using this tutorial

There are two main components to the tutorial: this document, and the video. There are also supplemental ControllerMate example files to download which have all the files shown in the video, plus additional files which help illustrate how to set up this system with different models of MIDI control surfaces. They can be imported from the ControllerMate File menu, and the import dialog has directions on how to access them within the ControllerMate interface after they have been imported.

The video explains step by step how to map the knobs and buttons on a Novation Zero SL MK II control surface to the onscreen controls of the Avid Mod Delay III plug-in. It also explains the concepts behind each step. This will give the user a conceptual foundation in how Pro Tools, ControllerMate, and the control surface work together as a system. This will be helpful in integrating a particular model of MIDI control surface with the system, since each model of control surface generally has different implementations for its relative output mode.

The video has three parts. Part one explains how to create a “compound object” in ControllerMate that will connect a single physical knob to a single on-screen knob. The term “compound object” is not a technical term in ControllerMate. I use it to refer to a collection of connected building "blocks,” which are the main objects in ControllerMate used to construct macros. Part two shows how to build a similar compound object that connects a single physical button to a single on-screen button. Part three explains how to create a group of these compound objects which represents the entire mapping for a single plug-in.

If you want to take a quicker route, and just get a feel for how this works, check out the example files. To use them, you will need to understand how to set up the connection between your particular interface and ControllerMate. 

ControllerMate

ControllerMate is a macro building application from OrderedBytes software. It has a focus on enabling expanded use of many different types of USB and MIDI controllers. (It is popular in the gaming community for remapping game controllers.) In this tuturiorial we use just a small subset of its functionality. It is great software and is continuously developed and supported. I’ve been a user for over 10 years and have gotten a ton of use from it for all sorts of macro-building tasks. The demo version is limited to 10 “blocks” of programming, which is enough to complete the first part of this tutorial if you want to try it.  A full license is $25.

In ControllerMate, you build macros in a “graphically-oriented, object-based environment.” Macros are utility programs that execute complex behavior in your computer by connecting together a series of simpler commands. The basic “object” in ControllerMate is a called a "building block." You construct macros by connecting various types of building blocks together. The blocks have inputs and outputs. You drag from the output of one block to the input of another to connect them. Blocks can be connected to more than one other block. You can also stack them together to make the connection. 

"Object-based” in this context means simply that the building blocks have properties that control what the block does. You set the properties of a block by selecting it and changing the properties in the “Inspector Window.” The behavior of the macros is defined by how you chain various blocks together and set their properties. (It’s reminiscent of the MAX programming environment. You also find this “select object, change properties in inspector” paradigm in popular media authoring applications like Final Cut Pro X, Illustrator, and Logic.)

Video Part One:

ControllerMate should be installed and launched. (It has a “helper mode” which allows it to run in the background so you don’t actually have to have the program open once you are done with the programming. This screenshot shows both the master enable and the helper enable buttons.)

We will use ControllerMate to build a "compound object” that performs the core functions we need to make our control surface communicate with Pro Tools. This compound object receives MIDI continuous controller data from the control surface.

Here’s what it looks like in ControllerMate. The notes give an outline of how it works.

 

The top three blocks work together to determine whether the incoming CC value should be converted to a mouse wheel down or a mouse up event. These three blocks are the ones that need to be set for different models of MIDI control surfaces (I think of them as a little “hat-shaped" object). You can check out a few more of these in the example files.

First, the MIDI Controller block converts the incoming CC value to a plain number value and sends it to each of the Value Selector blocks. 

The Value Selector block on the left is set so that if it receives a number value that represents a mouse wheel down (63 in our tutorial example), which happens when the physical knob is turned counter clockwise, it issues an “on” message. This triggers the rest of the macro in the left stack. 

Next, the Pulse block converts the “on” message to a quick “on/off” message. This triggers the Cursor block to move the cursor over the on-screen control that we are targeting. (We set the coordinates for this, relative to the plug-in window position, in the ControllerMate inspector window.)

The “on/off” message passes through the Cursor Block, and triggers the last block, the Vertical (Mouse) Wheel block. The block on the left sends the operating system a mouse wheel "down” message if triggered, and the block on the right is set to trigger a mouse wheel “up” message. ControllerMate sends this to the Mac OS as a mouse wheel up or down event, acting as a virtual mouse, and Pro Tools interprets the message accordingly, moving the parameter value up or down.

You can change the “ballistics” or resolution of the physical knob by changing the number of mouse wheel events the Vertical Wheel block issue. To get a faster response, and less resolution, the last block can be set to generate 2,3,4 or more mouse wheel up or down events.

Video Part Two:

We create a compound object that allows us to use buttons on the control surface to control the onscreen buttons in the plug-in. This is a simpler object as there is no logic required to interpret the button press. The only event it monitors for is the button press. Again, the MIDI Controller block will be looking for incoming CC values on a single CC number, specified in the block properties.

Video Part Three:

We create an entire mapping of buttons and knobs for our example plug-in (Avid Mod Delay III). This is how it looks:

A good way to organize a collection of fully mapped plug-ins is to leave each set of blocks on their own Programming Page (each named after the plug-in they map). Programming Pages can all be collected in a “Programming Group." The Programming Pages and Groups all reside in the "Programming Items" pane on the left side of the ControllerMate interface. You create a new Group by clicking gear-icon button above the Programming Items pane  select "create Programming Group."

Each Programming Page can set to “active” or “inactive” by checking the checkbox next to its name in the Programming Items pane.

MIDI Control Surface requirements(back to top)

This is some nitty gritty stuff, and probably the hardest part of setting up this system.

• The interface must have endless knobs (“encoders”). I like the term knobs, as it reminds me of the actual physical thing. These are found on many, but not all, MIDI control surfaces. They are knob controllers that have no beginning or end, and they rotate continuously in both directions. (The interface I use in this tutorial, the Novation Zero SL Mk II, has a large number of different controllers on it, but only eight of them are the endless type).
• You must be able to program the individual controllers so that each is assigned their own MIDI continous controller (CC) number, and can be set to output MIDI CC values in a “relative” mode. This is a key point!
• Buttons work best when set to “momentary” mode (or something along those lines) as opposed to “toggle” mode. This means when you press the button it sends out a MIDI CC value representing an “on” state, and when you let go it sends a CC value representing an off state. If the button has a light, it will only light when you hold it pressed.

You will need to use the documentation (User Guide) for your MIDI surface to set it up. The programming will involve executing a sequence of specific button pushes and knob turns on the control surface itself. Some feedback will be provided as lit buttons or abbreviations on the tiny screens that are found on such interfaces. I have found the process of programming the control surface at this level to be non-user-friendly!

The documentation is often very minimal, without a lot of helpful context. It is often presented in chart form, and found towards the end of the user guide. But I have always found that the needed information is indeed present in complete form.

The hallmark of this type of MIDI programming is that it uses a very limited set of knobs and buttons (the ones on the interface itself), so each control will by necessity perform multiple functions, depending on where you are in the setup process. The main thing you are doing is finding the mode that allows you to set the Continous Contoller number for an individual control, as well as changed the output mode for that individual control. 

Often this setup requires putting the control surface in to some kind of global “MIDI mode” or “Advanced Mode,” because many controllers are multi-function. For example, the Novation Zero SL MK II needs to be set to “Advanced Mode” as opposed to “Automap Mode” to make the controls act as MIDI controls that you can program as you want. (If you want to check out how this is done, here’s a link to the Zero SL user guide. The instructions for programming it in Advanced Mode start on page 16.)

Once you set up one control on the control surface, you will follow the same pattern of steps for each of the others. (It's bit tedious, but once you learn the pattern it gets faster). Then, after you have all of controllers programmed, there will be a way to save the whole setup as a preset or page in your MIDI control surface. Again, careful following of the documentation will be required!

Sometimes when I am programming MIDI devices I find it helpful to use this little utility: http://www.snoize.com/MIDIMonitor/

It will display incoming MIDI information on your computer screen, and you can filter by message type. I often want to look at the CC values my devices is actually outputting when I move a control.

I have have successfully set up this system with Berhinger BCR2000 and the Novation Zero SL Mk II. They are low cost devices, and the Berhinger in particular is well suited for this task with its 32 endless faders.

It also works with the M-Audio Axiom Air 25, but the setup is a bit more complicated and performance is not as smooth as the others because of the way it outputs its MIDI data. I do not recommend this device, but if you already have it, it will work.

“Absolute mode” vs “relative mode” for MIDI controllers

Most midi controllers of the knob or slider variety come programmed by default to output an absolute value on whatever MIDI CC number they have been assigned to. (There are 128 MIDI CCs). As you move the control, it outputs a CC value that changes incrementally with the movement. With fixed knobs and faders, you can think of each position of the control as mapping to a specific value between 0-127 (a fader will output 0 at the bottom and 127 at the top for example).

Endless knobs are a bit different. Because the knob can be turned indefinitely, there is no fixed mapping between the position of the knob and the CC value it puts out. Instead, the software in the control surface remembers the last value that knob sent. When you turn the controller, it is the direction of the turn that causes the value of the CC to increase or decrease. If you turn it past a point where the value is 0 or 127 (the endpoints), it does not output any more values (or outputs the same value repeatedly). As soon as your turn the knob the other direction it will start to increment or decrement the value the other way. (I find this kind of unintuitive, but this is how they are set by default on most MIDI control surfaces). Even though it’s an endless knob, this is still “absolute mode” type of behavior.

Relative Mode:

For this system to work, we need endless knobs, set to “relative mode.” When an endless knob is set to relative mode, it still transmits MIDI CC values, it just does it in a different way. Most controllers have several options for relative mode, but they basically work the same way. Each counterclockwise increment of the knob outputs a single MIDI CC value, each clockwise turn outputs a different single MIDI CC value. The various options usually specify what these values are. (An increment is the smallest turn amount a knob will register. It’s like a step) As you turn the knob, it outputs a stream of identical CC values, one for each increment.

In this tutorial, I picked a setting on the Novation that outputs a CC value of 63 for each counter clockwise increment of the knob, and a CC value of 65 for each clockwise turn. Many controllers, like the Novation, have an option that will output data that reflects the acceleration of the knob. So for slow counter clockwise increments it will output CC value 63, as you turn faster the values would go down, 62, 61, 60 and so forth. The clockwise increments go the other way. Slow outputs 65, then as you turn faster you get 66, 67, 68 etc…(they usually only register about 6 levels of acceleration). If you want to get fancy, you can program ControllerMate to interpret this data, and have knob-acceleration control over your onscreen parameters.

The Berhinger BCR 2000 setting I use outputs values of 127 on each counterclockwise increment, and 1 on each clockwise increment. These values are somewhat arbitrary, and each manufacturer seems to pick their own schemes. We just need to understand exactly what data is output when a knob is turned, so we can set a “Value Selector” building block in ControllerMate to respond when it gets those values.

 

<
Pro Tools-Controllermate-MIDI Control Surface Tutorial by Brian Daly is licensed under a Creative Commons Attribution 4.0 International License.
Based on a work at http://dnamusiclabs.com/protools-controllermate-tutorial.