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()
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 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 __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 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()
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 __init__(self, universe, uid, sub_device, pid_file):
"""Create a new InteractiveModeController.
Args:
universe:
uid:
sub_device:
pid_file:
"""
cmd.Cmd.__init__(self)
self._universe = universe
self._uid = uid
self._sub_device = sub_device
self.pid_store = PidStore.GetStore(pid_file)
self.wrapper = ClientWrapper()
self.client = self.wrapper.Client()
self.rdm_api = RDMAPI(self.client, self.pid_store)
self._uids = []
self._response_printer = ResponsePrinter()
# tuple of (sub_device, command_class, pid)
self._outstanding_request = None
self.prompt = '> '
def run(self):
self.wrapper = ClientWrapper()
self.running = True
while self.running:
self.computeEffects()
self.computeDMX()
self.sendDMX()
time.sleep(50e-3)
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()
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 __init__(self, config, inputdevice):
self.config = config
self.current_frame = [0] * 512
self.scene_updated = False
self.input_device = InputDevice(inputdevice)
self.wrapper = ClientWrapper()
self.current_scene = self.config["scenes"][self.config["start_scene"] -
1]
self.nextStep(True)
def __init__(self):
Lighting_Controller.__init__(self)
# dmx bits
self.wrapper = ClientWrapper()
self.client = self.wrapper.Client()
self.universe = 0 # type: int
self.wait_on_dmx = threading.Event()
self.dmx_succeeded = False
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 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 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):
'''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 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 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 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 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()
