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()
