Ansteuerung Nebelmaschine mit Raspberry Pi über Midi-Noten von Sampler

[Osher]

Hallo Leute,

ich habe mich soeben im Forum angemeldet und möchte gern einen Thread starten zum Thema Licht-/Neblersteuerung über MIDI/DMX.

Kurz zum Hintergrund der Idee:

Wir haben in unserer Band (5 köpfige Deathmetaltruppe) eine Nebelmaschine vorn mittig, welchevon mir (Gesang) per Fußschalter ausgelöst wird. Modell ist ein ADJ Fog Fury Jett Pro.
Zukünftig würde ich diesen Nebler gern automatisiert/ auf den Song genau angepasst automatisiert abspielen lassen. Perspektivisch wären dann auch weitere Spielsachen wie weitere Nebler denkbar.

Der typische Weg den ich in den Recherchen hier und in anderen Foren gefunden habe, ist über einen Laptop mit DAW-->USB/DMX-Interface-->Nebelmaschine zu gehen.
Ein Laptop kommt derzeit nicht in Frage. Wir nutzen für unsere Backingtracks/Samples einen Cymatic Audio LP 16 Sampler, welcher auch MIDI-Noten ausgeben kann.

Meine Idee ist daher die MIDI-Noten vom Cymatic (jeder Song wäre separat programmiert) kommend abspielen zu lassen, das an den Raspberry Pi zu senden, welcher es mit Hilfe von Interface(s) von MIDI auf DMX wandelt und dann an den Nebler sendet.
Die Lichtarchitektur bei Raspberry Pi wäre dann vermutlich OLA.

Ich habe bisher weder Erfahrung mit einem Raspberry oder aber OLA, d.h. die Idee ist bisher alles was ich habe. Rücksprache hab ich hierzu bereits mit Chris de Rock aus dem Forum gehalten, welcher mich ermutigt hat hier einen Thread zu eröffnen.

Da ich nicht jeden Tag Zeit habe, mich um diese Sache zu kümmern, könnte es durchaus ein paar Tage dauern, bis hier ein brauchbares Ergebnis zu Stande kommt. Am Ende würde ich mich aber riesig über ein brauchbares Ergebnis freuen und bin vor allem positiv überrascht, dass man nach Jahren des Amateur-Musizierens hier zufällig auf so ein schönes Forum trifft.

Danke schonmal für jegliche Unterstützung und beste Grüße der Osher/Epidemic Scorn

 

[SubbrSchwob]

Du kannst sicher mit QLC+ was stricken, aber ich orakle, dass es nicht problemlos headless auf einem RaspPi laufen wird.

Standalone bietet sich wohl eher etwas mit Arduino an, also „ohne Betriebssystem“, da nur eine kleine, überschaubare Aufgabe erledigt werden soll.

Hier gibt's ein Projekt, ich hab es nicht probiert: https://github.com/jmej/MIDI2DMX

Generell wäre ich an dem Thema auch interessiert, denn diverse meiner Mischpulte können per USB ebenfalls MIDI-Daten senden, die ich gerne in DMX umsetzen würde. Oft habe ich Anwendungen, wo ich nur 2 oder 4 Scheinwerfer habe, dafür lohnt sich kein großer Controller. In meinem Fall wäre ich aber auch nicht unfroh, wenn die DMX-Daten zugleich als ArtNet zur Verfügung stünden, da ich sowieso eine WLAN-basierte ArtNet-Lösung betreiben möchte. Das riecht dann aber wieder nach RaspPi von den Anforderungen her.

 

[chrisderock]

Fangen wir erstmal bei den theoretischen Grundlagen an:

• Bei MIDI haben alle Werte einen Umfang von 0 bis 127, bei DMX jedoch von 1-512. Das muss also übersetzt werden.
• Meiner Meinung nach bietet sich für solche Anwendung die Nutzung von MIDI-Noten an denn:
  • Eine Note und damit ein DMX-Kanal kann angeschaltet werden (NoteOn)
  • Eine Note und damit ein DMX-Kanal kann ausgeschaltet werden (NoteOff)
  • Eine Note beinhaltet die Velocity (Lautstärke) deren Wert man für den Wert des DMX-Kanals nehmen kann. Da auch die Velocity nur Werte von 0 - 127 haben kann, ein DMX-Kanal jedoch Werte von 0-155 verdoppeln wir hier einfach den Wert der Velocity. Das macht die Sache weniger genau aber für diesen Zweck sollte es ausreichen.
• Jetzt fällt dem geneigten Leser eventuell auf dass es ja auch nur 128 Noten gibt (0-127) und man so nicht das komplette DMX-Universum ansprechen kann. Aber MIDI kennt ja auch noch verschiedene Kanäle. So können wir die Noten der MIDI-Kanäle 1-4 nutzen und kommen auf unsere 512 Noten

Was nehmen wir für die möglichst einfache und simple Umsetzung? Ich hab mich für die Programmiersprache Python[1] und die Module Mido[2] und ola[3] entschieden damit die Sache nicht zu unübersichtlich wird.

Erst einmal lesen wir MIDI-Noten:

#!/usr/bin/python3
""" simply convert from MIDI to DMX"""
import mido
def run_dmx():
    """wait for new MIDI messages"""
    with mido.open_input('Midi Through:Midi Through Port-0 14:0') as port:
        for message in port:
            process_midi_input(message)

Ich öffne also einen bestimmten Eingangskanal (hier den Midi Through:Midi Through Port-0 14:0) und warte auf MIDI Nachrichten.


[1] https://www.python.org/
[2] https://mido.readthedocs.io/en/latest/
[3] https://github.com/OpenLightingProject/ola/tree/master/python/ola

Beitrag automatisch zusammengefügt: 10.01.23

Im obigen Beispiel lese ich also die eingehenden Nachrichten und rufe dann die Funktion "process_midi_input" zur Verarbeitung auf. Schauen wir uns das mal an:

#!/usr/bin/python3
""" simply convert from MIDI to DMX"""
import array
import mido

DATA = None

def process_midi_input(msg):
    """converts the midi note events to dmx"""
    global DATA
    if msg.type != 'note_on' and msg.type != 'note_off':
        return
    if msg.channel < 0 or msg.channel > 3:
        return
    print(msg)
    if msg.type == 'note_on':
        DATA[msg.note + (msg.channel * 128)] = msg.velocity*2
    else:
        DATA[msg.note + (msg.channel * 128)] = 0
    print(DATA)
def run_dmx():
    """wait for new MIDI messages"""
    with mido.open_input('Midi Through:Midi Through Port-0 14:0') as port:
        for message in port:
            process_midi_input(message)
if __name__ == '__main__':
    DATA = array.array('B',[0]*255)
    run_dmx()

Ich definiere also meinen Datenblock "DATA" der nur 512 mal den Wert 0 enthält, also ein ganzes DMX-Universum. In der Funktion selbst prüfe ich lediglich ob eine eingehende Nachricht das ist was ich haben will und setze die Werte in DATA wie oben beschrieben. Jetzt können wir schon mal MIDI lesen und verarbeiten. Als nächstes schauen wir uns das Senden von DMX mit OLA an.

Beitrag automatisch zusammengefügt: 10.01.23

In meinem Fall wäre ich aber auch nicht unfroh, wenn die DMX-Daten zugleich als ArtNet zur Verfügung stünden

Das von mir verwendete OLA ist problemlos mit Artnet nutzbar, also dran bleiben.

So, versuchen wir mal DMX zu senden.

#!/usr/bin/python3
""" simply convert from MIDI to DMX"""
import array
from ola.ClientWrapper import ClientWrapper
from ola.OlaClient import OlaClient

WRAPPER = None
DATA = None
TICK_INTERVAL = 1000 # 1 second

def dmx_sent(state):
    """just prints the state of the dmx and closes
    the sender on error"""
    global WRAPPER
    if not state.Succeeded():
        print(state.message)
        WRAPPER.Stop()
def send_dmx():
    """sends the current values to dmx out"""
    global WRAPPER
    global DATA
    global TICK_INTERVAL
    WRAPPER.AddEvent(TICK_INTERVAL, send_dmx)
    WRAPPER.Client().SendDmx(0, DATA, dmx_sent)
def start_dmx():
    """setup the dmx output"""
    global WRAPPER
    WRAPPER = ClientWrapper()
    WRAPPER.Client().PatchPort(2, 0, True, OlaClient.PATCH, 0, dmx_sent)
    WRAPPER.AddEvent(TICK_INTERVAL, send_dmx)
    WRAPPER.Run()

In der Funktion "start_dmx" erstellen wir den eigentlichen Sender der unsere Daten auf die Leitung schickt. Danach patchen wir ein DMX-Universum auf ein Gerät. Dieses Gerät kann ein normaler USB-DMX Dongle oder eben auch Artnet sein. Als nächstes weisen wir den Sender an nach Ablauf von TICK_INTERVAL die Funktion "send_dmx" aufzurufen. Diese erstellt als erstes wieder einen solchen Event damit sie regelmässig aufgerufen wird und schickt danach unsere Daten an das konfigurierte Universum. Falls irgend etwas daran fehlschlägt wird über die oberste Funktion "dmx_sent" das Senden von Daten beendet.

 

[Osher]

Ich danke euch schonmal für die schnellen Ideenansätze!
@SubbrSchwob den Ansatz mit dem Arduino hatte ich auch schon gefunden, aber mir nicht zugetraut das anzugehen. Mein Motto ist auch je einfacher desto besser, Hauptsache es funktioniert
@chrisderock bisher habe ich tatsächlich alles verstanden, was du geschrieben hast, obwohl ich absolut keine Ahnung vom programmieren habe.
Welcher Raspi wäre egal oder? bühnentauglich wäre vermutlich dann mal ein Gerät mit Gehäuse rundherum, wo man nur noch die Anschlüsse außen hat oder?
Wie sieht es aus bezüglich Interface(s)? Könnte man alles zusammen (RasPi+Interface) in ein Gehäuse bauen, um evtl. Getränkeunfällen/Verschmutzungen etc. vorzubeugen?

 

[chrisderock]

Welcher Raspi wäre egal oder? bühnentauglich wäre vermutlich dann mal ein Gerät mit Gehäuse rundherum, wo man nur noch die Anschlüsse außen hat oder?

Meiner Meinung nach sollte eigentlich jeder RasPi zu gebrauchen sein da die benötigte Leistung nicht so hoch sein dürfte. Ein Gehäuse, notfalls auch für RasPi und Dongle zusammen lässt sich prima mit einem 3D-Drucker herstellen.

Beitrag automatisch zusammengefügt: 10.01.23

Ein kleiner Ausflug zu den von mir genutzten MIDI- und DMX-Ports/Devices/Anschlüssen. Wie bekommt man die jetzt raus? Bei Mido sind ein paar Beispielprogramme dabei die einem eine kleine Liste von Ports ausgeben: https://github.com/mido/mido/blob/main/bin/mido-ports
Auch für OLA gibt es ein Beispiel das einem die verfügbaren Geräte und Ports ausgibt: https://github.com/OpenLightingProject/ola/blob/master/python/examples/ola_devices.py

So, jetzt haben wir zwei kleine Programme. Eins empfängt MIDI unt tut damit Dinge, das andere sendet DMX. Wir haben jetzt nur zwei kleine Probleme:

• Jedes dieser Programme ist eigentlich vollständig und dauernd mit seiner Aufgabe beschäftigt. Also entweder Empfangen oder Senden.
• Die beiden Programme greifen auf die selben Daten (DATA) zu. Eins schreibt rein, das andere liest. Das könnte schiefgehen wenns zeitgleich versucht wird.

Die Lösung für beide Probleme: Posix Threads[1]. Damit können wir sozusagen beide Programme parallel innerhalb eines Programms ausführen, haben gemeinsame Daten und haben Unterstützung für Mutexe/Locks mit denen wir den Zugriff auf gemeinsame Daten regeln können. Werfen wir jetzt alles in einen Topf und rühren gut um kommt folgendes raus:

#!/usr/bin/python3
""" simply convert from MIDI to DMX"""
import array
import threading
import mido
from ola.ClientWrapper import ClientWrapper
from ola.OlaClient import OlaClient

WRAPPER = None
DATA = None
TICK_INTERVAL = 1000
LOCK = threading.Lock()

def dmx_sent(state):
    """just prints the state of the dmx and closes
    the sender on error"""
    global WRAPPER
    if not state.Succeeded():
        print(state.message)
        WRAPPER.Stop()
def send_dmx():
    """sends the current values to dmx out"""
    global WRAPPER
    global DATA
    global TICK_INTERVAL
    global LOCK
    LOCK.acquire()
    WRAPPER.AddEvent(TICK_INTERVAL, send_dmx)
    WRAPPER.Client().SendDmx(0, DATA, dmx_sent)
    LOCK.release()
def start_dmx():
    """setup the dmx output"""
    global WRAPPER
    WRAPPER = ClientWrapper()
    WRAPPER.Client().PatchPort(2, 0, True, OlaClient.PATCH, 0, dmx_sent)
    WRAPPER.AddEvent(TICK_INTERVAL, send_dmx)
    WRAPPER.Run()
def process_midi_input(msg):
    """converts the midi note events to dmx"""
    global LOCK
    global DATA
    if msg.type != 'note_on' and msg.type != 'note_off':
        return
    if msg.channel < 0 or msg.channel > 3:
        return
    print(msg)
    LOCK.acquire()
    if msg.type == 'note_on':
        DATA[msg.note + (msg.channel * 128)] = msg.velocity*2
    else:
        DATA[msg.note + (msg.channel * 128)] = 0
    print(DATA)
    LOCK.release()
def run_dmx():
    """wait for new MIDI messages"""
    with mido.open_input('Midi Through:Midi Through Port-0 14:0') as port:
        for message in port:
            process_midi_input(message)
if __name__ == '__main__':
    DATA = array.array('B',[0]*255)
    tid = threading.Thread(group=None, target=start_dmx, daemon=True)
    tid.start()
    run_dmx()

Wie man sehen kann nutze ich die neue Variable LOCK. Diese wird angefordert und freigegeben. Sollte sie beim Anfordern bereits von jemand anderem belegt sein wartet meine Funktion automatisch bis sie wieder freigegeben ist. So ist sichergestellt dass immer nur einer auf die Daten zugreift.

Eigentlich ist das Progrämmchen jetzt fertig. Nur die entsprechenden Ports/Devices angeben und laufen lassen.

[1] https://de.wikipedia.org/wiki/Thread_(Informatik)

 

[MatzeRockt]

Hallo,
gibt es fix und fertig in einer Kiste:

Decabox Midi to DMX Bridge

Ich habe zur Not so ein Ding noch rumliegen.

Grüße

 

[Osher]

@chrisderock ist ja echt Einiges zu Beachten aber cool, dass du das schon so detailliert hier reingeschrieben hast. Ich bestell mir jetzt erstmal nen Pi3 zum Testen.
@MatzeRockt ich hab echt ne ganze Weile per Google gesucht und dabei bin ich nie auf dieses Teil gestoßen.

 

[chrisderock]

gibt es fix und fertig in einer Kiste:

Witzig. Das macht wirklich das selbe (eben nur auf einem MIDI-Kanal statt auf vieren)

 

[Osher]

Wenn ich das richtig verstehe, sollte es damit ja tatsächlich möglich sein den Nebler (perspektivisch weitere Nebler) an seiner Adresse anzusprechen und dann auch die mehreren Kanälen (mit Wert 0 bis 255) jeweils zu nutzen, richtig?

 

[chrisderock]

Nebler und einfache Pars sind kein Problem. Für Moving Heads ist das aber nichts.

 

[MatzeRockt]

Ja,
ein auswählbarer Midi-Kanal (128 Noten --> 128DMX-Kanäle) mit 128 Schritten (zwischen 0 und 255 interpoliert, oder aufgedoppelt - nenn es wie du willst.) - von daher nur für grobe Sachen geeignet.

Grüße

Hier ist noch eine Kiste die das können sollte:

https://www.chd-el.cz/products/midi-dmx-converter-56/

 

[SubbrSchwob]

Es gibt auch noch http://www.midi2dmx.pl - aber da ist die Software noch für Win XP und auch sonst sieht das tot aus.

Der Vorteil beim RaspPi ist natürlich, dass man – solange der I/O nur via USB stattfindet – das ganze auch auf einem PC testen kann. Ein PiZero könnte schnell genug sein. Der Nachteil ist der große Overhead… ein ganzes, großes Betriebssystem, nur für eine Multiplikation mit 2 und ein bisschen Protokollschubsen.

Bei einem hypothetischen midi2ArtNet sieht das dann wieder leicht anders gelagert aus, da der „normale” RaspPi den nötigen Netzwerkport mitbringt und Linux als Betriebssystem das ganze TCP/IP- bzw. UDP-Gedönse.

Der ursprünglich von mir entwickelte Netzwerk-Fußschalter für die Allen&Heath Qu-Serie, leider dank Firmware-Update nicht mehr so recht kompatibel, benutzte einen Trick, um in Python im Java-Style „synchronized“ arbeiten zu können, das löst dann das Concurrent Access Problem. Das Projekt schläft seit 2016 hier: https://github.com/chriszuercher/quPy

Eine andere Idee: Ziemlich sweet wäre es, ein midi2Artnet als Erweiterung zu OpenWRT zu hacken. Etliche OpenWRT-Router haben einen USB-Port (Host), an den könnte man ein USB-MIDI-Interface oder ein Digitalmischpult (Client) hängen. Die Daten könnten im Router direkt in ArtNet konvertiert und rausgeblasen werden und mit einem ArtNet-Node wie dem air2dmx dann wieder eingefangen werden. Tatsächlich existiert für OpenWRT eine Artnet-Bibliothek.

 

[SB]

Ich hab jetzt die Machbarkeit noch nicht im Detail geprüft und denk einfach mal laut...

Tuts eventuell nicht wirklich ein Arduino? Man müsste aber wohl zumindest einen Mega2560 nehmen wegen der vier UARTs. Zwar reicht theoretisch ja 1x RX für MIDI und 1x TX für DMX, aber ich denke nicht, dass man auf der selben Schnittstelle sendend und empfangend verschiedene Baudraten fahren kann, zumal durch die die entsprechenden Bibliotheken ja die Schnittstellenparameter entsprechend gesetzt werden.

Fürs DMX habe ich in den letzten Projekten, egal ob DMX gesendet oder empfangen werden soll, die Bibliothek von Deskontrol.net genommen. Da taucht das Projekt aber nicht mehr auf, hier gibts aber noch eine Kopie davon:
https://github.com/daniel3514/DMX-512-Tricks/tree/master/Projets/Arduino four universes DMX 512 library

Ich habe die Lib aber anpassen müssen, da sich anscheinend in irgendeiner Arduino-Version die UART-Bezeichnungen geändert haben. Ansonsten klappt das aber sehr gut und ich kann alle 512 Kanalbytes schön als Array übergeben bzw. abholen.

Hardwaremäßig ist das nicht tragisch, im Prinzip reicht zum Senden ein MAX485 oder SN75176 ohne Randbeschaltung.

MIDI per Arduino hab ich noch nie probiert, gibt aber ein paar recht vielversprechende Anleitungen, z.B.
https://www.instructables.com/Send-and-Receive-MIDI-with-Arduino/

Aus meiner Sicht sollte also eine recht einfach gehaltene Funktionalität hardgecoded im Stil "Wenn Note X den Wert Y hat, setze DMX-Kanal Z auf 255" kein Thema sein. Oder übersehe ich etwas gravierendes? Gefühlt kommt mir ein RasPi für einfachste Schnittstellenkonversion schon sehr oversized vor. In puncto Zeitaufwand für die Grundeinrichtung und auch späterer Startzeit ist ein kleiner Mikrocontroller auch was anderes als ein im Prinzip vollwertiger PC.

Das ist aber - um mal kurz OT zu werden - ein Trend, den ich immer mehr bemerke. Die Bootzeit scheint den Entwicklern teilweise völlig egal zu sein, selbst bei Geräten, wo es schon mal sein kann, dass unterm Betrieb der Strom ausfällt und ein schneller Start danach aber eigentlich schon gut wäre. Oft liegt das vermutlich an einer Standard-Softwareplattform, die für den vorgesehenen Zweck eben völlig überfrachtet ist. Da braucht man im Audiobereich nur mal ein Soundcraft Si mit einem X32 vergleichen. Letzteres ist nach gleichzeitiger Spannungswiederkehr gefühlt schneller wieder am Start, als so mancher Amp aus dem Protect rausschaltet, während man bei ersterem noch gemütlich ein Bier holen gehen kann, um es zurück am FOH dann trotzdem im Zustand "Startup: 89% complete" wiederzufinden...
Irgendwie kriegt der Uli also was hin, was die Jungs bei Harman scheinbar vor unüberwindbare Hürden gestellt hat (oder, wie ich eher vermute: man hat halt einfach drauf ..., der Kunde kaufts ja eh). Paradoxerweise ist dann die softwaremäßig effizientere Kiste auch noch die mit dem deutlich (!) größeren Funktionsumfang...

Back2topic, Thema Fertiglösungen:
Die ganzen alten, rustikalen 12/24er Scenesetter aus Zeiten des konventionellen Lichts, die unter zig Labels nahezu baugleich unterwegs waren und teilweise noch sind (Botex, Eurolite, Showtec, American DJ, Work, lightmaxx und wie sie alle heißen...) hatten i.d.R. auch einen MIDI-Eingang. Was damit tatsächlich möglich ist, müsste man mal anhand der BDA gegenchecken. Vermutlich können einzelne Szenen angetriggert werden. Gerade wenn du auf Seiten des MIDI-Ausgabegeräts relativ flexibel hinsichtlich des Befehlssatzes bist und ja DMX-seitig nur ein einziges Gerät gesteuert werden muss, sollte das durchaus machbar sein. Oft kann man die Dinger ja für maximal nen Fuffi irgendwo gebraucht abgreifen, das dürfte doch deutlich weniger sein als die Fertiglösung mit dem Konverterkästchen und natürlich auch weniger zeitaufwendig als eine komplette Eigenbaulösung.

Mir stellt sich gerade noch eine andere Frage: Du baust DMX-mäßig ja eine reine Insellösung zwischen deinem wie auch immer gearteten Interface und der Nebelmaschine, richtig? Es sollen also momentan keine anderen Geräte gesteuert werden? Muss es denn dann überhaupt DMX sein? Was ist das genau für ein Nebler? Wenn der z.B. eine 5pol DIN-Buchse für eine Kabelfernbedienung hat, tut es im ersten Schritt evtl. auch ein simpler Schließerkontakt, wenn man die Belegung kennt. Dann müsste man sich nur um die MIDI-Auswertung kümmern und nicht noch ums Generieren des DMX-Signals. Ein simpler Schaltausgang ist ja auf allen Plattformen problemlos zu realisieren.

 

[Osher]

@SB vielen Dank auch für deinen Input!
Das ist für mich nach wie vor alles sehr viel Theorie mit auf meiner Seite weiterhin vergleichsweise wenig Wissen diesbezüglich.

Der Nebler ist ein ADF Fog Fury Jett Pro (der kräftige von beiden). Zunächst geht es darum diesen mittels Cymatic LP 16 per MIDI anzusteuern. Perspektivisch könnten wir uns aber auch noch 1-2 weitere Nebler und ggf. 2 LED-Bars vorstellen. Deswegen wäre natürlich eine Lösung schön, die man dann später "ausbauen" könnte. Erstmal soll es aber überhaupt funktionieren mit dem Nebler und einer, je Song angepassten, ablaufenden Midi-Spur.

 

[deltapirat]

Ich stand vor Jahren vor dem gleichen Problem, ich wollte zu meinen Backtracks (utrack24) per Midi Signale DMX Signale an bestiimmte Lampen/Nebler usw senden und unsere Kemper Amps umschalten. Hat mich bestimmt 2 Jahre Zeit gekostet, aber das Endprodukt lief zuverlässig und zufriedenstellend auf einem Raspberry PI 3 mit dem vorgefertigten QLC+ Layout und meinem qlc showfile.
Das Setup sah so aus:
utrack24 sendet Backtracks (Klicks usw...) und parallel vorher erstellte MIDI Signale, die gehen dann in den Kemper AMP (Profile umschalten) und in den Raspi per USB Midi. Auf dem läuft QLC+ und per Netzwerk ist ein Mini 4port Art Net Node angeschlossen, die DMX Kabel gehen zu den Lampen, und nun schaltet und waltet alles so wie es soll.

Die Midi Spuren hab ich mit Reaper erstellt. IRgendwo hier im Forum habe ich auch mal eine detailierte Beschreibung verfasst. Wenn dazu Fragen sind, gerne melden.

Die Firma Cymatic Audio gibt es ja anscheinend nicht mehr, wer weiß, wie lange die utracks und LP16´s noch funktionieren... Eine Alternative hab ich bisher noch nicht gefunden. Es gib ja zB den Wolfsmix (https://www.thomann.de/de/wolfmix_w1.htm), der hat aber kein Midi IN. Dann gibts den hier https://www.thomann.de/de/m_live_b.beat_128gb.htm aber da hab ich keine Erfahrungen zu und hab mich nicht rangetraut. Ich find meine Bastel-Idee mit dem Raspi auch gut und es läuft halt.

 

[Osher]

Hallo @deltapirat danke dir für deinen Input. Ich habe die letzten 2 Wochen das ganze Thema aufgrund Urlaub und Zeitmangel etwas ruhen lassen, werde es aber in den nächsten Wochen angehen.
Gerade das Erstellen der MIDI-Spuren auf Reaper (nutze ich auch für meine Gesangsaufnahmen) wird ja dann bald ein Thema sein und ich werde ggf. darauf zurückkommen

Beste Grüße Osher

 

[Osher]

Um mal ein kleines Update zu geben:

Ich habe den Raspi mittlerweile in Betrieb genommen, testweise ein Midi-Keyboard angeschlossen.
Bei der Verfahrensweise Terminal-Programmierung/Python usw. hat mir der @chrisderock entscheidend geholfen.

Als Nächstes werden wir uns den Nebler und 2 LED-Bars vornehmen. Zunächst werde wir versuchen sie mit dem Keyboard anzusteuern, bevor es später an das Erstellen der MIDI-Spuren für den Sampler geht.

 

[Osher]

Hallo Leute,

mittlerweile habe ich das Ganze am Laufen Dank Hilfe von @chrisderock und @deltapirat.
Am vergangenen Samstag wurde das Ganze System inkl. 3 Nebler sowie den beiden LED-Bars mit relativ simplen, aber für unsere Zwecke ausreichenden Befehlen live getestet und es kam sehr gut rüber.
Mittels Raspi 3, QLC+ und Cymatic Audio LP16 läuft das Ganze nun stabil und ich freue mich auf unsere nächsten Auftritte.

Auf dem Bild leuchtet natürlich noch diverse Lichttechnik vom Club zusätzlich.

 

[SubbrSchwob]

Noch eine andere Lösung, die ich just vorgestern entdeckt habe: MidiMonster. Das ist was für Nerds. Um damit MIDI CC in ArtNet umzuwandeln, was mit jedem beliebigen ArtNet-Node in DMX gewandelt werden kann, reicht unter Linux diese kleine Config-Datei:

[midi alsamidi]

[backend artnet]
bind = 0.0.0.0

[artnet out]
destination = 255.255.255.255
universe = 0

[map]
alsamidi.ch0.cc{0..127} > out.{1..128}

Damit ist das von mir im obigen alten Post herbeigewünschte midi2artnet Wirklichkeit geworden.

 

[SubbrSchwob]

Leider vergessen, daher Nachtrag: Um midi2artnet mit MIDI-Noten statt CC zu machen, gälte folgende Zeile:

fromalsa.ch0.note{0..127} > out.{1..128}

Das würde die Noten 0 bis 127 auf DMX-Kanäle 1 bis 128 rausgeben, mit der Velocity als Helligkeit.