def start_wrapper(): global wrapper global client wrapper = ClientWrapper() client = wrapper.Client() wrapper.AddEvent(0, main_loop) wrapper.Run()
def main(): atexit.register(killall) args = parse_args() setup_logging(args) # read tool config config = DFSConfig() # setup show show = Show(config, args.show_name) if not show: print('no such show %s', args.show_name) sys.exit(1) # setup stage stage = Stage(show, args.stage_name) if not stage: print('could not load or create stage %s', args.stage_name) sys.exit(1) # setup joystick joy = xbox.Joystick(debug=args.debug, config=config.joystick) if args.check_mode: sys.exit(0) handler = DmxHandler(config, show, stage, joy) # setup data handler, this is our callback loop # as DMX data comes in constantly wrapper = ClientWrapper() rx = wrapper.Client() rx.RegisterUniverse(config.input.universe, rx.REGISTER, handler.handle) wrapper.Run()
def processOLA(flag): global wrapper global universe global data wrapper = ClientWrapper() client = wrapper.Client() if (flag == 1): data = [] data = array.array('B') data.append(125) #Intencity data.append(255) #R data.append(255) #G data.append(255) #B print(data) ledON = 0 while (ledON < 10): # 10 == 10 SECONDS """ # THIS IS THE AMOUNT OF TIME WE SHOULD WAIT WHEN WE GET MOTION # THIS VALUE WILL BE THE VALUE THE LIGHT SHOULD REMAIN ON AFTER # MOTION HAS BEEN DETECTED. """ sleep(1) client.SendDmx(universe, data, DmxSent) wrapper.Run() ledON += 1 return return
def rec(ar): if ar.dev: serial_device = Serial(ar.dev, 115200, timeout=1) else: serial_device = Serial(detect_serial_device(), 115200, timeout=1) clip_name = ar.clip if not clip_name.endswith('.clip'): clip_name += '.clip' clip = open(os.path.join(CLIPS_DIR, clip_name), 'w') def dmxdata(data): global last if last == 0: td = 0 else: td = int((datetime.now() - last).total_seconds() * 1000) last = datetime.now() pickle.dump({'td': td, 'frm': data}, clip) send(data, serial_device) universe = 1 try: wrapper = ClientWrapper() except OLADNotRunningException: print("Start olad first") sys.exit(1) client = wrapper.Client() client.RegisterUniverse(universe, client.REGISTER, dmxdata) wrapper.Run()
def main(): try: opts, args = getopt.getopt(sys.argv[1:], "hp:", ["help", "plugin="]) except getopt.GetoptError as err: print(str(err)) Usage() sys.exit(2) plugin = None for o, a in opts: if o in ("-h", "--help"): Usage() sys.exit() elif o in ("-p", "--plugin"): plugin = int(a) global wrapper wrapper = ClientWrapper() client = wrapper.Client() if plugin is not None: client.PluginDescription(PluginDescription, plugin) else: client.FetchPlugins(Plugins) wrapper.Run()
class OlaThread(threading.Thread): def __init__(self): threading.Thread.__init__(self) self.data = None def run(self): def onData(data): # TODO check on status before assigning data self.data = data #print(data) self.wrapper = ClientWrapper() self.client = self.wrapper.Client() universe = 1 self.client.RegisterUniverse(universe, self.client.REGISTER, onData) print('running thread') self.wrapper.Run() def exit(self): try: self.wrapper.Terminate() except: self.wrapper.Stop() def getData(self): # return or print? print(self.data)
def testSend(self): """tests that data goes out on the wire with SendDMX""" sockets = socket.socketpair() wrapper = ClientWrapper(sockets[0]) class results: gotdata = False def DataCallback(self): data = sockets[1].recv(4096) expected = binascii.unhexlify( "7d000010080110001a0d557064617465446d784461746122680801126400000" "000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000000000000" "000000") self.assertEqual(data, expected, msg="Regression check failed. If protocol change " "was intended set expected to: " + str(binascii.hexlify(data))) results.gotdata = True wrapper.AddEvent(0, wrapper.Stop) wrapper._ss.AddReadDescriptor(sockets[1], lambda: DataCallback(self)) self.assertTrue(wrapper.Client().SendDmx(1, array.array('B', [0] * 100), None)) wrapper.Run() self.assertTrue(results.gotdata)
def main(): def Plugins(state, plugins): for plugin in plugins: print('%d %s' % (plugin.id, plugin.name)) wrapper.Stop() def PluginDescription(state, description): print(description) wrapper.Stop() try: opts, args = getopt.getopt(sys.argv[1:], "hp:", ["help", "plugin="]) except getopt.GetoptError as err: print(str(err)) Usage() sys.exit(2) plugin = None for o, a in opts: if o in ("-h", "--help"): Usage() sys.exit() elif o in ("-p", "--plugin"): plugin = int(a) wrapper = ClientWrapper() client = wrapper.Client() if plugin is not None: client.PluginDescription(PluginDescription, plugin) else: client.FetchPlugins(Plugins) wrapper.Run()
class DmxControlThread(threading.Thread): def __init__(self, name, ola_universe, dmx_state, interface_fs=30): threading.Thread.__init__(self) self.daemon = True self.name = name self.ola_universe = ola_universe self.dmx_state = dmx_state self.tick_interval = 1000./interface_fs def DmxSent(self, state): if not state.Succeeded(): print 'DMX ERROR, NOT SUCCEEDED.' self.wrapper.Stop() def send_DMX(self): self.wrapper.AddEvent(self.tick_interval, self.send_DMX) new_state, modified = self.dmx_state.get() if modified: self.wrapper.Client().SendDmx(self.ola_universe, new_state, self.DmxSent) def close(self): print 'thread close' self.wrapper.Stop() def run(self): print 'starting DMX control thread' atexit.register(self.close) self.wrapper = ClientWrapper() self.wrapper.AddEvent(self.tick_interval, self.send_DMX) self.wrapper.Run()
class DMXServerThread(threading.Thread): wrapper = None TICK_INTERVAL = 1 # in ms SPEED = 3 # speed multiplier targetValues = [0, 0, 0, 0, 0, 0, 0, 0, 0] currentValues = [0, 0, 0, 0, 0, 0, 0, 0, 0] def __init__(self): print "DMXServerThread Init" threading.Thread.__init__(self) self.wrapper = ClientWrapper() def DmxSent(self, state): if not state.Succeeded(): print "DMX Sending Failed for some reason" self.wrapper.Stop() def SendDMXFrame(self): # continuously schedule the next function call self.wrapper.AddEvent(self.TICK_INTERVAL, self.SendDMXFrame) # if current values are within range of target, set to target; prevent target oscillation for i, v in enumerate(self.currentValues): diff = abs(self.targetValues[i] - v) if diff > 0 and diff <= self.SPEED: #print "Forcing channel %s to %s" % (i, v) self.currentValues[i] = v # Don't flood the dmx controller with unnecessary messages if self.currentValues == self.targetValues: return # compute next current value for each channel & add to frame data = array.array('B') for i, v in enumerate(self.targetValues): newVal = self.currentValues[i] + (cmp( self.targetValues[i] - self.currentValues[i], 0) * self.SPEED) #print newVal if (newVal > 255): newVal = 255 if (newVal < 0): newVal = 0 self.currentValues[i] = newVal data.append(self.currentValues[i]) self.wrapper.Client().SendDmx(1, data, self.DmxSent) def setTargets(self, _targetValues={}): for k, v in _targetValues.iteritems(): if not isinstance(k, int) or k > 10: print "Target channel is not an int or is out of range" return self.targetValues[k] = v def stop(self): self.wrapper.Stop() def run(self): self.wrapper.AddEvent(self.TICK_INTERVAL, self.SendDMXFrame) self.wrapper.Run()
def senddmx(data_in): universe = 1 global wrapper wrapper = ClientWrapper() client = wrapper.Client() # send 1 dmx frame with values for channels 1-6 client.SendDmx(universe, data_in, dmxsent) wrapper.Run()
def run_strip_animation(): wrapper = ClientWrapper() controller = SimpleFadeController(UPDATE_INTERVAL, wrapper) wrapper.AddEvent(SHUTDOWN_INTERVAL, wrapper.Stop) wrapper.Run() # Clears the variables, to prevent scope pollution. wrapper = None controller = None
def patch(self): global rgb, brightness, strobe cache = self.hash() parser = reqparse.RequestParser() parser.add_argument('rgb', type=unicode, location='json') parser.add_argument('strobe', type=int, location='json') parser.add_argument('brightness', type=int, location='json') # Parse the arguments into an object args = parser.parse_args() if args['rgb'] is not None: if not re.search(r'^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$', args['rgb']): return {'error': 'Invalid hex string'}, 400 rgb = args['rgb'] if args['brightness'] is not None: if args['brightness'] < 0 or args['brightness'] > 255: return {'error': 'Invalid brightness value'}, 400 brightness = args['brightness'] if args['strobe'] is not None: if args['strobe'] < 0 or args['strobe'] > 240: return {'error': 'Invalid strobe value'}, 400 strobe = args['strobe'] hex = rgb.lstrip('#') rgb_parts = tuple(int(hex[i:i + 2], 16) for i in (0, 2, 4)) data = array.array( 'B', [ rgb_parts[0], # red rgb_parts[1], # green rgb_parts[2], # blue 0, # color macros strobe + 15, # strobing/program speed 0, # programs brightness # master dimmer ]) global wrapper wrapper = ClientWrapper() client = wrapper.Client() client.SendDmx(1, data, dmx_sent) wrapper.Run() # If the state has changed, publish a state-change event. if cache != self.hash(): self.service.publish( 'device-state-changed.{}'.format(self.identifier), self.to_json()) return self.to_json(), 200
def main(): args = ParseArgs() universe = args.universe global wrapper wrapper = ClientWrapper() client = wrapper.Client() client.GetCandidatePorts(GetCandidatePortsCallback, universe) wrapper.Run()
def main(): # Set this appropriately device_alias = 1 global wrapper wrapper = ClientWrapper() client = wrapper.Client() artnet_request = ArtNetConfigMessages_pb2.Request() artnet_request.type = artnet_request.ARTNET_OPTIONS_REQUEST client.ConfigureDevice(device_alias, artnet_request.SerializeToString(), ArtNetConfigureReply) wrapper.Run()
def run(self, Universe, Count): global wrapper wrapper = None wrapper = ClientWrapper() self.client = wrapper.Client() while self._RunOK: Stride() self.client.SendDmx(Universe, DMXData, DmxSent) wrapper.Run() # send 1 dmx frame # print(DMXData[:50]) time.sleep(StrideLength)
def DMXSend(inputData, universe=1): """ Sends inputData via DMX """ data = array.array('B') for i in inputData: data.append(i) global dmxWrapper dmxWrapper = ClientWrapper() dmxClient = dmxWrapper.Client() dmxClient.SendDmx(universe, data, DMXSent) dmxWrapper.Run()
def squid(dmxrngs, delta_t): global rngs rngs = dmxrngs global tick_interval tick_interval = delta_t global wrapper wrapper = ClientWrapper() wrapper.AddEvent(22, SendDMXFrame) wrapper.Run()
def patch(self): global rgb global brightness global strobe parser = reqparse.RequestParser() parser.add_argument('rgb', type=unicode) parser.add_argument('strobe', type=int) parser.add_argument('brightness', type=int) # Parse the arguments into an object args = parser.parse_args() if args['rgb'] is not None: if not re.search(r'^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$', args['rgb']): return {'error': 'Invalid hex string'}, 400 rgb = args['rgb'] if args['brightness'] is not None: if args['brightness'] < 0 or args['brightness'] > 255: return {'error': 'Invalid brightness value'}, 400 brightness = args['brightness'] if args['strobe'] is not None: if args['strobe'] < 0 or args['strobe'] > 240: return {'error': 'Invalid strobe value'}, 400 strobe = args['strobe'] hex = rgb.lstrip('#') rgb_parts = tuple(int(hex[i:i + 2], 16) for i in (0, 2, 4)) data = array.array( 'B', [ rgb_parts[0], # red rgb_parts[1], # green rgb_parts[2], # blue 0, # color macros strobe + 15, # strobing/program speed 0, # programs brightness # master dimmer ]) global wrapper wrapper = ClientWrapper() client = wrapper.Client() client.SendDmx(1, data, dmx_sent) wrapper.Run() return self.to_json(), 200
def olaThread(adc, dest): try: opts, args = getopt.getopt(sys.argv[1:], "hu:", ["help", "universe="]) except getopt.GetoptError as err: print(str(err)) Usage() sys.exit(2) universe = 0 wrapper = ClientWrapper() client = wrapper.Client() client.RegisterUniverse(universe, client.REGISTER, NewData) wrapper.Run()
def senddmx(rgb_in): universe = 1 data = array.array('B') # first fixture data.append(rgb_in['rot']) # channel 1 rot data.append(rgb_in['gruen']) # channel 2 gruen data.append(rgb_in['blau']) # channel 3 blau data.append(0) # channel 4 weiss data.append(255) # channel 5 dimmer data.append(0) # channel 6 strobe # second fixture data.append(rgb_in['rot']) # channel 7 rot data.append(rgb_in['gruen']) # channel 8 gruen data.append(rgb_in['blau']) # channel 9 blau data.append(0) # channel 10 weiss data.append(255) # channel 11 dimmer data.append(0) # channel 12 strobe # third fixture data.append(rgb_in['rot']) # channel 13 rot data.append(rgb_in['gruen']) # channel 14 gruen data.append(rgb_in['blau']) # channel 15 blau data.append(0) # channel 16 weiss data.append(255) # channel 17 dimmer data.append(0) # channel 18 strobe # fourth fixture data.append(rgb_in['rot']) # channel 19 rot data.append(rgb_in['gruen']) # channel 20 gruen data.append(rgb_in['blau']) # channel 21 blau data.append(0) # channel 22 weiss data.append(255) # channel 23 dimmer data.append(0) # channel 24 strobe # fifth fixture data.append(rgb_in['rot']) # channel 25 rot data.append(rgb_in['gruen']) # channel 26 gruen data.append(rgb_in['blau']) # channel 27 blau data.append(0) # channel 28 weiss data.append(255) # channel 29 dimmer data.append(0) # channel 30 strobe # sixth fixture data.append(rgb_in['rot']) # channel 31 rot data.append(rgb_in['gruen']) # channel 32 gruen data.append(rgb_in['blau']) # channel 33 blau data.append(0) # channel 34 weiss data.append(255) # channel 35 dimmer data.append(0) # channel 36 strobe global wrapper wrapper = ClientWrapper() client = wrapper.Client() # send 1 dmx frame with values for channels 1-6 client.SendDmx(universe, data, dmxsent) wrapper.Run()
def main(): try: opts, args = getopt.getopt( sys.argv[1:], 'fjiu:', ['help', 'full', 'incremental', 'universe=']) except getopt.GetoptError as err: print(str(err)) Usage() sys.exit(2) universe = None full_discovery = False incremental_discovery = False for o, a in opts: if o in ('-h', '--help'): Usage() sys.exit() elif o in ('-f', '--full'): full_discovery = True elif o in ('-i', '--incremental'): incremental_discovery = True elif o in ('-u', '--universe'): universe = int(a) if universe is None: Usage() sys.exit() if incremental_discovery and full_discovery: print('Only one of --incremental or --full can be specified') sys.exit() wrapper = ClientWrapper() client = wrapper.Client() def show_uids(state, uids): if state.Succeeded(): for uid in uids: print(str(uid)) else: print('Error: %s' % state.message, file=sys.stderr) wrapper.Stop() if full_discovery: client.RunRDMDiscovery(universe, True, show_uids) elif incremental_discovery: client.RunRDMDiscovery(universe, False, show_uids) else: client.FetchUIDList(universe, show_uids) wrapper.Run()
def dmxListnerDaemon(universe, dmxOutputQueue, logQueue): global outputQueue outputQueue = dmxOutputQueue try: wrapper = ClientWrapper() client = wrapper.Client() client.RegisterUniverse(universe, client.REGISTER, NewDataCallback) wrapper.Run() except: logQueue.put_nowait("Error setting up DMX in uiniverse: %d" % (universe)) logQueue.put_nowait(traceback.format_exc()) logQueue.put_nowait("Error setting up DMX in uiniverse: %d" % (universe))
def main(a, b, c, d): universe = 0 data = array.array('B') # append first dmx-value for x in range(512): r1 = random.randint(0, 255) data.append(r1) global wrapper wrapper = ClientWrapper() client = wrapper.Client() # send 1 dmx frame with values for channels 1-3 client.SendDmx(universe, data, DmxSent) wrapper.Run()
def main(): serial_device = None if len(sys.argv) == 1: serial_device = Serial(detect_serial_device(), 115200, timeout=1) elif len(sys.argv) == 2: serial_device = Serial(sys.argv[1], 115200, timeout=1) configfile = open(settings.WALL_CONFIG_FILE, 'r') data = simplejson.load(configfile) configfile.close() w = int(data['w']) h = int(data['h']) mapping = {} for k, v in data['mapping'].items(): mapping[int(k)] = int(v) def dmxdata(data): print data pindex = 0 fdata = [] for y in range(h): for x in range(w): r = data[pindex * 3] g = data[pindex * 3 + 1] b = data[pindex * 3 + 2] color = correct_rgb((r, g, b)) fdata.extend([0xFF, mapping[y * w + x]]) fdata.extend(color) pindex += 1 serial_device.write("".join([chr(v) for v in fdata])) universe = 1 wrapper = None try: wrapper = ClientWrapper() except OLADNotRunningException: print "Start olad first" sys.exit(1) client = wrapper.Client() client.RegisterUniverse(universe, client.REGISTER, dmxdata) wrapper.Run()
def squid(dmxrngs): global rngs rngs = dmxrngs global tepilepsy tepilepsy = Tepilepsy() global pen pen = Pen(tepilepsy, '/home/squidlights/resources/tepilepsy_font.gif') global wrapper wrapper = ClientWrapper() wrapper.AddEvent(22, SendDMXFrame) wrapper.Run()
def something(): ##SomethingHere? try: wrapper = ClientWrapper() client = wrapper.Client() client.RegisterUniverse(universe, client.REGISTER, NewData) wrapper.Run() wrapper.AddEvent(10,something) except KeyboardInterrupt: #clear() print("The End")
def main(): args = ParseArgs() device = args.device port = args.port is_output = args.mode == 'output' action = OlaClient.PATCH if args.action == 'patch' else OlaClient.UNPATCH universe = args.universe global wrapper wrapper = ClientWrapper() client = wrapper.Client() client.PatchPort(device, port, is_output, action, universe, PatchPortCallback) wrapper.Run()
def squid(dmxrngs, begclr, endclr, period): global frames frames = [] # # precompute dmx packets for every frame # beg_hsv = colorsys.rgb_to_hsv( *tuple(map(operator.div, map(float, begclr), [255.0] * 3))) end_hsv = colorsys.rgb_to_hsv( *tuple(map(operator.div, map(float, endclr), [255.0] * 3))) for i in (range(0, period, TICK_INTERVAL) + [period]): progress = float(i) / float(period) hsv_delta = tuple(map(operator.sub, end_hsv, beg_hsv)) hsv_addend = tuple(map(operator.mul, tuple([progress] * 3), hsv_delta)) hsv = tuple(map(operator.add, beg_hsv, hsv_addend)) clr = tuple( map( int, map(operator.mul, colorsys.hsv_to_rgb(*hsv), tuple([255.0] * 3)))) frame = [] for j in range(0, len(dmxrngs)): dmxpacket = array.array('B', [0] * dmxrngs[j][1]) for chann in range(dmxrngs[j][1], dmxrngs[j][2] - 2, 3): dmxpacket.append(clr[0]) dmxpacket.append(clr[1]) dmxpacket.append(clr[2]) frame.append(dmxpacket) frames.append(frame) global rngs rngs = dmxrngs global forward forward = True global t_idx t_idx = 0 global wrapper wrapper = ClientWrapper() wrapper.AddEvent(22, SendDMXFrame) wrapper.Run()
def main(): universe = 1 data = array.array('B') # append first dmx-value data.append(10) # append second dmx-value data.append(50) # append third dmx-value data.append(255) global wrapper wrapper = ClientWrapper() client = wrapper.Client() # send 1 dmx frame with values for channels 1-3 client.SendDmx(universe, data, DmxSent) wrapper.Run()