Arduino Fußtaster bauen für Behringer XR18

  • Ersteller Mathias1234
  • Erstellt am
Die USB Buchse vom xr18
gibt gar nichts aus. Das ist ein USB B Eingang.

Dur brauchst auch kein 7.poliges Kabel. 5 Pole reichen. MIDI hat nur 1 Paar, 1 Ader für Masse. und dann 2 für die Stromversorgung auf den beiden zusätzlichen Pins.
0.3er reicht ewig.
 
  • Gefällt mir
Reaktionen: 1 Benutzer
Stimmt, manchmal denkt man um die Ecke obwohls geradeaus geht... Alles klar, danke.
 
Kleine Frage noch. Die LEDs für die Taster kommen an GND und an jeweils an einem seperaten Digitalpin des Arduino oder? Die Taster beide auch an GND und auch nochmal jeweils an einen Digitalpin.


Also z.B. LED 1 an D2 und LED 2 an D3
Taster 1 dann an D4 und Taster 2 an D5.

Passt das dann so?
 
Zuletzt bearbeitet:
Die LEDs brauchen noch einen Vorwiderstand, 330 Ohm bis 1 kOhm. Ansonsten ja, nach Belieben auf die Digitalpins verteilen (Außer D0 und D1 wenn die serielle Schnittstelle verwendet wird, denn dann sind die dafür reserviert).
 
  • Gefällt mir
Reaktionen: 1 Benutzer
So, Verdrahtung ist erstmal fertig, wenn ihr nix einzuwenden habt.

Midibuchse: ist mit Pin 4 und 5 über 220 Ohm an +5v und TX1 angeschlossen wie auf der ersten Seite beschrieben.

Potentiometer: Linke Lasche an +5v und rechte Lasche an GND, die mittlere Lasche an A0.

Taster: Taster 1 und 2 liegen mit einer Seite an D11 und D12, die andere Seite an GND.

Diode: über jeweils 470 Ohm an D2 und D3 und die andere Seite an GND. (die einen sagen der Widerstand muss an GND und die anderen sagen die andere Seite?)
Hab das jetzt so wie in der verlinkten Anleitung gemacht; die sagt am längeren Beinchen den Widerstand und an den Digitalpin.

Wenn da jetzt nix dagegen spricht. Können wir uns mal an den Code machen.



Können soll das Ding Masterlautstärke am XR18 regeln ( nur wenn man dreht den Wert ändern aber ohne Rückabfrage, so dass andere Benutzer auch noch die Chance haben zu Bedienen, keine MIDI Flut)
Mutegruppen 1 und 2 am XR18 schalten und dabei anzeigen über LED wenn Mutegruppe an oder aus.
 
Zuletzt bearbeitet:
Ok,
Arduino IDE ist installiert?
Ein neues Programm hat in der Regel 2 Funktionen: setup() und loop()
setup wird einmal zu Beginn aufgerufen
loop immer wieder zyklisch. Und nein- das ist keine Schleife sondern eine Funktion, die wiederholend aufgerufen und abgearbeitet wird.
Leider braucht man für diese Konstruktion globale Variablen, wenn man in setup etwas initialisieren will, was man in loop braucht.

die .ino Datei ist übrigens eine Text-datei, die man auch mit einem normalen Texteditor ansehen und bearbeiten kann.

also los mit Setup und davor die #defines
#define wirkt so, dass es das erste "Wort" durch das 2. "Wort" ersetzt, bevor der Compiler läuft.
Oft wird eine Variable für die Pin Nummern verwendet, aber spätestens bie A0 geht das nicht mehr
Ach ja, hier keine ; verwenden, denn die werden mit ersetzt und sorgen dann im Programm für nicht
nachvollziehbare Syntaxfehler

#define Taster1 11
#define Taster2 12
#define Led1 2
#define Led2 3
#define Poti A0

void setup() {
pinMode(Led1, OUTPUT);
pinMode(Led2, OUTPUT);
pinMode(Taster1, INPUT_PULLUP);
pinMode(Taster2, INPUT_PULLUP);

// Setup serial port for MIDI communication
Serial.begin(31250);

}
 
Ja ist installiert. Bis dahin hab ich jetzt alles mal eingegeben.
 
Ok im Loop muss mn dann alles zyklisch abfragen Und ich würde mir immer den letzten Wert merken, so dass nur bei Änderungen etwas gesendet wird.

Variablen (vor setup global anlegen, du kannst dir natürlich auch andere Variablennamen ausdenken)

byte Tastwert1;
word Potiwert = 0;
byte AnalogControl;

Abfrage geht dann in Loop (jeweils nur ein Beispiel)

Tastwert1 = digitalRead(Taster1);

Potiwert = analogRead(Poti); // Wertebereich 0 .. 1023
AnalogControl = Potiwert >> 3; // macht daraus 0 .. 127

digitalWrite(Led, xxx); // xxx ist der Wert den du da hinschreiben möchteest, 0 oder 1


Wie ein CC Wert an MIDI gesendet wird, habe ich oben schon verlinkt
 
OK, das muss ich in Ruhe machen. Mal sehen ob ich dazu komme heute Abend.
Aber ich merke jetzt schon an, dass ich echt nicht gut bin in sowas. Es werden also viele Fragen noch kommen.

Am liebsten wärs mir ja wenn sich jemand erbarmt und mir das komplette Programm schreiben kann ...

Aber ich schau mal ob ich's hinbekomme
 
Oben steht ein fertiger Code - inkl. Tastenentprellung.
 
OK... Da fehlen noch die LEDs oder ?
Steinigt mich nicht aber programmiert hab ich in meinem Leben noch genau garnix... 🥴.


Wie gesagt mal sehen ob ich's hinbekomme 🙄
 
Ok, was brauchst du weiter ...
HIer in meinem Review ist die MIDI Implementation des XR18 zu finden (oder auf der Behringer Webseite). Auch wichtig: Die Kanäle werden von 1 .. 16 gezählt, beim Senden des seriellen Worts aber von 0 .. 15, so dass man da 1 abzeihen muss.

Du brauchst den Main Fader: Kanal 1 und CC 31
Sowie die Mute Gruppen 1 (Kanal 2 CC36) und Gruppe 2 (Kanal 2 CC37)

Dann würde ich eine Funktion basteln (vor setup einfügen)

void MidiSendCC(byte channel, byte ControlNo, byte value)
{
channel-- ; // umrechnen von 1..16 auf 0 .. 15
channel &= 0x0f; // Sicherheit, falls Nummer zu groß
ControlNo &= 0x0f;
value &= 0x0f;
Serial.write(0xb0 + channel); // Control Change + Kanalnummer im Bereich 0.. 15, Wenn 1..16 dann: (0xaf + channel);
Serial.write(ControlNo);
Serial.write(value);
}
 
  • Gefällt mir
Reaktionen: 2 Benutzer
C++:
#include <SoftwareSerial.h>
#include <MIDI.h>

// Pin-Definitionen
const int button1Pin = 2;
const int button2Pin = 3;
const int potPin = A0;
const int midiTxPin = 6;

const int led1Pin = 8;  // LED für Button 1
const int led2Pin = 9;  // LED für Button 2

// MIDI-Konstanten
const byte midiChannel1 = 1;
const byte midiChannel2 = 2;
const byte ccButton1 = 36;
const byte ccButton2 = 37;
const byte ccPot = 31;

// MIDI via SoftwareSerial
SoftwareSerial midiSerial(-1, midiTxPin); // RX, TX
MIDI_CREATE_INSTANCE(SoftwareSerial, midiSerial, MIDI_OUT);

// Entprell-Zeit
const unsigned long debounceDelay = 50; // in Millisekunden

// Taster 1
bool button1StableState = HIGH;
bool button1LastRead = HIGH;
unsigned long button1LastChangeTime = 0;

// Taster 2
bool button2StableState = HIGH;
bool button2LastRead = HIGH;
unsigned long button2LastChangeTime = 0;

// Poti
int lastCCValuePot = -1;

void setup() {
  pinMode(button1Pin, INPUT_PULLUP);
  pinMode(button2Pin, INPUT_PULLUP);
  pinMode(led1Pin, OUTPUT);
  pinMode(led2Pin, OUTPUT);

  midiSerial.begin(31250); // MIDI-Standard Baudrate
  MIDI_OUT.begin(MIDI_CHANNEL_OMNI);
}

void loop() {
  unsigned long currentTime = millis();

  // === Taster 1 mit Entprellung ===
  bool currentRead1 = digitalRead(button1Pin);
  if (currentRead1 != button1LastRead) {
    button1LastChangeTime = currentTime;
    button1LastRead = currentRead1;
  }
  if ((currentTime - button1LastChangeTime) > debounceDelay && currentRead1 != button1StableState) {
    button1StableState = currentRead1;
    if (button1StableState == LOW) {
      MIDI_OUT.sendControlChange(ccButton1, 127, midiChannel2);
      digitalWrite(led1Pin, HIGH); // LED1 an
    } else {
      MIDI_OUT.sendControlChange(ccButton1, 0, midiChannel2);
      digitalWrite(led1Pin, LOW);  // LED1 aus
    }
  }

  // === Taster 2 mit Entprellung ===
  bool currentRead2 = digitalRead(button2Pin);
  if (currentRead2 != button2LastRead) {
    button2LastChangeTime = currentTime;
    button2LastRead = currentRead2;
  }
  if ((currentTime - button2LastChangeTime) > debounceDelay && currentRead2 != button2StableState) {
    button2StableState = currentRead2;
    if (button2StableState == LOW) {
      MIDI_OUT.sendControlChange(ccButton2, 127, midiChannel2);
      digitalWrite(led2Pin, HIGH); // LED2 an
    } else {
      MIDI_OUT.sendControlChange(ccButton2, 0, midiChannel2);
      digitalWrite(led2Pin, LOW);  // LED2 aus
    }
  }

  // === Potentiometer lesen und MIDI CC senden ===
  int potValue = analogRead(potPin);
  int ccValuePot = map(potValue, 0, 1023, 0, 127);

  if (ccValuePot != lastCCValuePot) {
    MIDI_OUT.sendControlChange(ccPot, ccValuePot, midiChannel1);
    lastCCValuePot = ccValuePot;
  }
}

Hier komplett mit LEDs. Taster 1 steuert Mutegroup1, Taster 2 Steuert Mutegroup2, Poti streuert Mainvolume. Wenn das Mainvolume nicht voll, sondern nur in einem bestimmten Bereich gesteuert werden soll muss die Funktion int ccValuePot = map(potValue, 0, 1023, 0, 127); angepasst werden, die letzten beiden Ziffern legen den Regelbereich des Midi-Befehls fest. Eventuell muss auch überprüft werden, ob bei voll zugedrehtem Poti überhaupt eine 0 eingelesen wird, respektive bei voll aufgedrehtem Poti eine 1023. Die beiden Grenzen könnten in der MAP-Funktion dann auch noch angepasst bzw. nachgeführt werden.

Vorteil der Verwendung der Bibliothek ist, das irgendein Digitalpin als TX fürs Midi verwendet werden kann. Bei der Methode von Chris blockiert man sich D0 und D1, welche wie richtig festgestellt, zur Kommunikation über USB gebraucht werden. Man kann die verwenden, dann ist aber nach dem Programmieren des Arduinos kein Debugging über die USB Schnittstelle mehr möglich.
 
Grund: erweiterte Erklärung
Zuletzt bearbeitet:
  • Gefällt mir
Reaktionen: 2 Benutzer
ccValuePot = map(potValue, 0, 1023, 0, 127);
Statt der Umrechnung (macht die map Funktion über Formeln mit Multiplikation und Division) kann man einfach
ccValuePot = potValue >> 3;
schreiben. macht nämlich nichts anderes, nur schneller und ökonomischer. Und man will ja von dem 10 Bit Wert nur die oberen 7 Bit und schneidet die unteren einfach ab (bzw. schiebt die rechts raus ins Nirvana)

Du müsstest auch noch verraten, woher man die Bibliothek bekommt und wie man die der Arduino IDE beibringt.
 
Zuletzt bearbeitet:
  • Gefällt mir
Reaktionen: 2 Benutzer
ccValuePot = potValue >> 3;
schreiben. macht nämlich nichts anderes

Jein, für diese Anwendung sicherlich hinreichend genau und damit super anwendbar, ohne Frage - aber Bitschiebung funktioniert 100% korrekt nurwenn die Skalierung eine Potenz von 2 ist. Wenn du 1023 auf 127 abbilden willst, ist das eine Division durch etwa 8 (1023/127 ≈ 8,05). Das ist kein exaktes Bit-Shifting. Aber wie gesagt, für diese Anwendung irrelevant. Die MAP Funktion hat den Vorteil dass der Reglebereich für das Main-Volume auch eingeschränkt werden kann, z.B. schon ab -20dB bis +10dB, oder auch nur bis 0dB. Da kann man mit dem Poti feinfühliger arbeiten.

Die Bibliothek gibts wie weiter oben beschrieben bei FortySevenEffects.


Im Anhang der aktuelle Release.

In der Arduino IDE einfach in der Bibliotheksverwaltung ".ZIP Bibliothek hinzufügen" auswählen und die ZIP-Datei einbinden.
 

Anhänge

  • arduino_midi_library-5.0.2.zip
    148 KB · Aufrufe: 18
Zuletzt bearbeitet:
  • Gefällt mir
Reaktionen: 2 Benutzer
Alter, ihr seid der Hammer. Kanns nur noch nicht ausprobieren, da ich aktuell beruflich unterwegs bin. Sobald wieder möglich teste ich das. Vielen vielen Dank schon mal. Kann ich euch was gutes tun bis dahin?
 
Hi - Du wirst wohl noch nicht dazu gekommen sein, weiter zu experimentieren. Hast Du aber vielleicht schon Bilder von Deinem Hardware Setup? Wäre cool, zu sehen mit welchem Gehäuse etc. Du da arbeitest.
 
Hi, ich hatte leider etwas zu kämpfen in letzter Zeit, dass ich überhaupt zu was komme. Das Programm funktioniert jetzt zumindest soweit. Verdrahtet hab ich auch soweit alles und es klappt.

Zum Gehäuse basteln bin ich dann leider doch noch nicht gekommen. Ich werd's vermutlich komplett selbst aus Holz und ner Aluplatte für die Schalter und den Poti machen. Wann ich dazu komme weiß ich noch nicht, da gerade mit Job und Familie viel los ist. Aber wenn's dann fertig ist, stelle ich's hier nochmal rein.

Danke außerdem nochmals an alle Helfer die hier in dem Thread zugange waren und mir Programmiernoob ja das komplette Arduino Programm geliefert haben.
 
  • Gefällt mir
Reaktionen: 1 Benutzer
Ich hab mich gerade beim Abendessen mit @hack_meck ausgetauscht, weil mich das Konzept nicht losgelassen hat. Sehe ich das richtig, dass ich im Maximum 8 Möglichkeiten habe, ein analoges Poti anzuschließen und dafür theoretisch auch passive Expression Pedals nehmen kann? Sagen wir sowas with den HoTone Ampere Press 2. Desweiteren bis zu 4 (eigentlich max 8) Foot Switches für die Mute Gruppen, also auch 2 Lead Foot FS-2 wie hier schon verlinkt? Damit müsste der Controller in ein Gehäuse mit Stromversorgung und - sagen wir - Klinkenbuchsen und die Pedale dann daran angeschlossen. Das wäre die Arbeit sparen, die Fußschalter / Taster je nach Anwendung mit dem Controller im Gehäuse zu verbauen.

Ziel wäre es für mich, einen XR18 zu nutzen um Kanal 9/10 (Keyboard) mit einem Expression Pedal zu steuern und Master Volume mit einem anderen. Dazu noch nach Bedarf Mute Gruppen zu schalten, also eine kleine Erweiterung Deines ursprünglichen Gedanken, @Mathias1234

Ich hänge etwas an meinen Fähigkeiten, ein Gehäuse mit Foot Switches zu bauen (also entsprechend Aussparungen für die Schalter und ne - sagen wir USB - Buchse zur Stromversorgung zu fräsen). Ein Loch für 6,35mm Klinken traue ich mir dagegen zu ;)

Die Programmierung dafür zu erweitern ist leicht. Bei der Hardware hat's bei mir gehapert, daher denke ich mal in die Richtung und bitte um Validierung von Euch
 
  • Gefällt mir
Reaktionen: 1 Benutzer

Unser weiteres Online-Angebot:
Bassic.de · Deejayforum.de · Sequencer.de · Clavio.de · Guitarworld.de · Recording.de

Musiker-Board Logo
Zurück
Oben