MIDI-Umbau für Digitalorgeln: Komponenten & Anleitung

Benötigte Bauteile

• 1× Arduino Mega 2560
• 1× DIN-MIDI-Buchse (5-polig, 180°)
• 1× 220 Ω Widerstand (für MIDI-Out)
• 1× USB-A-auf-B-Kabel (Programmierung/Strom)
• 1× AWM-Kabel (mehradrig, für Tastaturverkabelung)
• 1× Stiftleiste 40-polig (1 Reihe, 2,54 mm)
• 1× Schiebe-Potentiometer 10 kΩ linear (Expression-Pedal)
• 1× IDC-Buchse (optional, für steckbare Kabel)
• Jumper-Kabel (optional)

Benötigtes Werkzeug

• Lötkolben + bleifreies Lot + Flussmittel
• Abisolierzange, Seitenschneider, Flachzange
• Kabelbinder, Schrumpfschlauch
• Multimeter (Prüfung der Schaltertypen)
• Bohrer (für MIDI-Buchse & Netzteilzugang)

Software

• Arduino IDE
• Zwei Sketch-Varianten: Matrix-Tastatur & Bus-Tastatur (siehe Code-Abschnitt)

Projektbeschreibung

Dieses Projekt wandelt eine alte Orgelkonsole in einen MIDI-Controller um: Tasten der Manuale und des Pedalboards senden Note-On/Note-Off-Nachrichten über einen Hardware-MIDI-Ausgang. Der originale Klanggenerator wird dabei deaktiviert – die Orgel wird reiner MIDI-Controller.

Schritt-für-Schritt-Anleitung

Schritt 1: Orgel untersuchen

• Tastatur-Typ bestimmen: Matrix (Zeilen/Spalten mit Dioden) oder Bus (gemeinsame Sammelschiene pro Taste). Der Code unterscheidet sich!
• Schaltertyp prüfen: Mit Multimeter testen: Normalerweise offen (NO) oder geschlossen (NC). Beispiel-Orgel: Manuale NO, Pedale NC → Code muss ggf. invertieren.
• Zugang schaffen: Gehäuse öffnen, Platz für Arduino & MIDI-Buchse finden. Netzteil (z. B. 5 V USB-Netzteil intern) und MIDI-Buchse (Bohrung) einplanen.
• Matrix-Größe notieren: Beispiel: 2 Manuale à 6×11, Pedal 6×7. Abweichungen erfordern Code-Anpassung.

Schritt 2: Arduino montieren

Arduino Mega auf Kunststoffplatte schrauben, diese im Orgelgehäuse befestigen. Position so wählen, dass Kabellängen für alle Tastaturen reichen.

Schritt 3: Kabel vorbereiten

Matrix-Tastatur: Pro Manual/Pedal 6 Zeilen + 11/7 Spalten → je 2 AWM-Kabel (Zeilen & Spalten) plus Dioden an jeder Spalte. Kabel großzügig messen, ordentlich verlegen.

Bus-Tastatur: 6 AWM-Kabel (je 10 Adern = 60 Tasten) + 1 Einzeldraht für 61. Taste. An jedem Schalter Diode (Kathode zum Schalter) anlöten.

Schritt 4: Kabelenden an Stiftleisten löten

Entweder direkt an Pinheader löten oder Schraubklemmen/IDC-Buchsen verwenden (empfohlen für Testphase).

Schritt 5: Kabel an Schalter löten

Matrix: Bestehende Drähte zum Original-Controller abtrennen/ablöten. Zeilen-Drähte (falls 6×11) belassen, Spalten-Drähte an neue Kabel mit Dioden anschließen. Kabelbinder für saubere Verlegung.

Bus: An jeder Taste Diode anlöten (Kathode → Schalter), Anode an Ader des AWM-Kabels. Für alle 61 Tasten wiederholen.

Schritt 6: MIDI-Ausgang bauen

220 Ω Widerstand an Pin 5 der DIN-Buchse (MIDI-Out), Pin 4 an Arduino TX1 (Pin 18), Pin 2 an GND. Pins 1 & 3 unbelegt. Schirmung der MIDI-Leitung beachten.

Schritt 7: Stiftleisten auf Arduino stecken

Gemäß Schaltplan (siehe Schematics) alle Header aufstecken. IDC-Buchsen + Jumper erleichtern Umstecken bei Code-Änderungen.

Schritt 8: Software aufspielen

• Arduino per USB an PC anschließen.
• Passenden Sketch wählen (Matrix oder Bus).
• In Arduino IDE neuen Sketch anlegen, Code einfügen, Board „Arduino Mega 2560“ & Port wählen, Hochladen.

Schritt 9: Testen

• MIDI-Interface (USB-MIDI-Adapter) an PC, Orgel-MIDI-Out daran anschließen.
• MIDI-Monitor-Software (z. B. MIDI-OX, Hairless MIDI, DAW) öffnen.
• Jede Taste & Pedal drücken/losen → Note-On (Velocity 100) / Note-Off prüfen.
• Für Standalone-Betrieb: 5 V Netzteil an Arduino-Strombuchse oder USB-Netzteil am USB-Kabel.

Wichtige Hinweise

• Bus-Code ist noch nicht getestet – Feedback willkommen.
• Bei Bus-Tastatur: Dioden Kathode zum Schalter (Matrix: Kathode weg vom Schalter).
• Expression-Pedal (Potentiometer) jetzt im Code unterstützt (analog Pins).
• Pin 13 (Onboard-LED) stört Bus-Code → LED entfernen (zwei Lötkolben) oder vorsichtig zerstören.
• Phosphor-Bronze-Sammelschienen können Kontaktprobleme machen → alle Busse & Kontakte einer Taste parallel verdrahten hilft; 12 V-Keying wäre besser, aber hier nicht möglich.

Expression-Pedal Hardware (Potentiometer-Halterung)

Mechanischer Aufbau für lineares Potentiometer als Expression-Pedal:

• Befestigung: Winkel („L-Bracket“) an bestehendem Pedalhebel oder zweites Winkel direkt am Pedal.
• Gelenk: Maschinenschraube mit Kontermutter & 2 Unterlegscheiben (leichtgängig).
• Stange: 6 mm Alu-Rundstab, oben Augenbolzen (JB Weld), unten Möbelwinkel am Potentiometer-Schieber.
• Potentiometer-Halter: Acrylglas (3″×4,5″), erhöht (3″×0,5″) aufgeklebt (JB Weld), an Möbelband unten im Gehäuse verschraubt.
• Führung: PTFE-Block (3/4″ dick) mit 6 mm Bohrung für Stange, an Acryl verschraubt – spielfreie, reibungsarme Führung.
• Detaillierte Bauanleitung mit Materialliste & Werkzeug siehe Originaltext (Schritt 10).

Code

Variante A: Matrix-Tastatur (6×11 Manuale, 6×7 Pedal + 2 Expression-Pedale)

// Arduino Mega MIDI Controller v21 – Matrix Version
// Manuals: Keyboard A (Ch1), B (Ch2), Pedal C (Ch3, invertiert für NC-Schalter)
// Expression: A0→Ch6 CC11, A1→Ch7 CC11

byte keysA[11][6], keysB[11][6], keysC[7][6];
byte lastA[11][6], lastB[11][6], lastC[7][6];

const int noteOn1=144, noteOff1=128;
const int noteOn2=145, noteOff2=129;
const int noteOn3=146, noteOff3=130;
const int velocity=100;
const int chan6=181, chan7=182, Exp=11;
int LastPot6=1, LastPot7=1;

void setup() {
  Serial.begin(31250); // MIDI-Baudrate
  // Pins 2,22-52 für Keyboard A (Zeilen/Spalten)
  // Pins 3,23-53 für Keyboard B
  // A2-A14 für Keyboard C (Pedal)
  // Alle als INPUT initialisieren, Spalten-Pins werden im Loop auf OUTPUT/LOW geschaltet
}

void loop() {
  // --- Keyboard A lesen (6 Zeilen, 11 Spalten) ---
  // Zeilen-Pins (2,22-30) auf INPUT_PULLUP
  // Spalten nacheinander auf OUTPUT/LOW, Zeilen einlesen → keysA[spalte][zeile]
  // (Code stark vereinfacht – Original siehe unten)

  // --- Keyboard B analog ---

  // --- Keyboard C (Pedal, NC-Schalter → invertieren) ---
  // Nach Einlesen: keysC[][] = !keysC[][]

  // --- MIDI senden bei Zustandsänderung ---
  // Für jede Taste: if (pressed && !wasPressed) NoteOn; if (!pressed && wasPressed) NoteOff
  // State in lastX[][] speichern (0/7 als Flags)

  // --- Expression-Pedale ---
  int cur6 = analogRead(0); int map6 = map(cur6,0,1023,0,127);
  if (abs(cur6-LastPot6)>=8) { MidiSend(chan6,Exp,map6); LastPot6=cur6; }
  int cur7 = analogRead(1); int map7 = map(cur7,0,1023,0,127);
  if (abs(cur7-LastPot7)>=8) { MidiSend(chan7,Exp,map7); LastPot7=cur7; }
}

void MidiSend(int cmd, int note, int vel) {
  Serial.write(cmd); Serial.write(note); Serial.write(vel);
}

Hinweis: Der vollständige, sehr repetitive Original-Code (alle 61 Noten × 3 Keyboards einzeln abgefragt) ist im Originalartikel enthalten. Hier gekürzt dargestellt. Für die Praxis empfiehlt sich eine Array-basierte Implementierung mit Schleifen.

Variante B: Bus-Tastatur (4× 61 Tasten + 3 Expression-Pedale)

// Arduino Mega MIDI Controller 61x4 + 3 Pots – Bus Version
// Keyboards A,B,C,D auf Kanäle 1-4, Expression A13-A15 auf Ch6-8 CC11

byte keysA[11][6], keysB[11][6], keysC[11][6], keysD[11][6];
byte lastA[11][6], lastB[11][6], lastC[11][6], lastD[11][6];

// MIDI-Befehle pro Kanal...
// Pins 2-53, A0-A8 = 61 Tasten-Eingänge (INPUT_PULLUP im Loop)
// A9-A12 = 4 Spalten-Ausgänge (nacheinander LOW)
// A13-A15 = 3 Potis

void loop() {
  // Alle 61 Pins auf INPUT_PULLUP
  // Spalte A9 LOW → Keys 1-11 einlesen → keysA[0..10][0..5]
  // Spalte A10 LOW → Keyboard B
  // Spalte A11 LOW → Keyboard C
  // Spalte A12 LOW → Keyboard D
  // Pins zurück auf INPUT
  // MIDI-Handling analog Matrix-Version
  // 3 Expression-Pedale an A13-A15
}

Auch hier: Originalcode extrem lang (explizite Abfragen für 96 Noten × 4 Keyboards). Array/Loop-Struktur stark empfohlen.

Schaltpläne

• Matrix-Version: 6×11 Matrix für Manuale, 6×7 für Pedal, Potis an A0/A1.
• Bus-Version: 61 Tasten an Pins 2-53/A0-A8, 4 Spalten an A9-A12, 3 Potis an A13-A15.

Fazit

Mit diesem Projekt lassen sich historische Orgeln als leistungsfähige MIDI-Controller für Virtual Instruments (Hauptwerk, GrandOrgue, VSTs) weiterverwenden. Der Aufwand ist hoch (viel Verkabelung), aber das Ergebnis ist eine professionelle, anschlagdynamische (Velocity fix 100) Steuerung mit Expression-Pedalen. Für Fragen & Support empfiehlt der Autor das verlinkte Forum (Arduino Project Hub benachrichtigt nicht zuverlässig).