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