def start(): """ Starts a UDP server on localhost:5000 listening for incoming OSC data on /muse/eeg. """ parser = argparse.ArgumentParser() parser.add_argument("--ip", default="127.0.0.1", help="The ip to listen on") parser.add_argument("--port", type=int, default=5000, help="The port to listen on") args = parser.parse_args() d = dispatcher.Dispatcher() d.map("/debug", print) d.map("/muse/eeg", eeg_handler, "EEG") server = osc_server.BlockingOSCUDPServer((args.ip, args.port), d) print("OSC server started {}".format(server.server_address)) try: server.serve_forever() except KeyboardInterrupt: print("Server stopped.")
def start(self): self._running=True self._server = osc_server.BlockingOSCUDPServer((socket.gethostbyname(socket.gethostname()),self._port), self._dispatcher) while self._running: self._server.handle_request() self._server.server_close() self._server=None
def updateServer(self): if self.server: self.server.server_address = (self.sv_ip, self.sv_port) else: self.server = osc_server.BlockingOSCUDPServer( (self.sv_ip, self.sv_port), self.disp) print('Server updated', self.sv_ip, self.sv_port)
def start(): """ Starts a UDP server on localhost:5000 listening for incoming OSC data on /muse/eeg. """ parser = argparse.ArgumentParser() parser.add_argument("--ip", default="192.168.1.86", help="The ip to listen on") parser.add_argument("--port", type=int, default=5000, help="The port to listen on") args = parser.parse_args() print("listening on ip", args.ip, "with port", args.port) d = dispatcher.Dispatcher() d.map("/debug", print) d.map("/muse/eeg", eeg_handler, "EEG") d.map("/muse/elements/alpha_absolute", alpha_handler, "ALPHA") d.map("/muse/elements/beta_absolute", beta_handler, "BETA") d.map("/muse/elements/theta_absolute", theta_handler, "THETA") d.map("/muse/elements/gamma_absolute", gamma_handler, "GAMMA") d.map("/muse/elements/delta_absolute", delta_handler, "DELTA") server = osc_server.BlockingOSCUDPServer((args.ip, args.port), d) print("OSC server started {}".format(server.server_address)) try: server.serve_forever() except KeyboardInterrupt: print("Server stopped.")
def _osc_server_thread(self): """ Thread for OSC blocking server """ self._oscserver = osc_server.BlockingOSCUDPServer( (self.udp_ip, self.udp_port), self._dispatcher) self._pr('Starting OSC server on {:s}:{:d}...'.format( self.udp_ip, self.udp_port)) self._oscserver.serve_forever() self._pr('OSC server shut down.')
def main(): disp = dispatcher.Dispatcher() disp.set_default_handler(handle_default) disp.map("/SOSC", handle_simple_osc) server = osc_server.BlockingOSCUDPServer(("0.0.0.0", 9999), disp) server.serve_forever()
def run(self): global FD_control from pythonosc import dispatcher dispatcher = dispatcher.Dispatcher() dispatcher.map('/svd', complexity2FD) server = osc_server.BlockingOSCUDPServer((self.addr, self.port), dispatcher) print("Serving on {}".format(server.server_address)) server.serve_forever()
def __init__(self, broadcast_address): self.disp = dispatcher.Dispatcher() self.disp.set_default_handler(print) self.server = osc_server.BlockingOSCUDPServer(("0.0.0.0", 10023), self.disp) self.client = udp_client.SimpleUDPClient(broadcast_address, 10023, allow_broadcast=True) self.server.socket = self.client._sock
def listen_osc(self, folder, handler, *args): """Listen osc at address, port with handler function forever""" dispatcher_ = dispatcher.Dispatcher() dispatcher_.map(folder, handler, *args) server = osc_server.BlockingOSCUDPServer((self.address, self.port), dispatcher_) if self.verbose: print(f"Serving on {server.server_address}") server.serve_forever()
def start_server_in_separate_thread(counter): global server_thread, server_ip, server_port, server our_dispatcher = dispatcher.Dispatcher() our_dispatcher.map("/tick", handle_tick) # add other dispatcher hooks here server = osc_server.BlockingOSCUDPServer((server_ip, server_port), our_dispatcher) server_thread = threading.Thread(target=server.serve_forever) server_thread.start()
def _work(self): disp = dispatcher.Dispatcher() disp.map("/*", self._got_osc, needs_reply_address=True) server = osc_server.BlockingOSCUDPServer( (self._destination, self._port), disp, ) server.timeout = 1 while self._running: server.handle_request()
def startupInputServer(self, context, envars): print("Create Python Server Thread...") # creating a blocking UDP Server # Each message will be handled sequentially on the same thread. # the alternative: # ThreadingOSCUDPServer creates loads of threads # that are not cleaned up properly self.inputServer = osc_server.BlockingOSCUDPServer((envars.udp_in, envars.port_in), self.dispatcher) self.server_thread = threading.Thread(target=self.inputServer.serve_forever) self.server_thread.start() print("... server started on ", envars.port_in)
def handle_osc(): global osc_udp_client osc_udp_client = udp_client.SimpleUDPClient(config["osc"]["sendToHost"], config["osc"]["sendToPort"]) disp = dispatcher.Dispatcher() disp.map(config["path"] + "*", osc_message_handler) global osc_udp_server osc_udp_server = osc_server.BlockingOSCUDPServer( server_address=(config["osc"]["receiveFromHost"], config["osc"]["receiveFromPort"]), dispatcher=disp) osc_udp_server.serve_forever()
def __init__(self, in_port, out_port, ip='127.0.0.1', *args): super(OSCServer, self).__init__() # OSC library objects self.dispatcher = dispatcher.Dispatcher() self.client = udp_client.SimpleUDPClient(ip, out_port) # Bindings for server self.init_bindings(self.osc_attributes) self.server = osc_server.BlockingOSCUDPServer((ip, in_port), self.dispatcher) # Server properties self.debug = False self.in_port = in_port self.out_port = out_port self.ip = ip
def main(self): self.dispatcher = dispatcher.Dispatcher() self.osc = osc_server.BlockingOSCUDPServer( (self.osc_address, self.osc_port), self.dispatcher) self.dispatcher.map("/channel/*/stage/layer/*/", self.parse_stage) self.dispatcher.map("/channel/*/framerate", self.parse_framerate) self.dispatcher.map("/channel/*/mixer/audio/*", self.parse_volume) self.dispatcher.map("/channel/*/output/consume_time", self.parse_consume_time) self.dispatcher.set_default_handler(self.parse_null) self.osc.serve_forever()
def start_server_in_separate_thread(): global server_thread, server_ip, server_port, server dis = dispatcher.Dispatcher() dis.map("/tick", handle_tick) dis.map("/output_1", mix) dis.map("/output_2", scoop) dis.map("/output_3", move) # add other dispatcher hooks here server = osc_server.BlockingOSCUDPServer((server_ip, server_port), dis) server_thread = threading.Thread(target=server.serve_forever) server_thread.start()
def __init__(self, in_port, out_port, ip, ip_client, *args): super(OSCServer, self).__init__() # OSC library objects self.dispatcher = dispatcher.Dispatcher() self.client = SimpleUDPClientCustom(ip_client, out_port) # Bindings for server self.init_bindings(self.osc_attributes) self.server = osc_server.BlockingOSCUDPServer((ip, in_port), self.dispatcher) self.server.allow_reuse_address = True # Server properties self.debug = False self.in_port = in_port self.out_port = out_port self.ip = ip
def __init__(self, in_port, out_port, ip='127.0.0.1', verbose=True, *args): super(OSCServer, self).__init__() # OSC library objects self.verbose = verbose self.dispatcher = dispatcher.Dispatcher() self.client = udp_client.SimpleUDPClient(ip, out_port) self.init_bindings(self.osc_attributes) self.server = osc_server.BlockingOSCUDPServer((ip, in_port), self.dispatcher) self.in_port = in_port self.out_port = out_port self.ip = ip
def main(): # this must only be modified from a Bokeh session callback # This is important! Save curdoc() to make sure all threads # see the same document. doc = curdoc() #thingy = Surface3d(x="gyro_x", y="gyro_y", z="gyro_z", data_source=source) layout = column(children=[], sizing_mode='stretch_both') doc.add_root(layout) # mapping of name to ClientInfo clients = {} disp = dispatcher.Dispatcher() disp.map("/filter", partial(schedule_update, doc, clients, layout)) server = osc_server.BlockingOSCUDPServer(("localhost", 10000), disp) server_thread = threading.Thread(target=server.serve_forever) server_thread.start()
def __init__(self, address): self.disp = dispatcher.Dispatcher() self.disp.set_default_handler(print) self.server = osc_server.BlockingOSCUDPServer(("0.0.0.0", 10023), self.disp) self.client = udp_client.SimpleUDPClient(address, 10023) self.server.socket = self.client._sock logging.info(" Testing faders...") for i in range(1, 17): logging.debug(f" Testing channel {i}") self.test_fader(f"/ch/{str(i).zfill(2)}", False) for i in range(1, 9): logging.debug(f" Testing DCA {i}") self.test_fader(f"/dca/{i}", True) logging.info(" Done!") logging.info(" X32 Ready!")
def launchUDPServer(): # this is handling the messages received from EEGSonic parser = argparse.ArgumentParser() parser.add_argument('--ip', default='127.0.0.1', help='The ip of the OSC server') parser.add_argument('--port', type=int, default=7400, help='the port the OSC server is listening on') args = parser.parse_args() dispatcher = Dispatcher() dispatcher.map('*', relayOSC) # this is receiving the messages from EEGsonic and forwarding to the front end server = osc_server.BlockingOSCUDPServer( (args.ip, args.port), dispatcher) print(f'Serving on {server.server_address}') server.serve_forever()
def connect(self): # https://github.com/attwad/python-osc/issues/41 self._udp_client = udp_client.UDPClient(self._host, self._port) self._udp_client._sock.bind(('', 0)) osc_server.BlockingOSCUDPServer.allow_reuse_address = True if sys.platform == 'linux': self._udp_client._sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) _, src_port = self._udp_client._sock.getsockname() self._udp_server = osc_server.BlockingOSCUDPServer( (self._host, src_port), self._dispatcher) Thread(target=self._udp_server.serve_forever, name='reaper_osc').start()
def __init__(self): print('Starting...') self.disp = dispatcher.Dispatcher() self.disp.map('/cc', self.ccRecieve) self.disp.map('/noteOn', self.noteOn) #self.client = udp_client.SimpleUDPClient('192.168.2.142', 57120) self.client = udp_client.SimpleUDPClient('100.75.0.230', 57120) self.server = osc_server.BlockingOSCUDPServer(('192.168.56.102', 7121), self.disp) #self.server = osc_server.BlockingOSCUDPServer(('192.168.56.102', 7121), #self.disp) self.message_listener = MessageListener(self.server) #self.client.send_message('/noteOn', (1, 60)) self.playing = True self.recording = False self.beat = 0.0 self.BPM = 80 self.BPS = self.BPM / 60 self.bar = 0 self.phrase = Stream() self.reply = None #self.player = BasicPlayer() self.player = DataReader() self.reply = self.player.generateBar() print('AI ready!') self.input_note = None self.input_cc = None self.message_listener.start() self.mainLoop() # clean up... self.message_listener.shutdown() self.message_listener.join()
def execute(self, context): global _report bcw = bpy.context.window_manager #For sending try: self.client = udp_client.UDPClient(bcw.addosc_udp_out, bcw.addosc_port_out) msg = osc_message_builder.OscMessageBuilder(address="/blender") msg.add_arg("Hello from Blender, simple test.") msg = msg.build() self.client.send(msg) except OSError as err: _report[1] = err return {'CANCELLED'} #Setting up the dispatcher for receiving try: self.dispatcher = dispatcher.Dispatcher() self.dispatcher.set_default_handler(OSC_callback_original) print("Create Server Thread on Port", bcw.addosc_port_in) # creating a blocking UDP Server # Each message will be handled sequentially on the same thread. # the alternative: # ThreadingOSCUDPServer creates loads of threads # that are not cleaned up properly self.server = osc_server.BlockingOSCUDPServer( (bcw.addosc_udp_in, bcw.addosc_port_in), self.dispatcher) self.server_thread = threading.Thread( target=self.server.serve_forever) self.server_thread.start() except OSError as err: _report[0] = err return {'CANCELLED'} #inititate the modal timer thread context.window_manager.modal_handler_add(self) self._timer = context.window_manager.event_timer_add( bcw.addosc_rate / 1000, window=context.window) context.window_manager.status = "Running" return {'RUNNING_MODAL'}
def main(): game = GameInstance(1) dspt = dispatcher.Dispatcher() mappings = { "/register_player":game.register_player, "/remove_player":game.remove_player, "/register_display":game.register_display_server, "/start":game.start_session, "/update_param/player/*":game.update_parameter } for k, v in mappings: dspt.map(k, v) dspt.set_default_handler(default_h) server = osc_server.BlockingOSCUDPServer(('', 5005),dspt) server.serve_forever()
def setup(self): # ColorTerminal().warn('OscReader-setup') if self.oscServer != None: self.destroy() ColorTerminal().output("Starting OSC Server with host {0} and port {1}".format(self.host, self.port)) dispatcher = Dispatcher() dispatcher.map('/marker', self.oscMarkerHandler) dispatcher.map("/rigidbody", self.oscRigidBodyHandler) try: self.oscServer = osc_server.BlockingOSCUDPServer((self.host, self.port), dispatcher) self.oscServer.handle_timeout = self.handleTimeout self.oscServer.timeout=0 #self.oscServer.serve_forever() except OSError as err: ColorTerminal().fail("Could not create OSC server: ", err) self.oscServer = None ColorTerminal().success("OSC Server running")
def start(self, input_port): if self.running: self.stop() if not self.parser.isLoaded(): log_data.append( "No configuration loaded, once you load a configuration the server will start" ) return for key, string in self.parser.getUdpClientStrings().items(): if string.split(":")[1] == str(input_port): log_data.append( "Cannot start server because the input port {0} is the same as the the output port for prefix '{1}'. Please change the input port." .format(input_port, key)) return try: dispatch = dispatcher.Dispatcher() for key in self.parser.getSceneMap(): dispatch.map("/scene/" + key, self.respond_to_scene) for number in self.parser.getMidiMap(): dispatch.map("/midi-scene/" + str(round(number / 127, 2)), self.respond_to_scene) dispatch.set_default_handler(self.route_message) self.server = osc_server.BlockingOSCUDPServer( ("0.0.0.0", input_port), dispatch) self.server_thread = Thread(target=self.server.serve_forever) self.server_thread.start() log_data.append( "\nServer started, listening on all interfaces on port {0}...\n" .format(input_port)) self.running = True except KeyboardInterrupt: print("Exiting...") sys.exit(0)
def start_background(): # parser = argparse.ArgumentParser() # parser.add_argument("--ip", # default="127.0.0.1", help="The ip to listen on") # parser.add_argument("--port", # type=int, default=9999, help="The port to listen on") # args = parser.parse_args() ip = '10.0.0.2' port = 9999 a_dispatcher = dispatcher.Dispatcher() a_dispatcher.map("/pot/0", update_kick_dist) a_dispatcher.map("/pot/1", update_kick_decay) a_dispatcher.map("/pot/2", update_kick_release) a_dispatcher.map("/pot/4", update_kick_pitch_high) a_dispatcher.map("/pot/3", update_kick_pitch_low) a_dispatcher.map("/pot/5", update_shuffle) # a_dispatcher.map("/pot/0", update_kick_roll) # a_dispatcher.map("/*", print) server = osc_server.BlockingOSCUDPServer((ip, port), a_dispatcher) print("Serving on {}".format(server.server_address)) server.serve_forever()
stroke.main(strokeCharacter) strokeCharacter = [] if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument("--ip", default="239.255.0.85", help="The ip (multicast or unicast) to listen on") parser.add_argument("--port", type=int, default=10085, help="The port to listen on") parser.add_argument("--ifaceip", default="10.10.10.35", help="The ip of the interface to listen on, if multicast") args = parser.parse_args() address = (args.ip, args.port) interface_addr = args.ifaceip dispatch = dispatcher.Dispatcher() # log_everything(dispatch) log_gesture(dispatch) #log_hand(dispatch) process_hand(dispatch) process_open_gesture(dispatch) #process_heartbeat(dispatch) # server = osc_server.ThreadingOSCUDPServer(address, dispatch, interface_addr) server = osc_server.BlockingOSCUDPServer((args.ip, args.port), dispatch, args.ifaceip) server.serve_forever()
def execute(self, context): global _report bcw = bpy.context.window_manager #For sending try: self.client = udp_client.UDPClient(bcw.addosc_udp_out, bcw.addosc_port_out) msg = osc_message_builder.OscMessageBuilder(address="/blender") msg.add_arg("Hello from Blender, simple test.") msg = msg.build() self.client.send(msg) except OSError as err: _report[1] = err return {'CANCELLED'} #Setting up the dispatcher for receiving try: self.dispatcher = dispatcher.Dispatcher() for item in bpy.context.scene.OSC_keys: #For ID custom properties (with brackets) if item.id[0:2] == '["' and item.id[-2:] == '"]': dataTuple = (1, eval(item.data_path), item.id, item.idx, make_tuple(item.osc_index)) self.dispatcher.map(item.address, OSC_callback_pythonosc, dataTuple) #For normal properties #with index in brackets -: i_num elif item.id[-1] == ']': d_p = item.id[:-3] i_num = int(item.id[-2]) dataTuple = (2, eval(item.data_path), d_p, i_num, make_tuple(item.osc_index)) self.dispatcher.map(item.address, OSC_callback_pythonosc, dataTuple) #without index in brackets else: try: if isinstance(getattr(eval(item.data_path), item.id), mathutils.Vector): dataTuple = (3, eval(item.data_path), item.id, item.idx, make_tuple(item.osc_index)) self.dispatcher.map(item.address, OSC_callback_pythonosc, dataTuple) elif isinstance(getattr(eval(item.data_path), item.id), mathutils.Quaternion): dataTuple = (3, eval(item.data_path), item.id, item.idx, make_tuple(item.osc_index)) self.dispatcher.map(item.address, OSC_callback_pythonosc, dataTuple) except: print("Improper setup received: object '" + item.data_path + "' with id'" + item.id + "' is no recognized dataformat") self.dispatcher.set_default_handler(OSC_callback_pythonosc_undef) print("Create Server Thread on Port", bcw.addosc_port_in) # creating a blocking UDP Server # Each message will be handled sequentially on the same thread. # the alternative: # ThreadingOSCUDPServer creates loads of threads # that are not cleaned up properly self.server = osc_server.BlockingOSCUDPServer( (bcw.addosc_udp_in, bcw.addosc_port_in), self.dispatcher) self.server_thread = threading.Thread( target=self.server.serve_forever) self.server_thread.start() # register the execute queue method bpy.app.timers.register(execute_queued_OSC_callbacks) except OSError as err: _report[0] = err return {'CANCELLED'} #inititate the modal timer thread context.window_manager.modal_handler_add(self) self._timer = context.window_manager.event_timer_add( bcw.addosc_rate / 1000, window=context.window) context.window_manager.status = "Running" return {'RUNNING_MODAL'}