DMX mit dem Kunbus Revolution Pi Core 3+ (Seite 3)

Mithilfe der Bibliothek Fcntl ließe sich das Skript so gestalten, dass es im Hintergrund den Offset ermittelt und statt des Klartextnamens verwendet. Diese aufwendige Prozedur vermeidet das vorgestellte Skript, indem es direkt die Offsets benutzt. Da diese sich im Beispiel immer um 1 erhöhen, muss man nicht alle Werte durch Ausprobieren ermitteln. Ein Codebeispiel, das die Verwendung der Klartextnamen demonstriert, findet sich auf der Kunbus-Homepage [5].

Zwei Klassen dienen dazu, die Verbindung zum RevPi (RevPi) aufzubauen und die Farbwechsel der Lampen (DMX) zu steuern. Mit dem open()-Kommando öffnen Sie eine Verbindung zum Hardwaretreiber und speichern sie in der Variablen _rev_Pi. Alle Zugriffe auf die Hardware erfolgen dann über diese Variable.

In der Klasse DMX sorgen die do_FARBE-Methoden mithilfe der Anweisung update_color() dafür, dass die entsprechende Farbe an die Lampe übermittelt wird. Die Berechnung der Farbe erfolgt in der Methode set_step(), gesteuert über die Variable mode_val. Da die Lampen nur ein recht grobes Dimmen beherrschen, werden die Werte für die einzelnen Farben immer um 16 erhöht oder verringert.

Bei zwei Leuchten und drei Farben ergeben sich sechs mögliche Farbübergänge. Daher wird die Variable mode wieder auf 1 gesetzt, sobald sie den Wert 7 erreicht. Das Kommando time.sleep(0.05) steuert die Geschwindigkeit der Farbübergänge. Die __init__-Methode der Klasse DMX setzt den Master-Dimmer auf 100 Prozent, um die Dimmer für die einzelnen Farben voll ausnutzen zu können.

Durch das Kommando while 1 läuft das Programm in einer Endlosschleife, die Sie mit [Strg]+[C] abbrechen können. Innerhalb dieser Schleife verändert der Code die Variable mode und übergibt sie an die Objekte für die zwei Lampen, wodurch eine bestimmte Farbe ein- oder ausgeblendet wird. Erreicht eine Farbe ihren neuen Wert, erhöht sich die Variable mode um 1. Um einen Farbübergang vollständig zu durchlaufen, muss man die Methode set_step() sechzehnmal aufrufen – das erledigt die zweite For-Schleife.

Sie starten das Demoprogramm mit dem Befehl python3 dmx_demo.py auf der Kommandozeile des RevPi Core. Auf Youtube finden Sie ein Video, das unser Demoprogramm in Aktion zeigt [6].

#!/usr/bin/python3
import time
import struct
DEBUG = False
DMX1_MASTER = 525
DMX1_RED = 526
DMX1_GREEN = 527
DMX1_BLUE = 528
DMX2_MASTER = 533
DMX2_RED = 534
DMX2_GREEN = 535
DMX2_BLUE = 536
class RevPi:
  _rev_pi = open('/dev/piControl0', 'wb+', 0)
  def __init__(self):
    pass
class DMX(RevPi):
  _green = 0
  _red = 255
  _blue = 0
  def __init__(self, master, adr_green, adr_red, adr_blue):
    self.adr_green = adr_green
    self.adr_red = adr_red
    self.adr_blue = adr_blue
    self._rev_pi.seek(master)
    self._rev_pi.write(struct.pack('<H', 255))
  def update_color(self, adr, val):
    self._rev_pi.seek(adr)
    self._rev_pi.write(struct.pack('<H', val))
  def set_step(self, mode_val):
    if mode_val == 1:
      self._green += 16
    elif mode_val == 2:
      self._red += -16
    elif mode_val == 3:
      self._blue += 16
    elif mode_val == 4:
      self._green += -16
    elif mode_val == 5:
      self._red += 16
    elif mode_val == 6:
      self._blue += -16
  def do_green(self):
    if DEBUG:
      print('GREEN: %d' % self._green)
    self.update_color(self.adr_green, self._green)
  def do_red(self):
    if DEBUG:
      print('RED: %d' % self._red)
    self.update_color(self.adr_red, self._red)
  def do_blue(self):
    if DEBUG:
      print('BLUE: %d' % self._blue)
    self.update_color(self.adr_blue, self._blue)
DMX_1 = DMX(DMX1_MASTER, DMX1_GREEN, DMX1_RED, DMX1_BLUE)
DMX_2 = DMX(DMX2_MASTER, DMX2_GREEN, DMX2_RED, DMX2_BLUE)
while 1:
  for mode in range(1, 7):
    if DEBUG:
      print('mode=%d' % mode)
    for i in range(0, 15):
      if DEBUG:
        print('i=%d' % i)
      DMX_1.set_step(mode)
      DMX_2.set_step(mode)
      DMX_1.do_red()
      DMX_2.do_red()
      DMX_1.do_green()
      DMX_2.do_green()
      DMX_1.do_blue()
      DMX_2.do_blue()
      time.sleep(0.05)

Fazit

Mit dem DMX-Modul für den Revolution Pi Core 3+ fällt es leicht, sich in die Materie einzuarbeiten. Ein wenig Stöbern im Internet fördert viele interessante Geräte zutage, die sich mit DMX ansteuern lassen. Neben der klassischen Bühnenbeleuchtung decken die Produkte auch Beleuchtungssysteme für die Heimautomation ab. Ein echtes Highlight unter den DMX-Geräten ist ein voll beweglicher, sprechender Totenkopf [7]. Wir wünschen Ihnen viel Spaß bei eigenen Experimenten rund um DMX. (jlu)