Unopad: Nahtloser Arduino MIDI-Controller für Ableton Live

Komponenten und Zubehör

Arduino UNO	1
Schalter-Aktor, APEM A01 Serie beleuchtete Drucktaster	9
Jumper-Kabel (allgemein)	1

Benötigte Werkzeuge und Maschinen

• Lötkolben (allgemein) – optional

Apps und Online-Dienste

• loopMIDI
• Hairless MIDI<->Serial Bridge
• Ableton Live 10 Testversion

Über dieses Projekt

Zusammenfassung

Die meisten Tutorials und Projekte für MIDI-Controller erklären nur die Arduino-Arbeit, nicht aber die Nutzung in der DAW selbst. Ich wollte ein Tutorial erstellen, das alles Notwendige an einem Ort vereint. Dieses Projekt soll Anfängern helfen, den Prozess der Erstellung und Nutzung eines Controllers besser zu verstehen – und ich hoffe, es ist für jemanden nützlich.

Ich wollte schon lange einen MIDI-Controller bauen und habe es endlich geschafft. Ich nutze einen Arduino Uno, der nicht von sich aus MIDI-Nachrichten per USB senden kann – daher waren spezielle Programme nötig (dazu später mehr).

Die folgenden Abschnitte beschreiben die Schaltung, den Arduino-Code sowie die Verbindung zu Computer und DAW – hier am Beispiel von Ableton.

Schaltung

Es ist eine sehr einfache Schaltung. Ich verwendete 9 Drucktaster, aber nicht in Matrix-Anordnung, weil ich die Möglichkeit wollte, mehrere Tasten gleichzeitig zu drücken (es ist einfacher und ich hatte ungenutzte digitale Pins – ich nutze 9, in Matrix wären es 6).

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

MIDI-Mappings

Ich definierte 9 MIDI-Noten, von 36 bis 45, sowie NOTE_ON und NOTE_OFF.

Dieses MIDI-Tutorial hilft zu verstehen, wie man die MIDI-Sprache nutzt, um jedes Gerät zu steuern, das das MIDI-Protokoll verwendet.

#define NOTE_ONE 36
#define NOTE_TWO 37
// Alle Noten hier definieren
#define NOTE_ON_CMD 0x90
#define NOTE_OFF_CMD 0x80
#define MAX_MIDI_VELOCITY 127

MIDI über USB

Da der Arduino Uno nicht selbst MIDI-Noten an die DAW senden kann, müssen wir zwei Zusatzprogramme nutzen: LoopMIDI und Hairless MIDI<->Serial Bridge.

Mit LoopMIDI erstellen wir einen virtuellen MIDI-Port, den wir in Hairless MIDI mit dem Arduino-Port verbinden können.

Code-Erklärung

Ich erstellte eine Button-Klasse und nutze sie so:

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};

Für Details zur Button-Implementierung siehe Buttons.cpp.

Da wir keine Widerstände nutzen, sondern den Taster nur mit dem digitalen Pin und Masse verbinden, verwenden wir INPUT_PULLUP statt INPUT.

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

Der knifflige Teil: Man sucht nicht nach einem HIGH-Signal, wie man annehmen könnte – der Taster gibt LOW (0) aus, wenn er gedrückt wird.

// Taster gedrückt
if (state == 0) {
  midiNoteOn(Buttons[i]->Note, 127);
}
// Taster nicht gedrückt
if (state == 1) {
}

Das bedeutet auch, dass der initiale Tasterzustand 1 ist, nicht 0.

// Buttons.cpp
_state = 1;

Jede NOTE_ON-Nachricht erfordert die passende NOTE_OFF-Nachricht. Wenn der Taster gedrückt wird, sendet er NOTE_ON. Wenn er losgelassen wird, sendet er NOTE_OFF. Deshalb habe ich neben dem Initialzustand auch den letzten gemerkten Zustand im Code gespeichert.

// Buttons.cpp
_lastState = 1;

Wir senden MIDI-Nachrichten nur, wenn der aktuelle Zustand vom letzten abweicht.

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

Diese beiden Funktionen senden MIDI-Nachrichten. Parameter sind note und midiVelocity (ich nutze maximale Velocity).

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);
}

Die Programmlogik liegt in der Funktion updateButtons.

void updateButtons() {
  for (int i = 0; i < NUMBER_BUTTONS; i++) {
    int state = Buttons[i]->getButtonState();
    // Taster gedrückt
    if (state == 0) {
      midiNoteOn(Buttons[i]->Note, 127);
    }
    // Taster nicht gedrückt
    if (state == 1) {
      midiNoteOff(Buttons[i]->Note, 0);
    }
  }
}

Die Funktion wird in loop() aufgerufen.

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

Controller mit DAW nutzen (Ableton Live)

Als DAW-Anfänger wusste ich nicht, wie man Geräte anschließt. Mein Korg Nanokey wurde von Ableton sofort erkannt. Beim Arduino-Controller war das anders – er ist kein HID-Gerät und der PC erkennt ihn weiterhin als Arduino.

Hier zeige ich, wie man den Arduino-MIDI-Controller in Ableton Live 10 verbindet und nutzt.

Mit Ableton verbinden

1. loopMIDI öffnen und einen neuen virtuellen MIDI-Port erstellen (siehe Bilder).
2. hairless-midiserial öffnen und Serial Port, MIDI Out und MIDI In zuweisen. Als Serial Port den Arduino Uno wählen, für MIDI In und Out den virtuellen Port aus Schritt 1.
3. Baudrate in Hairless auf denselben Wert wie im Arduino-Sketch einstellen (Datei → Einstellungen).
4. Wenn alles stimmt, kann man MIDI-Nachrichten debuggen: Taster drücken und in Hairless auf eingehende Nachrichten prüfen.
5. Hairless MIDI nicht schließen!
6. Ableton Live öffnen, Optionen → Einstellungen → Link MIDI – sollte wie im Beispiel aussehen.
7. Zur Prüfung oben rechts in Ableton schauen: Das obere Feld sollte blinken, wenn ein Taster gedrückt wird.

Controller ist bereit!

Controller als Drum Rack oder Keyboard nutzen

MIDI-Spur auswählen. Im Monitor-Bereich In statt Auto wählen, und bei MIDI to den Lautsprecher-Ausgang wählen. Jetzt sollte das Keyboard spielbar sein. Dasselbe für Drum Rack.

Mein fertiges Projekt

Ich nutzte einen alten Lautsprecherkarton und etwas Plastik, das ich zu Hause fand. Beide Plastikplatten schnitt ich auf die Maße des Gehäuses zu und bohrte Löcher für die Taster und eine LED, die ich später hinzufügen werde.

Ich habe noch einen weiteren alten Lautsprecher mit demselben Gehäuse, den ich für einen weiteren MIDI-Controller mit Drehreglern und Joysticks nutzen werde.

To Do

• Langdruck auf Taster für Wechsel in CC-Modus

Code

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

MidiDrumPad.ino (Arduino)

#include "Buttons.h"
//------Noten-------------
#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();
    // Taster gedrückt
    if (state == 0) {
      midiNoteOn(Buttons[i]->Note, 127);
    }
    // Taster nicht gedrückt
    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);
}

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

// MIDI Note OFF senden
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-Nummer, Noten-Nummer)
class Button {
public:
  Button(int pin, short note);
  int getButtonState();
  int Note;
private:
  int _pin;
  short _note;
  int _state;
  int _lastState;
};
#endif

Code auch auf GitHub: https://github.com/sadreactonly/MidiDrumpad

Schaltplan