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)