def __init__(self, ip: str = "127.0.0.1", port_in: int = 8081, port_out: int = 8080, recv_address: str = "/pyosc", parse_parenthesis_as_list: bool = False, discard_duplicate_arguments: bool = True, send_format: SendFormat = SendFormat.FLATTEN, osc_log_level: Optional[int] = logging.INFO): """ :param ip: :param port_in: :param port_out: :param parse_parenthesis_as_list: :param send_format: :param osc_log_level: Forward log messages to Max. Will not forward if set to None. To forward only some messages, override _handle_max_osc_error, _handle_type_error or _handle_error """ super(MaxOsc, self).__init__(parse_parenthesis_as_list, discard_duplicate_arguments) self.logger = logging.getLogger(__name__) self.sender: Sender = Sender(ip, port_out, send_format) if osc_log_level: handler: OscLogHandler = OscLogHandler(self.sender, osc_log_level) self.logger.addHandler(handler) dispatcher = Dispatcher() dispatcher.map(recv_address, self.main_callback) dispatcher.set_default_handler(self._default_handler) self._server = BlockingOSCUDPServer((ip, port_in), dispatcher) self.logger.info( f"MaxOsc initialized on ip {ip} with incoming port {port_in} and outgoing port {port_out}." )
def __init__(self, *args, **kwargs): super(OSCServer, self).__init__(*args, **kwargs) self.parser.add_argument("--ip", help="IP for the OSC Server to listen on", default="0.0.0.0") self.parser.add_argument("--port", help="Port for the OSC Server to listen on", default=1337) self.dispatcher = Dispatcher() self.dispatcher.set_default_handler(self.osc_recv)
def __init__(self, machine): """Initialise switch player.""" self.log = logging.getLogger('OSC Plugin') self.machine = machine # type: MachineController if 'osc_plugin' not in machine.config: machine.log.debug('"osc_plugin:" section not found in ' 'machine configuration, so the OSC' 'plugin will not be used.') return if not Dispatcher: raise AssertionError( "To use the OSC plugin you need to install the pythonosc extension." ) self.config = self.machine.config['osc_plugin'] self.machine.config_validator.validate_config("osc_plugin", self.config) if not self.config['enabled']: return self.dispatcher = Dispatcher() self.dispatcher.map("/sw/*", self.handle_switch) self.server = AsyncIOOSCUDPServer( (self.config['server_ip'], self.config['server_port']), self.dispatcher, self.machine.clock.loop) self.machine.events.add_async_handler("init_phase_5", self._start) self.client = SimpleUDPClient(self.config['client_ip'], self.config['client_port'])
def __init__(self, osculator_client, audience_client, performer_client, machine, beat_manager, tonality): self.osculator_client = osculator_client self.audience_client = audience_client self.performer_client = performer_client self.song_machine = machine self.beat_manager = beat_manager self.tonality = tonality dispatcher = Dispatcher() dispatcher.map(settings.INTERPRETER_TARGET_ADDRESS, self.interpreter_handler) dispatcher.map(settings.SONG_BEAT_ADDRESS, self.beat_handler) dispatcher.map(settings.SONG_SYNTH_RESET_ADDRESS, self.reset_handler) self.server = ThreadingOSCUDPServer( (settings.ip, settings.SONG_SERVER_PORT), dispatcher) self.song_scenes = { k: v for k, v in zip(self.song_machine.parser.song_parts, range(len(self.song_machine.parser.song_parts))) } self.osculator_client.send_message( settings.SONG_ADVANCE_ADDRESS, (self.song_machine.parser.INTRO_NOTE, 1.0)) self.osculator_client.send_message( settings.SONG_ADVANCE_ADDRESS, (self.song_machine.parser.INTRO_NOTE, 0.0)) self.osculator_client.send_message('/mid_{}'.format('praise'), self.tonality.synth.ctrl_message) self._send_init_to_display()
async def init_main(): """ Asynchronous main, to be called from main() """ global config global outputs print("Setting up dispatcher") dispatcher = Dispatcher() dispatcher.map("/*", update_outputs) print("Starting Client for {}:{}".format(config["Client"]["ip"], config["Client"]["port"])) client = udp_client.SimpleUDPClient(config["Client"]["ip"], config["Client"]["port"]) client.send_message("/setBankStart", 1.0) client.send_message("/1/busOutput", 1.0) outputs.register_client(client) print("Starting Server at {}:{}".format(config["Server"]["ip"], config["Server"]["port"])) server = AsyncIOOSCUDPServer( (config["Server"]["ip"], config["Server"]["port"]), dispatcher, asyncio.get_event_loop()) # Create datagram endpoint and start serving transport, protocol = await server.create_serve_endpoint() print("Listening...") await loop() transport.close()
def __init__(self): # IP address, if you want to communicate with a device on the same network, you probably need to change stuff here. # especially differentiate between the PC and the device IP. However, this allows you to run processing on android # but do optimization on desktop and still have wireless communication. self.ip = "127.0.0.1" # the port we receive data from processing on self.receiving_port = 12001 # the port where processing expects data to be send. self.sending_port = 12000 # OSC works with addresses. Basically we can filter on the incoming address and have different handler based on an address. # in a case we dont recoginize the address, we use the default handler. self.dispatcher = Dispatcher() self.dispatcher.map("/filter", self.print_handler) self.dispatcher.map("/quit", self.quit_handler) self.dispatcher.set_default_handler(self.default_handler) # the client we use for sending data. self.sending_client = SimpleUDPClient( self.ip, self.sending_port) # Create client # a boolean to see whether we need to quit the server based on incoming messages. self.run = True
def main_func(ip, port): dispatcher = Dispatcher() dispatcher.map("/Chordata/r*", data_handler) dispatcher.set_default_handler(default_handler) server = BlockingOSCUDPServer((ip, port), dispatcher) server.serve_forever() # Blocks forever
def init_tuio_interface(self): dispatcher = Dispatcher() dispatcher.map( "/tuio2/frm", self.on_new_frame_message, needs_reply_address=True) # Also pass on the IP of the data origin dispatcher.map("/tuio2/ptr", self.on_new_pointer_message, needs_reply_address=True) dispatcher.map("/tuio2/bnd", self.on_new_bounding_box_message, needs_reply_address=True) dispatcher.map("/tuio2/tok", self.on_new_token_message, needs_reply_address=True) dispatcher.map("/tuio2/dat", self.on_new_data_message, needs_reply_address=True) dispatcher.map("/tuio2/ctl", self.on_new_control_message, needs_reply_address=True) dispatcher.map("/tuio2/alv", self.on_new_alive_message, needs_reply_address=True) print('IP, PORT', self.ip, PORT) osc_udp_server = ThreadingOSCUDPServer((self.ip, PORT), dispatcher) print( '[SensorDataInterface]: Listening on {} for incoming TUIO messages' .format(osc_udp_server.server_address)) server_thread = threading.Thread(target=osc_udp_server.serve_forever) server_thread.start()
async def init_main(): """ https://python-osc.readthedocs.io/en/latest/server.html#async-server https://web.archive.org/web/20170809181820/http://developer.choosemuse.com/research-tools-example/grabbing-data-from-museio-a-few-simple-examples-of-muse-osc-servers https://addshore.com/2018/06/python3-using-some-shared-state-in-2-async-methods/ :return: """ # with the connection made and inital state set, can start the main loops. # https://python-osc.readthedocs.io/en/latest/dispatcher.html # https://python-osc.readthedocs.io/en/latest/server.html#async-server event_loop_local = asyncio.get_event_loop() dispatcher = Dispatcher() dispatcher.map("/muse/elements/experimental/concentration", concentration_handler) # creates an OSC server that's Async. server = osc_server.AsyncIOOSCUDPServer((IP, OSC_PORT), dispatcher, event_loop_local) transport, protocol = await server.create_serve_endpoint( ) # Create datagram endpoint and start serving print("OSC server running.") await dummy_loop() transport.close() # Clean up server endpoint
def __init__(self, address=("127.0.0.1", 9000), listen_port=9001): self.beat_callback = None self.startup_callback = None self.listen_port = listen_port #------------------------------------------------------------------------ # Handler callbacks for particular messages from Live. # Used so that other processes can register callbacks when states change. #------------------------------------------------------------------------ self.handlers = {} self.osc_address = address self.osc_client = SimpleUDPClient(address[0], address[1]) dispatcher = Dispatcher() dispatcher.set_default_handler(self.handler) self.osc_server = BlockingOSCUDPServer(("127.0.0.1", listen_port), dispatcher) self.osc_server_thread = None self.osc_read_event = None self.osc_timeout = 3.0 self.osc_server_events = {} self.query_address = None self.query_rv = [] self.listen()
def InitNetwork(self, client_ip, client_port, listen_port): # client self.client = udp_client.SimpleUDPClient(client_ip, client_port) PrintManager("Connecting client on port {}.".format(client_port), 4) # server callbacks dispatch = Dispatcher() dispatch.map("/move*", self.MoveNozzle) # /move/extrude and /move dispatch.map("/extrude", self.ExtractMaterial) dispatch.map("/retract", self.RetractMaterial) dispatch.map("/req/nozzle_pos", self.RequestNozzlePosition) dispatch.set_default_handler( lambda _: PrintManager("Received message.", 1)) # TODO: Add other functions # server loop = asyncio.get_event_loop() self.server = AsyncIOOSCUDPServer(("127.0.0.1", listen_port), dispatch, asyncio.get_event_loop()) PrintManager("Serving on {}:{}".format("127.0.0.1", listen_port), 4) self.server.serve() # start the event loop for server self.osc_thread = threading.Thread(target=loop.run_forever) self.osc_thread.daemon = True self.osc_thread.start()
def __init__(self, ip, receive_from_port, quit_event, address_list=["/clock*"], address_handler_list=[None]): """ Constructor for OSC_SENDER CLASS :param ip: ip address of client ==> 127.0.0.1 (for local host/ inter app communication on same machine) :param receive_from_port: the port on which python listens for incoming data """ super(OscReceiver, self).__init__() self.setDaemon( True) # don't forget this line, otherwise, the thread never ends self.ip = ip self.receiving_from_port = receive_from_port self.listening_thread = None self.dispatcher = Dispatcher() for ix, address in enumerate(address_list): self.dispatcher.map(address, address_handler_list[ix]) self.dispatcher.set_default_handler(self.default_handler) self.server = BlockingOSCUDPServer((self.ip, self.receiving_from_port), self.dispatcher) #self.server.request_queue_size = 0 self.quit_event = quit_event
def __init__(self): #User configurable parameters self.limit = 4 self.tour_video_layer = 17 self.tour_video_clip = 2 self.tour_video_button_id = 0 self.box_video_layer = 16 self.box_video_start_column = 10 self.box_waiting_video_layer = 15 self.blank_waiting_video_column = 10 #OSC related self.osc_client = SimpleUDPClient("127.0.0.1", 7000) self.osc_dispatcher = Dispatcher() self.osc_dispatcher.map("/composition/layers/*/clips/*/connected", self.video_handler) self.osc_dispatcher.set_default_handler(self.debug_handler) #Internal variables self.items = [] self.current_clip = 0 self.current_layer = 0 self.playing_tour_video = False self.playing_idle_video = False self.loop = asyncio.get_running_loop() self.current_box_waiting_video_layer = 0 self.waiting_list = []
def main(args): includes = DEFAULT_INCLUDES + args.include dispatcher = Dispatcher() dispatcher.map("/remove", remove_handler, "Remove") dispatcher.map("/detach", detach_handler, "Detach") dispatcher.map("/slur_oneshot", slur_handler, "Slur") dispatcher.map("/tie_oneshot", tie_handler, "Tie") dispatcher.map("/text_spanner_oneshot", text_spanner_handler, "Text Spanner") dispatcher.map("/notehead_oneshot", notehead_handler, "Notehead") dispatcher.map("/bar_line_oneshot", bar_line_handler, "BarLine") dispatcher.map("/articulation_oneshot", articulation_handler, "Articulation") dispatcher.map("/dynamic_oneshot", dynamic_handler, "Dynamic") dispatcher.map("/dynamicTrend_oneshot", dynamicTrend_handler, "DynamicTrend") dispatcher.map("/literal_oneshot", literal_handler, "Literal") dispatcher.map("/markup_oneshot", markup_handler, "Markup") dispatcher.map("/note_event", note_handler, "Note") dispatcher.map("/display", display_handler, "Display") server = osc_server.ThreadingOSCUDPServer((args.host, args.port), dispatcher) print("Serving on {}".format(server.server_address)) server.serve_forever()
def start_server_to_listen(self, imu_handler, emg_handler): self.file_counter += 1 dispatcher = Dispatcher() dispatcher.map("/imu", imu_handler) dispatcher.map("/emg", emg_handler) self.server = osc_server.OSCUDPServer((self.ip, self.port), dispatcher) print("Serving on {}".format(self.server.server_address)) self.server.serve_forever()
def run(self) -> None: """ raises: OSError is server already is in use """ osc_dispatcher: Dispatcher = Dispatcher() osc_dispatcher.map(self.SERVER_ADDRESS, self.__process_osc) osc_dispatcher.set_default_handler(self.__unmatched_osc) self._server: BlockingOSCUDPServer = BlockingOSCUDPServer( (Server.DEFAULT_IP, self._inport), osc_dispatcher) self._server.serve_forever()
def run_server_forever(self): dispatcher = Dispatcher() dispatcher.map('/note_on', self._note_on_handler) dispatcher.map('/note_off', self._note_off_handler) server = osc_server.ThreadingOSCUDPServer((self.ip, self.port), dispatcher) print('Serving on {}'.format(server.server_address)) server.serve_forever()
def __init__(self, port): print(f'Setting up Receiver with port: {port}') self.dispatcher = Dispatcher() self.server = BlockingOSCUDPServer(('127.0.0.1', port), self.dispatcher) self.dispatcher.set_default_handler(self.handleMessage) self.thread = Thread(target=self.run) self.thread.start()
def __init__(self, address, state): self.state = state dispatcher = Dispatcher() dispatcher.set_default_handler(self.msg_handler) self.server = OSCClientServer((address, self.XAIR_PORT), dispatcher) worker = threading.Thread(target=self.run_server) worker.daemon = True worker.start()
def __init__(self, host='0.0.0.0', port=5300): self.dispatcher = Dispatcher() self.dispatcher.map("/state", self.setState) self.oscServer = ThreadingOSCUDPServer((host, port), self.dispatcher) self.oscServerThread = threading.Thread( target=self.oscServer.serve_forever, daemon=True) self.state = -1
def main_func(): ip = "localhost" port = 6565 dispatcher = Dispatcher() dispatcher.set_default_handler(default_handler) server = BlockingOSCUDPServer((ip, port), dispatcher) server.serve_forever()
def connecta_osc(self): self.disp = Dispatcher() self.disp.map(OSC_TIME_ROUTES[0], self.getTimeFromOscPlayer1) self.disp.map(OSC_TIME_ROUTES[1], self.getTimeFromOscPlayer2) self.disp.map(OSC_FILE_NAMES[0], self.getFileFromOscPlayer1) self.disp.map(OSC_FILE_NAMES[1], self.getFileFromOscPlayer2) self.disp.map(OSC_LAYER_PAUSED[0], self.getPauseFromOscPlayer1) self.disp.map(OSC_LAYER_PAUSED[1], self.getPauseFromOscPlayer2) self.srv = BlockingOSCUDPServer( (self.ip, self.port), self.disp)
def _start_server(self): dispatcher = Dispatcher() self.server = OSCClientServer(("0.0.0.0", self.args.port), self.ardour_addr, dispatcher, self._service_action) dispatcher.map("/rec_enable_toggle", self.handle_rec_enable_toggle) dispatcher.map("/record_tally", self.handle_record_tally) dispatcher.map("/heartbeat", self.handle_heartbeat) dispatcher.set_default_handler(self.handle_any)
def server(): dispatcher = Dispatcher() server = ThreadingOSCUDPServer(("127.0.0.1", SERVER_PORT), dispatcher) server_thread = threading.Thread(target=server.serve_forever) server_thread.daemon = True server_thread.start() yield server server.shutdown() server_thread.join()
def osc_server(): dispatcher = Dispatcher() dispatcher.map("/lightstick/preset", preset_handler) dispatcher.set_default_handler(default_handler) ip = "0.0.0.0" port = 5000 server = BlockingOSCUDPServer((ip, port), dispatcher) server.serve_forever()
def main_func(): dispatcher = Dispatcher() dispatcher.map("/%/*", data_handler) dispatcher.set_default_handler(default_handler) ip = "localhost" port = 6565 server = BlockingOSCUDPServer((ip, port), dispatcher) server.serve_forever() # Blocks forever
def configureDispatcher(self): # setting the object which receives the messages and decides where to send them dispatcher = Dispatcher() dispatcher.map("/inputs/key_mapping/*", self.set_keyMappings) dispatcher.map("/inputs/key_on/gen_MIDI", self.set_genMIDI) dispatcher.map("/inputs/key_on", self.keyOn) dispatcher.map("/inputs/key_off", self.keyOff) dispatcher.set_default_handler(self.default_handler) return dispatcher
def __init__( self, server_ip: str, server_port: int, default_receiver_ip: str, default_receiver_port: int, ) -> None: """Create an OSC communication server Parameters ---------- server_ip : str IP address to use for this server server_port : int port to use for this server default_receiver_ip : str IP address used for sending by default default_receiver_port : int port used for sending by default """ self._receivers: Dict[Tuple[str, int], str] = {} self._default_receiver: Tuple[str, int] = ( default_receiver_ip, default_receiver_port, ) # bundling messages support self._bundling_lock = RLock() self._bundling_bundles = [] # create server while True: try: self._osc_server = ThreadingOSCUDPServer( (server_ip, server_port), Dispatcher()) self._osc_server_running = True _LOGGER.debug("This OSCCommunication instance is at port: %s", server_port) break except OSError as error: if error.errno == errno.EADDRINUSE: server_port += 1 # start server thread self._osc_server_thread = threading.Thread( target=self._osc_server.serve_forever) self._osc_server_thread.daemon = True self._osc_server_thread.start() # init queues for msg pairs, must be after self._osc_server self._msg_queues: Dict[str, MessageQueue] = {} self._reply_addresses: Dict[str, str] = {} atexit.register(self.quit)
def main(): ip = '127.0.0.1' port = 6700 # URLにコールバック関数を割り当てる dispatcher = Dispatcher() dispatcher.map('/address', handler) # サーバを起動する server = osc_server.ThreadingOSCUDPServer((ip, port), dispatcher) print('Server Start IP={} PORT={}'.format(ip, port)) server.serve_forever()
def __init__(self): self.dispatcher = Dispatcher() self.dispatcher.map("/realsense*", self._onMessageReceived) self.server = osc_server.ThreadingOSCUDPServer((IP, PORT), self.dispatcher) self.raw = (0.0, 0.0, 0.0) self.offset = [0.0, 0.0, 0.0] self.distance_cach = (0.0, 0.0, 0.0) self.thread = threading.Thread(target=self._thread) self.thread.setDaemon(True) self.thread.start()