def setUp(self):
self.receiver = dispatch.Receiver()
self.serverPort = reactor.listenMulticast(
17778,
async .MulticastDatagramServerProtocol(self.receiver, "224.0.0.1"),
listenMultiple=True)
self.receiver2 = dispatch.Receiver()
self.serverPort2 = reactor.listenMulticast(
17778,
async .MulticastDatagramServerProtocol(self.receiver2,
"224.0.0.1"),
listenMultiple=True)
self.client = async .DatagramClientProtocol()
self.clientPort = reactor.listenUDP(0, self.client)
def __init__(self, port):
self.port = port
self.receiver = dispatch.Receiver()
self._server_port = reactor.listenUDP(
self.port, async .DatagramServerProtocol(self.receiver))
print("Listening on osc.udp://localhost:%s" % (self.port))
self.nleds = 160
self.threshold = 0.
self.amplification = 128.
self.buff = bytearray(self.nleds * 3)
self.frameLength = .03
for i in range(len(self.buff)):
self.buff[i] = 0x80
self.zeros = bytearray(5)
self.launchpad = [bytearray([0x80, 0x80, 0x80])] * 8
self.colorTable = self.generateColorTable()
self.adaptiveThreshold = [0.] * 24
self.quietTime = 0
self.lastArg = [0, 0]
self.maxArgSum = [0, 0]
# LED output loop
task.LoopingCall(self.mainLoop).start(self.frameLength)
# all top level osc commands
self.receiver.addCallback("/*", self.handleOSC)
def __init__(self, port):
self.port = port
self.receiver = dispatch.Receiver()
self._server_port = reactor.listenUDP(
self.port, async .DatagramServerProtocol(self.receiver))
print("Listening on osc.udp://localhost:%s" % (self.port))
self.nleds = 160
self.threshold = 0.
self.amplification = 128.
self.buff = bytearray(self.nleds * 3)
for i in range(len(self.buff)):
self.buff[i] = 0x80
self.zeros = bytearray(5)
self.launchpad = [bytearray([0x80, 0x80, 0x80])] * 8
self.colorTable = self.generateColorTable()
# LED output loop
task.LoopingCall(self.mainLoop).start(.03)
# all top level osc commands
self.receiver.addCallback("/*", self.handleOSC)
# it's all about the stats
self.stats = np.zeros((24, 10000),
dtype='float') # should take about 5.5 min
self.i = 0
def __init__(self, port):
self.port = port
self.receiver = dispatch.Receiver()
self._server_port = reactor.listenUDP(self.port, async.DatagramServerProtocol(self.receiver))
print("Listening on osc.udp://localhost:%s" % (self.port))
#self.receiver.addCallback('/some/specific/address',self.some_callback)
self.receiver.fallback = self.fallback
def testDispatching(self):
hello = osc.Message("/hello")
there = osc.Message("/there")
addr = ("0.0.0.0", 17778)
def cb(message, a):
self.assertEquals(message, hello)
self.assertEquals(addr, a)
state['cb'] = True
def cb2(message, a):
self.assertEquals(message, there)
self.assertEquals(addr, a)
state['cb2'] = True
recv = dispatch.Receiver()
recv.addCallback("/hello", cb)
recv.addCallback("/there", cb2)
state = {}
recv.dispatch(hello, addr)
self.assertEquals(state, {'cb': True})
state = {}
recv.dispatch(osc.Bundle([hello, there]), addr)
self.assertEquals(state, {'cb': True, 'cb2': True})
def setUp(self):
self.receiver = dispatch.Receiver()
self.serverPort = reactor.listenTCP(
17778, async .ServerFactory(self.receiver))
self.client = async .ClientFactory()
self.clientPort = reactor.connectTCP("localhost", 17778, self.client)
return self.client.deferred
def __init__(self, port):
self.port = port
self.receiver = dispatch.Receiver()
self._server_port = reactor.listenUDP(self.port, async.DatagramServerProtocol(self.receiver))
print("Listening on osc.udp://localhost:%s" % (self.port))
# Simple
self.receiver.addCallback("/1/fader1", self.hue_handler)
self.receiver.addCallback("/1/fader2", self.saturation_handler)
self.receiver.addCallback("/1/fader3", self.intensity_handler)
self.receiver.addCallback("/1/fader4", self.offset_handler)
self.receiver.addCallback("/1/fader5", self.speed_handler)
self.receiver.addCallback("/2/*", self.mode_handler)
# Beat Machine
self.receiver.addCallback("/3/rotary1", self.hue_handler)
self.receiver.addCallback("/3/rotary2", self.saturation_handler)
self.receiver.addCallback("/3/rotary3", self.intensity_handler)
# Pillow Room
self.receiver.addCallback("/*", self.mode_page_handler)
self.receiver.addCallback("/uniform/*", self.uniform_handler)
self.receiver.addCallback("/rainbow/*", self.rainbow_handler)
self.receiver.addCallback("/wheel/*", self.wheel_handler)
self.receiver.addCallback("/fade/*", self.fade_handler)
self.receiver.addCallback("/inertial_random/*", self.inertial_random_handler)
# fallback:
self.receiver.fallback = self.fallback
send_mode('u'); # when server starts, set mode to uniform
def __init__(self, port):
self.port = port
self.receiver = dispatch.Receiver()
self._server_port = reactor.listenUDP(
self.port, async .DatagramServerProtocol(self.receiver))
print("Listening on osc.udp://localhost:%s" % (self.port))
self.nleds = 160
self.threshold = [
-7.19297391151, -7.92876633769, -8.69039601836, -9.87746356824,
-10.7019071804, -11.1061553173, -10.9864707093, -10.7105013077,
-10.5640548188, -10.8411086662, -11.3074986843, -11.1271616796,
-10.5099373964, -10.1257797518, -10.1146692515, -10.517943859,
-11.2721637342, -12.1456213893, -12.6856257676, -12.6992830202,
-11.5580795472, -10.744207601, -10.4225721116, -10.6079076071
]
self.amplification = 128.
self.buff = bytearray(self.nleds * 3)
for i in range(len(self.buff)):
self.buff[i] = 0x80
self.zeros = bytearray(5)
self.launchpad = [bytearray([0x80, 0x80, 0x80])] * 8
self.colorTable = self.generateColorTable()
# LED output loop
task.LoopingCall(self.mainLoop).start(.03)
# all top level osc commands
self.receiver.addCallback("/*", self.handleOSC)
def __init__(self, port):
self.port = port
self.receiver = dispatch.Receiver()
self._server_port = reactor.listenUDP(
self.port, async .DatagramServerProtocol(self.receiver))
print("Listening on osc.udp://localhost:%s" % (self.port))
self.receiver.addCallback("/thermocam/1/up_down", up_down_handler)
self.receiver.addCallback("/thermocam/1/turn", turn_handler)
self.receiver.addCallback("/thermocam/1/test_scan", test_handler)
self.receiver.addCallback("/thermocam/1/scan", scan_handler)
self.receiver.addCallback("/thermocam/1/shutdown", shutdown_handler)
self.receiver.addCallback("/thermocam/1/resolution/1/*",
resolution1_handler)
self.receiver.addCallback("/thermocam/1/resolution/2/*",
resolution2_handler)
self.receiver.addCallback("/thermocam/1/resolution/3/*",
resolution3_handler)
self.receiver.addCallback("/thermocam/1/resolution/4/*",
resolution4_handler)
self.receiver.addCallback("/thermocam/1/resolution/5/*",
resolution5_handler)
self.receiver.addCallback("/thermocam/1/resolution/6/*",
resolution6_handler)
self.receiver.addCallback("/thermocam/1/resolution/7/*",
resolution7_handler)
def server_service(port):
"""
Create Twisted service for OSC server ('receiver').
Callbacks for inbound messages must be registered here.
"""
receiver = dispatch.Receiver()
receiver.addCallback("/loop", got_loop)
protocol = async.DatagramServerProtocol(receiver)
return internet.UDPServer(port, protocol)
def __init__(self, port, lightState):
self.port = port
self.lightState = lightState
self.receiver = dispatch.Receiver()
self.receiver.addCallback("/pixel/*", self.pixel_handler)
self._server_port = reactor.listenUDP(self.port,
async .DatagramServerProtocol(
self.receiver),
interface='0.0.0.0')
log.info("Listening OSC on udp port %s" % (self.port))
def __init__(self, port):
self.port = port
self.receiver = dispatch.Receiver()
self.receiver.addCallback("/foo", foo_handler)
self.receiver.addCallback("/ping", self.ping_handler)
self.receiver.addCallback("/quit", self.quit_handler)
self.receiver.setFallback(self.fallback)
self._server_port = reactor.listenTCP(
self.port, async .ServerFactory(self.receiver))
print("Listening on osc.tcp://127.0.0.1:%s" % (self.port))
def testFunctionFallback(self):
hello = osc.Message("/hello")
addr = ("0.0.0.0", 17778)
def fb(message, address):
self.assertEquals(message, hello)
recv = dispatch.Receiver()
recv.setFallback(fb)
recv.dispatch(hello, addr)
def __init__(self, port):
self.port = port
self.receiver = dispatch.Receiver()
self._server_port = reactor.listenUDP(
self.port, async .DatagramServerProtocol(self.receiver))
print("Listening on osc.udp://localhost:%s" % (self.port))
self.nleds = 160
self.nspokes = 8
self.leds_per_spoke = self.nleds / self.nspokes
## sparkle magic numbers ##
self.sparkle_fraction = 0.05
self.sparkle_fraction_amplification = 2.5 # music responsive
self.sparkle_length = 3
self.sparkle_fade_rate = 0.4 # non-music responsive
self.sparkle_fade_randomness_amplification = 0.6 # music responsive
self.sparkle_fraction_music_correction = 0.09
self.brightness_min = 7 # prevents the final color in the fade from being strongly colored when quiet
self.amplification = 250.
self.threshold_decay = .2
# sparkle 2.0 additional magic numbers
self.location_boost = 1.1
self.hue_rotate_speed = 0.5
self.hue_amplitude = 12
## colors
self.off_white = bytearray([170, 190, 160]) # g, r, b
self.black = bytearray([128, 128, 128]) # g, r, b
self.led_map = [[0] * self.leds_per_spoke for x in range(self.nspokes)]
self.spoke_sparkle_fade_randomness = 0
self.hue = 0
self.hue_shifter = [0, 0, 0]
self.threshold = 0.
self.soundVals = [0] * self.leds_per_spoke
self.buff = bytearray(self.nleds * 3)
self.frameLength = .05
for i in range(len(self.buff)):
self.buff[i] = 0x80
self.zeros = bytearray(5)
self.launchpad = [bytearray([0x80, 0x80, 0x80])] * 8
# self.colorTable = self.generateColorTable()
self.adaptiveThreshold = [0.] * 24
self.quietTime = 0
self.lastArg = [0, 0]
self.maxArgSum = [0, 0]
# LED output loop
task.LoopingCall(self.mainLoop).start(self.frameLength)
# all top level osc commands
self.receiver.addCallback("/*", self.handleOSC)
def __init__(self, port):
self.port = port
self.receiver = dispatch.Receiver()
self._server_port = reactor.listenUDP(
self.port, async .DatagramServerProtocol(self.receiver))
print("Listening on osc.udp://localhost:%s" % (self.port))
self.switch_position = None
task.LoopingCall(self.mainLoop).start(.03)
self.receiver.addCallback("/main", self.handleSwitch)
# TO-DO, don't respond to switch, only to pd
self.receiver.addCallback("/*", self.handleOSC)
def testClassFallback(self):
hello = osc.Message("/hello")
addr = ("0.0.0.0", 17778)
class Dummy(object):
def __init__(self, test_case):
self.x = 3
self.test_case = test_case
def fb(self, message, address):
self.test_case.assertEquals(message, hello)
self.test_case.assertEquals(self.x, 3)
recv = dispatch.Receiver()
dummy = Dummy(self)
recv.fallback = dummy.fb
recv.dispatch(hello, addr)
def __init__(self, port):
self.port = port
self.receiver = dispatch.Receiver()
self._server_port = reactor.listenUDP(
self.port, async .DatagramServerProtocol(self.receiver))
print("Listening on osc.udp://localhost:%s" % (self.port))
self.nleds = 240
self.lengthNumber = 90
self.threshold = 0.
self.amplification = 128.
self.gradientFiles = [
'golden.png', 'orange.png', 'pink_to_yellow.png',
'unfull_pastel.png', 'redder_pastel.png', 'purple_to_blue.png'
]
self.currentGradientFileIndex = 0
self.gradientFileName = self.gradientFiles[0]
self.buff = bytearray(self.nleds * 3)
self.frameLength = .03
self.colorLength = 60 * 15
for i in range(len(self.buff)):
self.buff[i] = 0x80
self.zeros = bytearray(5)
self.launchpad = [bytearray([0x80, 0x80, 0x80])] * 8
self.colorTable = self.generateColorTable()
self.adaptiveThreshold = [0.] * 24
self.quietTime = 0
self.lastArg = [0, 0]
self.maxArgSum = [0, 0]
# LED output loop
self.outputLoop = task.LoopingCall(self.mainLoop)
# On Off loop
self.onOffLength = 999999999 # currently, forever
self.loopOn = True
task.LoopingCall(self.onOffLoop).start(self.onOffLength)
# Color file loop
task.LoopingCall(self.colorLoop).start(self.colorLength)
# all top level osc commands
self.receiver.addCallback("/*", self.handleOSC)
def __init__(self, is_initiator=True):
self.delay = 1.0
self.send_host = "127.0.0.1"
self.send_port = 17777
self.receive_port = 16666
if is_initiator:
self.send_port = 16666
self.receive_port = 17777
self.receiver = dispatch.Receiver()
self.sender = async.DatagramClientProtocol()
self._sender_port = reactor.listenUDP(0, self.sender)
self._server_port = reactor.listenUDP(self.receive_port, async.DatagramServerProtocol(self.receiver))
print("Listening on osc.udp://localhost:%s" % (self.receive_port))
self.receiver.addCallback("/ping", self.ping_handler)
self.receiver.addCallback("/pong", self.pong_handler)
self.receiver.fallback = self.fallback
if is_initiator:
reactor.callLater(0.1, self._start)
def testFallback(self):
"""
Tests how fallbacks are handled.
"""
foo = osc.Message("/foo")
egg_spam = osc.Message("/egg/spam")
egg_ham = osc.Message("/egg/ham")
addr = ("0.0.0.0", 17778)
called = {'foo': False, 'egg_spam': False, 'fallback': False}
def foo_cb(message, a):
self.assertEquals(message, foo)
self.assertEquals(addr, a)
called['foo'] = True
def egg_spam_cb(message, a):
self.assertEquals(message, egg_spam)
self.assertEquals(addr, a)
called['egg_spam'] = True
def fallback(message, a):
self.assertEquals(message, egg_ham)
self.assertEquals(addr, a)
called['fallback'] = True
recv = dispatch.Receiver()
recv.addCallback("/foo", foo_cb)
child = dispatch.AddressNode()
child.addCallback("/spam", egg_spam_cb)
recv.addNode("egg", child)
recv.fallback = fallback
# now, dispatch messages
recv.dispatch(foo, addr)
recv.dispatch(egg_spam, addr)
recv.dispatch(egg_ham, addr)
self.assertTrue(called['foo'])
self.assertTrue(called['egg_spam'])
self.assertTrue(called['fallback'])
def __init__(self, port):
self.port = port
self.receiver = dispatch.Receiver()
self._server_port = reactor.listenUDP(
self.port, async .DatagramServerProtocol(self.receiver))
print("Listening on osc.udp://localhost:%s" % (self.port))
# Simple
# self.receiver.addCallback("/1/fader1", self.hue_handler)
# self.receiver.addCallback("/1/fader2", self.saturation_handler)
# self.receiver.addCallback("/1/fader3", self.intensity_handler)
# self.receiver.addCallback("/1/fader4", self.offset_handler)
# self.receiver.addCallback("/1/fader5", self.speed_handler)
# self.receiver.addCallback("/2/*", self.mode_handler)
# # Beat Machine
# self.receiver.addCallback("/3/rotary1", self.hue_handler)
# self.receiver.addCallback("/3/rotary2", self.saturation_handler)
# self.receiver.addCallback("/3/rotary3", self.intensity_handler)
# Pillow Room
# self.receiver.addCallback("/*", self.mode_page_handler)
self.receiver.addCallback("/uniform/*", self.uniform_handler)
def __init__(self, port):
self.port = port
self.receiver = dispatch.Receiver()
self._server_port = reactor.listenUDP(
self.port, async .DatagramServerProtocol(self.receiver))
print("Listening on osc.udp://localhost:%s" % (self.port))
self.nleds = 160
self.sensitivity = 1.
self.buff = bytearray(self.nleds * 3)
for i in range(len(self.buff)):
self.buff[i] = 0x80
self.zeros = bytearray(5)
self.spokes = []
for i in range(8):
self.spokes.append([-1 for j in range(20)])
self.launchpad = [bytearray([0x80, 0x80, 0x80])] * 8
self.colorTable = colorTable
# LED output loop
task.LoopingCall(self.mainLoop).start(.03)
# all top level osc commands
self.receiver.addCallback("/*", self.handleOSC)
def setUp(self):
self.receiver = dispatch.Receiver()
self.serverPort = reactor.listenUDP(
17778, async .DatagramServerProtocol(self.receiver))
self.client = async .DatagramClientProtocol()
self.clientPort = reactor.listenUDP(0, self.client)
def setUp(self):
self.receiver = dispatch.Receiver()
self.serverPort = reactor.listenUDP(
17778, async .DatagramServerProtocol(self.receiver))
self.target = liblo.Address(17778)
def __init__(self, port):
self.port = port
self.receiver = dispatch.Receiver()
self._server_port = reactor.listenMulticast(self.port, async.MulticastDatagramServerProtocol(self.receiver, "224.0.0.1"), listenMultiple=True)
print("Listening on osc.udp://224.0.0.1:%s" % (self.port))
self.receiver.addCallback("/spam", self.spam_handler)
def handleDone(message, client):
"""
"""
result = message.getValues()
if result == ['/quit']:
result = {"shutdown": "done"}
log.msg("Result in handleDone: %s" % result)
client.deferredResult.callback(result)
def handleFail(message, client):
"""
"""
errorData = message.getValues()
log.err("Failure: %s" % str(errorData))
error = {
"error": errorData[1],
"command": errorData[0],
"exception": exceptions.RemoteCallError
}
#client.deferredResult.errback(exceptions.RemoteCallError(errorData[1]))
client.deferredResult.callback(error)
receiverAPI = dispatch.Receiver()
receiverAPI.addCallback("/status.reply", handleStatus)
receiverAPI.addCallback("/done", handleDone)
receiverAPI.addCallback("/fail", handleFail)
def __init__(self, *dispatchers, **kw):
self.receiver = kw.get('receiver', None) or dispatch.Receiver()
self.receiver.fallback = self.fallback
self._addresses = {}
for d in dispatchers:
self.addDispatcher(d)
