def main():
global SRT_FILENAME, AUDIO_FILENAME, MAX_BRIGHTNESS, TICK_TIME, DEBUG, VERBOSE
parser = argparse.ArgumentParser(description="LushRoom sound and light command-line player")
# group = parser.add_mutually_exclusive_group()
# group.add_argument("-v", "--verbose", action="store_true")
# group.add_argument("-q", "--quiet", action="store_true")
parser.add_argument("-s","--srt", default=SRT_FILENAME, help=".srt file name for lighting events")
parser.add_argument("-a","--audio", default=AUDIO_FILENAME, help="audio file for sound stream")
parser.add_argument("-b","--brightness", default=MAX_BRIGHTNESS, help="maximum brightness")
parser.add_argument("-t","--time", default=TICK_TIME, help="time between events")
args = parser.parse_args()
print('args: ', args)
print('args.srt: ', args.srt)
SRT_FILENAME = args.srt
# global ipcon
ipcon.connect(HOST, PORT)
# Register Enumerate Callback
ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE, cb_enumerate)
# Trigger Enumerate
ipcon.enumerate()
sleep(2)
if VERBOSE:
print("tfIds: ", tfIDs)
dmxcount = 0
for tf in tfIDs:
# try:
if True:
# print(len(tf[0]))
if len(tf[0])<=3: # if the device UID is 3 characters it is a bricklet
if tf[1] in deviceIDs:
print('printed tfIds: ', tf[0],tf[1], getIdentifier(tf))
if tf[1] == 285: # DMX Bricklet
if dmxcount == 0:
print("Registering %s as slave DMX device for capturing DMX frames" % tf[0])
dmx = BrickletDMX(tf[0], ipcon)
dmx.set_dmx_mode(BrickletDMX.DMX_MODE_SLAVE)
dmx.register_callback(BrickletDMX.CALLBACK_FRAME, dmxread_callback)
dmx.set_frame_callback_config(False, False, True, False)
signal.signal(signal.SIGINT, signal_handler)
dmxcount += 1
while True:
pass
class MainWindow(QMainWindow, Ui_MainWindow):
qtcb_ipcon_enumerate = pyqtSignal(str, str, 'char', type((0, )), type(
(0, )), int, int)
qtcb_ipcon_connected = pyqtSignal(int)
qtcb_frame_started = pyqtSignal()
qtcb_frame = pyqtSignal(object, int)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setupUi(self)
self.setWindowTitle('DMX Test Tool by LauerSystems')
# create and setup ipcon
self.ipcon = IPConnection()
self.ipcon.connect(HOST, PORT)
self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE,
self.qtcb_ipcon_enumerate.emit)
self.ipcon.register_callback(IPConnection.CALLBACK_CONNECTED,
self.qtcb_ipcon_connected.emit)
self.dmx = BrickletDMX(UID_DMX, self.ipcon)
self.label_image.setText("Started!")
#Configs
self.wait_for_first_read = True
self.qtcb_frame_started.connect(self.cb_frame_started)
self.qtcb_frame.connect(self.cb_frame)
self.dmx.set_dmx_mode(BrickletDMX.DMX_MODE_MASTER)
print("DMX Mode [0=Master; 1=Slave]: " + str(self.dmx.get_dmx_mode()))
self.dmx.set_frame_duration(200)
print("Frame Duration [ms]: " + str(self.dmx.get_frame_duration()))
self.address_spinboxes = []
self.address_slider = []
print("Config Ende")
for i in range(20):
spinbox = QSpinBox()
spinbox.setMinimum(0)
spinbox.setMaximum(255)
slider = QSlider(Qt.Horizontal)
slider.setMinimum(0)
slider.setMaximum(255)
spinbox.valueChanged.connect(slider.setValue)
slider.valueChanged.connect(spinbox.setValue)
def get_frame_value_changed_func(i):
return lambda x: self.frame_value_changed(i, x)
slider.valueChanged.connect(get_frame_value_changed_func(i))
self.address_table.setCellWidget(i, 0, spinbox)
self.address_table.setCellWidget(i, 1, slider)
self.address_spinboxes.append(spinbox)
self.address_slider.append(slider)
print("Erzeuge Set: " + str(i))
self.address_table.horizontalHeader().setStretchLastSection(True)
self.address_table.show()
self.current_frame = [0] * 512
print(self.current_frame)
self.dmx.register_callback(self.dmx.CALLBACK_FRAME_STARTED,
self.qtcb_frame_started.emit)
self.dmx.register_callback(self.dmx.CALLBACK_FRAME,
self.qtcb_frame.emit)
self.dmx.set_frame_callback_config(True, False, True, False)
def frame_value_changed(self, line, value):
self.current_frame[line] = value
print("Value Changed")
print(self.current_frame)
self.dmx.write_frame(self.current_frame)
#self.dmx_overview.draw_line(line, value, None, True)
def mode_changed(self, index, update=True):
if index == 0:
for spinbox in self.address_spinboxes:
spinbox.setReadOnly(False)
for slider in self.address_slider:
slider.setEnabled(True)
self.frame_duration_label.setVisible(True)
self.frame_duration_unit.setVisible(True)
self.frame_duration_spinbox.setVisible(True)
else:
for spinbox in self.address_spinboxes:
spinbox.setReadOnly(True)
for slider in self.address_slider:
slider.setEnabled(False)
self.frame_duration_label.setVisible(False)
self.frame_duration_unit.setVisible(False)
self.frame_duration_spinbox.setVisible(False)
if update:
self.dmx.set_dmx_mode(index)
def frame_duration_changed(self, value):
self.dmx.set_frame_duration(value)
def handle_new_frame(self, frame):
for i, value in enumerate(frame):
self.address_spinboxes[i].setValue(value)
self.frame_value_changed(i, value)
self.wait_for_first_read = False
def cb_get_frame_duration(self, frame_duration):
self.frame_duration_spinbox.blockSignals(True)
self.frame_duration_spinbox.setValue(frame_duration)
self.frame_duration_spinbox.blockSignals(False)
def cb_get_dmx_mode(self, mode):
self.mode_combobox.blockSignals(True)
self.mode_combobox.setCurrentIndex(mode)
self.mode_changed(mode, False)
self.mode_combobox.blockSignals(False)
if mode == self.dmx.DMX_MODE_MASTER:
self.dmx.read_frame, None, self.cb_read_frame, self.increase_error_count
def cb_read_frame(self, frame):
self.handle_new_frame(frame.frame)
def cb_frame_started(self):
if not self.wait_for_first_read:
self.dmx.write_frame, self.current_frame, None, self.increase_error_count
def cb_frame(self, frame, frame_number):
if frame == None:
return
self.handle_new_frame(frame)
def cb_ipcon_enumerate(self, uid, connected_uid, position,
hardware_version, firmware_version,
device_identifier, enumeration_type):
if self.ipcon.get_connection_state(
) != IPConnection.CONNECTION_STATE_CONNECTED:
# ignore enumerate callbacks that arrived after the connection got closed
return
def cb_ipcon_connected(self, connect_reason):
try:
self.ipcon.enumerate()
except:
pass
dmxcount = 0
for tf in tfIDs:
# try:
if True:
# print(len(tf[0]))
if len(
tf[0]
) <= 3: # if the device UID is 3 characters it is a bricklet
if tf[1] in deviceIDs:
print(tf[0], tf[1], getIdentifier(tf))
if tf[1] == 285: # DMX Bricklet
if dmxcount == 0:
print(
"Registering %s as slave DMX device for capturing DMX frames"
% tf[0])
dmx = BrickletDMX(tf[0], ipcon)
dmx.set_dmx_mode(BrickletDMX.DMX_MODE_SLAVE)
dmx.register_callback(BrickletDMX.CALLBACK_FRAME,
dmxread_callback)
dmx.set_frame_callback_config(True, True, True, True)
dmxcount += 1
while True:
pass
if tfConnect:
ipcon.disconnect()