Unopad: Controlador MIDI Arduino para Ableton Live sin complicaciones

Componentes y suministros

Componente	Cantidad	Notas
Arduino UNO	1
Pulsadores iluminados APEM serie A01	9
Cables de puente (genéricos)	1 set

Herramientas necesarias

• Soldador (genérico) – opcional

Aplicaciones y servicios en línea

• loopMIDI – crea puerto MIDI virtual
• Hairless MIDI↔Serial Bridge – conecta Arduino con el puerto virtual
• Ableton Live 10 Trial (o superior)

Sobre el proyecto

Resumen

La mayoría de tutoriales de controladores MIDI explican solo la parte de Arduino, no cómo usarlo en el DAW. Quise crear una guía completa en un solo lugar para ayudar a principiantes a entender todo el proceso de creación y uso de un controlador. Espero que sea útil.

Llevaba tiempo queriendo hacer un controlador MIDI y finalmente lo logré. Usé un Arduino Uno, que no envía mensajes MIDI por USB nativamente, así que se requieren programas adicionales (explicados después).

Las siguientes secciones describen el circuito, el código de Arduino y cómo conectar con el ordenador y el DAW (Ableton Live).

Circuito

Circuito muy simple. Usé 9 pulsadores, pero no en matriz, porque quería poder pulsar varios a la vez (es más fácil y tengo pines digitales libres: uso 9, en matriz serían 6).

Botón 3 → D2   Botón 2 → D3   Botón 1 → D4
Botón 6 → D5   Botón 5 → D6   Botón 4 → D7
Botón 9 → D8   Botón 8 → D9   Botón 7 → D10

Mapeo MIDI

Definí 9 notas MIDI, de 36 a 45, con NOTE_ON y NOTE_OFF.

#define NOTE_ONE   36
#define NOTE_TWO   37
// ... definir todas las notas
#define NOTE_ON_CMD  0x90
#define NOTE_OFF_CMD 0x80
#define MAX_MIDI_VELOCITY 127

Este tutorial MIDI te ayudará a entender cómo usar el lenguaje MIDI para controlar cualquier dispositivo que use el protocolo.

MIDI por USB

Como el Arduino Uno no puede enviar notas MIDI al DAW por sí solo, usamos dos programas adicionales: LoopMIDI y Hairless MIDI↔Serial Bridge.

Con LoopMIDI creamos un puerto MIDI virtual que Hairless usa para conectar con el puerto serie del Arduino.

Explicación del código

Creé una clase Button y la uso así:

int NUMBER_BUTTONS = 9;
Button Button1(4, NOTE_ONE);
Button Button2(3, NOTE_TWO);
Button Button3(2, NOTE_THREE);
Button Button4(7, NOTE_FOUR);
Button Button5(6, NOTE_FIVE);
Button Button6(5, NOTE_SIX);
Button Button7(10, NOTE_SEVEN);
Button Button8(9, NOTE_EIGHT);
Button Button9(8, NOTE_NINE);
Button *Buttons[] {&Button1,&Button2,&Button3,&Button4,&Button5,&Button6,&Button7,&Button8,&Button9};

Para más detalles sobre la implementación del botón, ver Buttons.cpp.

Como no usamos resistencias externas (conectamos el botón entre pin digital y tierra), usamos INPUT_PULLUP en lugar de INPUT.

// Buttons.cpp
pinMode(_pin, INPUT_PULLUP);

La parte delicada: no buscas HIGH al pulsar; el botón devuelve LOW (0) cuando se presiona.

// Botón pulsado
if (state == 0) {
  midiNoteOn(Buttons[i]->Note, 127);
}
// Botón no pulsado
if (state == 1) { }

Esto también significa que el estado inicial del botón es 1, no 0.

// Buttons.cpp
_state = 1;

Cada mensaje NOTE_ON requiere su correspondiente NOTE_OFF. Al pulsar se envía NOTE_ON; al soltar, NOTE_OFF. Además del estado inicial, guardé el último estado recordado.

// Buttons.cpp
_lastState = 1;

Solo enviamos mensajes MIDI si el estado actual difiere del último.

// Buttons.cpp
if (state != _lastState) {
  // ...
}

Dos funciones envían los mensajes MIDI. Parámetros: note y midiVelocity (usé velocidad máxima).

void midiNoteOn(byte note, byte midiVelocity) {
  Serial.write(NOTE_ON_CMD);
  Serial.write(note);
  Serial.write(midiVelocity);
}
void midiNoteOff(byte note, byte midiVelocity) {
  Serial.write(NOTE_OFF_CMD);
  Serial.write(note);
  Serial.write(midiVelocity);
}

La lógica del programa está en updateButtons.

void updateButtons() {
  for (int i = 0; i < NUMBER_BUTTONS; i++) {
    int state = Buttons[i]->getButtonState();
    // Botón pulsado
    if (state == 0) {
      midiNoteOn(Buttons[i]->Note, 127);
    }
    // Botón no pulsado
    if (state == 1) {
      midiNoteOff(Buttons[i]->Note, 0);
    }
  }
}

Se llama desde loop().

void loop() {
  if (NUMBER_BUTTONS != 0) updateButtons();
}

Usa tu controlador con DAW (Ableton Live)

Como principiante en DAWs, no sabía cómo conectar nada. Mi Korg Nanokey fue reconocido automáticamente; con el controlador Arduino no ocurre lo mismo, ya que no es un dispositivo HID y el PC lo ve como un Arduino.

Así se conecta y usa en Ableton Live 10:

Conectar con Ableton

1. Abre loopMIDI y crea un nuevo puerto MIDI virtual.
2. Abre hairless-midiserial y asigna: Puerto serie → Arduino Uno; MIDI In/Out → puerto virtual creado en loopMIDI.
3. En File > Preferences de Hairless, ajusta el baudrate igual que en tu sketch de Arduino.
4. Si todo está bien, verás mensajes MIDI entrantes al pulsar botones. No cierres Hairless MIDI.
5. Abre Ableton Live → Options → Preferences → Link MIDI. Configura como en la imagen.
6. Para verificar, mira la esquina superior derecha de Ableton: la caja superior debe parpadear al pulsar botones.

¡Controlador listo para usar!

Usar como Drum Rack o Teclado

Selecciona pista MIDI. En Monitor elige In (no Auto), y en MIDI to elige tu salida de audio. Deberías escuchar el teclado. Lo mismo para Drum Rack.

Mi proyecto terminado

Usé una caja de altavoz vieja y plástico casero. Corté ambas placas a las dimensiones de la caja y taladré agujeros para los botones y un LED que añadiré luego.

Tengo otro altavoz viejo con la misma caja para otro controlador MIDI, esta vez con potenciómetros y joysticks.

Pendientes (To do)

• Pulsación larga en botón para cambiar a modo CC (Control Change).

Código

• MidiDrumPad.ino
• Buttons.cpp
• Buttons.h

MidiDrumPad.ino (Arduino)

#include "Buttons.h"
//------Notas-------------
#define NOTE_ONE 36
#define NOTE_TWO 37
#define NOTE_THREE 38
#define NOTE_FOUR 39
#define NOTE_FIVE 40
#define NOTE_SIX 41
#define NOTE_SEVEN 42
#define NOTE_EIGHT 43
#define NOTE_NINE 44
#define NOTE_ON_CMD 0x90
#define NOTE_OFF_CMD 0x80
#define MAX_MIDI_VELOCITY 127
//------------------------
int NUMBER_BUTTONS = 9;
Button Button1(4, NOTE_ONE);
Button Button2(3, NOTE_TWO);
Button Button3(2, NOTE_THREE);
Button Button4(7, NOTE_FOUR);
Button Button5(6, NOTE_FIVE);
Button Button6(5, NOTE_SIX);
Button Button7(10, NOTE_SEVEN);
Button Button8(9, NOTE_EIGHT);
Button Button9(8, NOTE_NINE);
Button *Buttons[] {&Button1,&Button2,&Button3,&Button4,&Button5,&Button6,&Button7,&Button8,&Button9};
int red_light_pin= 11;
int green_light_pin = 12;
int blue_light_pin = 13;

void setup() {
  Serial.begin(9600);
}

void loop() {
  if (NUMBER_BUTTONS != 0) updateButtons();
}

void updateButtons() {
  for (int i = 0; i < NUMBER_BUTTONS; i++) {
    int state = Buttons[i]->getButtonState();
    // Botón pulsado
    if (state == 0) {
      midiNoteOn(Buttons[i]->Note,127);
    }
    // Botón no pulsado
    if (state == 1) {
      midiNoteOff(Buttons[i]->Note,0);
    }
  }
}

void RGB_color(int red_light_value, int green_light_value, int blue_light_value) {
  analogWrite(red_light_pin, red_light_value);
  analogWrite(green_light_pin, green_light_value);
  analogWrite(blue_light_pin, blue_light_value);
}

// Enviar MIDI note ON
void midiNoteOn(byte note, byte midiVelocity) {
  Serial.write(NOTE_ON_CMD);
  Serial.write(note);
  Serial.write(midiVelocity);
}

// Enviar MIDI note OFF
void midiNoteOff(byte note, byte midiVelocity) {
  Serial.write(NOTE_OFF_CMD);
  Serial.write(note);
  Serial.write(midiVelocity);
}

Buttons.cpp (Arduino)

#include "Buttons.h"
Button::Button(int pin, short note) {
  _pin = pin;
  pinMode(_pin, INPUT_PULLUP);
  _state = 1;
  _lastState = 1;
  Note = note;
}

int Button::getButtonState() {
  int returnValue = -1;
  int state = digitalRead(_pin);
  if(state == _lastState) return 5;
  if(state != _lastState) {
    if(state == 0) {
      returnValue = 0;
    } else {
      returnValue = 1;
    }
  }
  _lastState = state;
  return returnValue;
}

Buttons.h (Arduino)

#ifndef Buttons_h
#define Buttons_h
#include <Arduino.h>
// Button (Pin Number, Note Number)
class Button {
public:
  Button(int pin, short note);
  int getButtonState();
  int Note;
private:
  int _pin;
  short _note;
  int _state;
  int _lastState;
};
#endif

Descarga el código desde mi GitHub

https://github.com/sadreactonly/MidiDrumpad

Esquemático