def run(self): '''Wrapper, Framerate''' print "THREAD" self._wrapper = ClientWrapper() self._activesender = True self.univloglevel = 0 self.base = com_sql.ComSql() # SQL Framerate try: engine = self.base.requete_sql( "SELECT * FROM dmx_engine WHERE id=1") #setting for e in range(len(engine)): freq_ms = engine[e]['freq_ms'] except: print "default to 40 fps" freq_ms = 25 # FOR TEST # freq_ms = 500 self._tick_interval = int(freq_ms) # in milliseconds print "freq_ms" print self._tick_interval # list of scens to play self.scen_ids = [] # dict to store each scenari instance self.my_scens = {} # SQL Universes try: prefs = self.base.requete_sql( "SELECT * FROM dmx_preferences WHERE id=1") #setting for p in range(len(prefs)): self.univ_qty = prefs[p]['univ_qty'] except: print "default to 1 universe" self.univ_qty = 1 print "univ_qty" print self.univ_qty # array to store full frame self.WholeDmxFrame = [0] * 512 * self.univ_qty # send the first one self.SendDmxFrame() self._wrapper.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 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 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 run(self): """ the running thread """ try: self.wrapper = ClientWrapper() self.client = self.wrapper.Client() if debug: print('connected to OLA server') self.wrapper.Run() except OLADNotRunningException: if debug: print('cannot connect to OLA')
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 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 """ else: data = [] data = array.array('B') data.append(0) #Intencity data.append(0) #R data.append(0) #G data.append(0) #B client.SendDmx(universe, data, DmxSent) wrapper.Run() print("\nSHOULDNT SEE THIS\n") return """ return
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 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 initialize(self, configDict): config = configDict.get('DMX', {}) self.universes = config.get('universes', [1]) self.data = bytearray(self.MaxChannels) self.dataChanged = True self.client = None try: self.wrapper = ClientWrapper() self.client = self.wrapper.Client() self.send() except: print("Error: couldn't connect to OLA server") getchMsg()
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 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(): 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 __init__(self): self.settings = yaml.load(open('settings.yaml', 'r')) self.serv = sockethandler.server( self.settings.get('address') or 'localhost', self.settings.get('port') or 25500) self.clients = [] self.switches = [] for switch in self.settings['switches'].items(): self.switches.append(Switch(switch[0], switch[1])) self.current_dmx = array.array('B', [0] * 512) self.wrapper = ClientWrapper() self.wrapper.AddEvent(100, self.loop)
def initialize(self): """ Zero out dmx, set up events """ try: self.dmx_wrapper = ClientWrapper() self.dmx_client = self.dmx_wrapper.Client() except: self.notify( "OLAD is not running", "Attept to connect to OLAD failed. " "Please start it and try again.") return self.dmx_wrapper.AddEvent(self.dmx_tick, self.send_to_dmx) self.dmx_wrapper.AddEvent(self.dmx_tick / 2, self.get_midi_data)
def run(self): if self.wrapper: self.wrapper.Stop() try: self.wrapper = ClientWrapper() except OLADNotRunningException: print "Start olad first" sys.exit(1) client = self.wrapper.Client() client.RegisterUniverse(self.universe, client.REGISTER, self._dmxdata) self._load_config() self.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 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 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()
def squid(dmxrngs, value): global rngs rngs = dmxrngs global tepilepsy tepilepsy = Tepilepsy() v = float(value) / 255.0 global shimmering shimmering = Shimmering(tepilepsy, v) global wrapper wrapper = ClientWrapper() wrapper.AddEvent(22, SendDMXFrame) wrapper.Run()
def __init__(self, groups): self.pixel_groups = [ self.pixel_group(group[0], group[1], group[2], group[3], group[4]) for group in groups ] self.source_universes = { group.source_universe for group in self.pixel_groups } self.ola_client_wrapper = ClientWrapper() self.ola_client = self.ola_client_wrapper.Client() self.listeners = [ self.universe_listener(u, self.pixel_groups, self.ola_client) for u in self.source_universes ] self.listeners.sort()
class OLAModel(object): def __init__(self, max_dmx, universe=0): # XXX any way to check if this is a valid connection? self.universe = universe self.wrapper = ClientWrapper() self.client = self.wrapper.Client() self.pixels = [0] * max_dmx def __repr__(self): return "OLAModel(universe=%d)" % self.universe # Model basics def cell_ids(self): # return PANEL_IDS return PANEL_MAP.keys() def set_pixel(self, ix, color): # dmx is 1-based, python lists are 0-based # I don't whole-heartedly believe in this anymore, but for consistency we're # keeping it for now ix = ix - 1 self.pixels[ix] = color.r self.pixels[ix + 1] = color.g self.pixels[ix + 2] = color.b def set_cell(self, cell, color): # cell is a string like "14b" # ignore unmapped cells if cell in PANEL_MAP: v = PANEL_MAP[cell] if type(v) is int: self.set_pixel(v, color) elif type(v) is list: for x in v: self.set_pixel(x, color) def set_cells(self, cells, color): for cell in cells: self.set_cell(cell, color) def set_eye_dmx(self, isParty, channel, value): "A direct access to the dmx control for the eyes. Party eye is before business eye" offset = PANEL_MAP["EYEp"] if not isParty: offset = PANEL_MAP["EYEb"] # Subtract 1 here so that the channels are always expressed in 1 indexed order as # is shown in the manual offset += channel - 1 self.pixels[offset] = value def go(self): data = array.array('B') data.extend(self.pixels) self.client.SendDmx(self.universe, data, callback)
def squid(dmxrngs): global rngs rngs = dmxrngs global datas datas = [] for rng in rngs: data = array.array('B', [0] * rng[1]) for chann in range(rng[1], rng[2]): data.append(0) datas.append(data) global wrapper wrapper = ClientWrapper() wrapper.AddEvent(22, SendDMXFrame) wrapper.Run()
class DMXAdapter(LightAdapter): def __init__(self): pass def start(self): from ola.ClientWrapper import ClientWrapper from ola.DMXConstants import DMX_MIN_SLOT_VALUE, DMX_MAX_SLOT_VALUE, DMX_UNIVERSE_SIZE self._universe = 0 self._wrapper = ClientWrapper() self._client = self._wrapper.Client() self.run() # TODO We could use OLA's internal event scheduling system, but currently # I'm not aware of any obvious reason to do so. Nevertheless it bears # further investigation. def _sent_callback(self, status): if (not status.Succeeded()): # TODO catch this and report it in our heartbeat log.error("Failed to send DMX: %s" % status.message) # Always stop, as we call ourselves from a loop self._wrapper.Stop() def send(self, data): self._client.SendDmx(0, data, self._sent_callback) self._wrapper.Run() def run(self): dt_start = time.time_ns() # awkwardly wait around while we waight for an animator to be assigned while not self.animator: time.sleep(1) while True: dt = time.time_ns() - dt_start dt_start = time.time_ns() self.animator.step(dt / (10**9)) with self.animator.lock: self.send(self.animator.lightstate) # TODO use configuration time.sleep(1 / 60)
def main(): global wrapper wrapper = ClientWrapper() client = wrapper.Client() global l l = LightDrummer(client, 140) # Intro pb2 = PartyBar() pb2.set(PURPLE, BLUE, BLUE, PURPLE) l.run(twobardimmer(pb2)) def handle_input(input): exec input in globals(), globals() shell.run(l, handle_input)
def PatchPorts(wrapper=None): """Perform the patch and return the results when complete.""" patch_results = PatchResults() if not wrapper: wrapper = ClientWrapper() def PatchingComplete(ok, found, patched): # called when the patching is complete, this stops the wrapper and updates # the status code wrapper.Stop() patch_results.status = ok patch_results.ports_found = found patch_results.ports_patched = patched patcher = AutoPatcher(wrapper, PatchingComplete, True) patcher.Patch() wrapper.Run() return patch_results
def __init__(self, max_dmx, universe=0): # XXX any way to check if this is a valid connection? self.universe = universe self.wrapper = ClientWrapper() self.client = self.wrapper.Client() # Extract just the cells from the panel map ignoring the eyes or other # logical DMX things with non-integer values self.cell_keys = [] for key in PANEL_MAP.keys: val = key[:-1] try: int(val) except Exception as e: pass else: self.cell_keys += [key] self.pixels = [0] * max_dmx
def squid(dmxrngs): global rngs rngs = dmxrngs global tepilepsy tepilepsy = Tepilepsy() global gen_1 gen_1 = Image.open('/home/squidlights/resources/gen1.png') global gen_2 gen_2 = Image.open('/home/squidlights/resources/gen2.png') global gen_3 gen_3 = Image.open('/home/squidlights/resources/gen3.png') global gen_4 gen_4 = Image.open('/home/squidlights/resources/gen4.png') global gen_5 gen_5 = Image.open('/home/squidlights/resources/gen5.png') # clear first for x in range(tepilepsy.GetWidth()): for y in range(tepilepsy.GetHeight()): tepilepsy.SetPixel((x, y), (0, 0, 0)) # decide on pokemon index idx = random.randint(0, 825) # open image, resize to fit im = get_pokemon(idx) im = im.convert('RGB') im.thumbnail((tepilepsy.GetWidth(), tepilepsy.GetHeight()), Image.NEAREST) im = im.convert('RGB') im.save('/tmp/im.png', 'PNG') # set image pixels for x in range(im.width): for y in range(im.height): tepilepsy.SetPixel((x, y), im.getpixel((x, y))) global wrapper wrapper = ClientWrapper() wrapper.AddEvent(22, SendDMXFrame) wrapper.Run()