Alesis Vortex: Modify the Ribbon Controller behavior

Some Keytar players use both hands on the keyboard part to play more complex notes arrangements. When I need to do that, I use a regular keyboard. As explained in a previous post, “I have seen keytar players “cross-under” the support strap to use their left hand on the (small) keyboard part. I have tried and it’s really uncomfortable because it puts the left wrist at a very odd angle. Since the keyboard part of the Vortex is only three octave long, my left wrist starts hurting as soon as I try that. Plus it looks dorky…” But, it might sometimes be useful to send some notes using the left hand. One example is when using RealGuitar, from RealGuitar uses some keyboard notes to control numerous program parameters. For example, Midi note C3 is a “strum down” and D3 is “strum up”. Instead of using the “cross-under” method, I would like to use my left hand on the neck of the Vortex. I thought about using other buttons on the Vortex neck, but none of them is programmable. The only one that actually sends something is the Sustain button (CC 65)(NOT changeable). I could use it but I need more than one button. The only solution (apart from modifying the Vortex)(see below) is to use the Ribbon Controller. The first method that I tried was to divide the Ribbon Controller’s surface into 4 logical sections: one section for each finger in my left hand (the thumb is used to hold the instrument, of course). If you position your fingers on the ribbon, they fall naturally next to each other. Pressing each one in turn while looking at a midi monitor gives me four distinct sections:

  • Index: 0 to 20
  • Second finger: around 50 (± 10)
  • Third (ring) finger: around 80 (± 10)
  • Fourth finger: 110 to 127
Fingers placed naturally on the Ribbon Controller

Fingers placed naturally on the Ribbon Controller

The ranges allow for some movement and imprecision. Of course, one restriction with this method is that you can’t touch the Ribbon Controller with two or more finger. Well, you can, but the resulting CC value will be between two ranges. For example, if I press both Index and Second finger on the Ribbon, a value of 30 is shown. That might give you the idea of using “sub-ranges” but due to the imprecision of finger placement, you might have a very unstable value. I guess that with plenty of practice, one might be able to diminish the error margin (thus the ranges) for each finger, like a violinist would have to do. But my left hand is just precise enough to hit piano notes, which translates to the ranges shown above.

One finger (ring) on the Ribbon Controller

One finger (second/major) on the Ribbon Controller

So, the key is now to map these ranges of incoming CC values to specific NoteOn Midi messages. Here are three ways to get the Ribbon Controller Midi messages transformed in NoteOn messages:

1- Use a software solution

1.1 Existing Software

I know two programs that will let you change midi messages on the fly. The first one is from and is called pizmidi, available at It’s free. It will load as a VST plugin in Ableton or other software and the midiConverter3 option will let you transform any incoming Midi CC into a NoteOn. It takes a while to program the necessary parameters but the results are OK. Take a look at the other plugins offered in pizzmidi. There’s over 40 of them! Since this is a VST, it will run on both Windows and Mac. Another way to transform Midi messages is to use a (NOT free) program called Bome’s Midi Translator Pro. It costs €59 (about US$ 80) and is very powerful. You will have to write rules that will transform the ranges into NoteOn messages. It will also run on Windows and Mac.

1.2 Write your own software

A third way to do the translation is to write your own software. This is what I tested first. I wrote a small program using Processing and a Midi library called MidiBus. The code is simple: the program waits for Midi input. If the incoming command is in the range that you want, you replace it with a Midi NoteOn command. Here’s the code for the active part:

void controllerChange(int channel, int number, int value) {
  // Receive a controllerChange
  int thisNote = 0;
  println("Controller Change:");
  if (lastValue == 0) { //Don't send a note if one is already active
    lastValue = value;
    if (channel == 0 && number == 1 && (value >= 1 && value <=15)) { 
      thisNote = 39;
    if (channel == 0 && number == 1 && (value >= 40 && value <=60)) { 
      thisNote = 38;
    if (channel == 0 && number == 1 && (value >= 70 && value <=90)) {
      thisNote = 37;
    if (channel == 0 && number == 1 && (value >= 110 && value <=127)) {
      thisNote = 36;
    //myBus.sendNoteOn(channel, number, value);
    if (thisNote != 0) {
      myBus.sendNoteOn(0, thisNote, 64); // Send a NoteOn
  else {
    if (value == 0) { //reset the Note flag
      lastValue = 0;

There’s some debugging code in there to show the incoming CC command and to show which finger was pressed. There is also some code to prevent multiple values. When your finger touches the Ribbon, many values can be sent in rapid succession. This will happen as soon as you move your finger (or even press harder) on the ribbon. This is the normal behavior for the Ribbon. The problem is that will send more than one NoteOn for one finger press. One solution is to block outgoing NoteOn until a finger is released. This will also ensure that only one finger can touch the Ribbon at one time. The key is to add a variable that will block outgoing messages until the received value from the Ribbon has a value of 0 (zero). This will happen when the Ribbon is programmed in non-latch mode, which is the default. The entire code is in this file: midiKeystrokeCCtoNoteOn.pde

2- Use a hardware solution

2.1- Midi Solutions Event Processor

Midi Solutions makes an Event Processor that will let you re-map any Midi command to NoteOn commands. This is explained here. I haven’t tested it.

2.2- Practical Usage Midi Processor

I built my own Midi processor. I call it the MP-1. It can be programmed to do anything with any Midi command. It’s built using an Arduino (any will do). I wrote many versions of the software. Some use hard-coded translation tables (the simplest way if you are good at programming the Arduino) while others let you store “translation tables” in the Arduino EEPROM memory. This is my prefered method, and by far the most flexible.

3- Modify the Vortex

I have modified my Vortex. In a previous post, I explain what was done. I found that using the Ribbon Controller required too much left-hand/left-fingers ability that I don’t have. So instead of practicing the precise timing required to only press with one finger, I added buttons dedicated for this purpose. This also lets me keep full functionality for the Ribbon. That modification uses a micro-controller similar to the Arduino. It’s a Teensy ++ 2.0 from The main advantage over a stock Arduino is that it incorporates a USB port. So I can just plug it in a computer and it is recognized as its own Midi instrument.

This entry was posted in Music equipment, Vortex and tagged , . Bookmark the permalink.

One Response to Alesis Vortex: Modify the Ribbon Controller behavior

  1. Rio says:

    Well, thanks again! You’re assom!
    I will use the Vortex/mainstage as a second secon keyboard and second guitar on stage, and for guitar only need to change from normal sound to bridge mute and repeat played notes (strum up/down), so I think the easier solution will be assign sustain button to bridge mute and use PizMidi to split the ribbon controller into two areas (strum up and strum down).
    I’ll do some tests and comment the results, maybe with a video, too :)

Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>