def __init__(self): ''' OSC ''' 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=12345, help="The port the OSC server is listening on") args = parser.parse_args() self.client = udp_client.UDPClient(args.ip, args.port) parser1 = argparse.ArgumentParser() parser1.add_argument("--ip", default="127.0.0.1", help="The ip of the OSC server") parser1.add_argument("--port", type=int, default=12346, help="The port the OSC server is listening on") args1 = parser1.parse_args() self.client1 = udp_client.UDPClient(args1.ip, args1.port) print("initialized")
def main(): ipAddress = sys.argv[1] portToDriver = int(sys.argv[2]) portFromDriver = int(sys.argv[3]) toDriverUDPClient = udp_client.UDPClient(ipAddress, portToDriver) fromDriverUDPClient = udp_client.UDPClient(ipAddress, portFromDriver) tasks = [(toDriverUDPClient, getTestMessagesToDriver()), (fromDriverUDPClient, getTestMessagesFromDriver())] for udpClient, messages in tasks: for msg in messages: udpClient.send(msg)
def run(self, edit): self.settings = sublime.load_settings('Antescofo.sublime-settings') address = self.settings.get('antescofoip', 'localhost') port = self.settings.get('antescofoport', 5678) # Walk through each region in the selection for region in self.view.sel(): # If no region, then just send the line! if region.empty(): # Expand the region to the full line it resides on, excluding the newline line = self.view.line(region) # Extract the string for the line, and add a newline Contents = self.view.substr(line) + '\n' else: # if region, then send the region # Get the selected text Contents = self.view.substr(region) + '\n' # Send OSC message if pyosc: ## Send using pyosc client = OSC.OSCClient() client.connect((address, port)) oscmsg = OSC.OSCMessage('/antescofo/cmd') oscmsg.append('playstring') oscmsg.append(Contents) client.send(oscmsg) else: client = udp_client.UDPClient(address, port) oscmsg = osc_message_builder.OscMessageBuilder( address="/antescofo/cmd") oscmsg.add_arg("playstring") oscmsg.add_arg(Contents) oscmsg = oscmsg.build() client.send(oscmsg)
def send_questions_to_line_editor(): """ Sends data for display to Line Editor """ data = get_api_interact_data()['questions'] print("Called send question to the line editor") #client = udp_client.UDPClient(ip_osc_editor, port_client_editor,1) #builder = osc_message_builder.OscMessageBuilder(address='/textques') #for k,v in data.items(): # builder.add_arg(v) #builder.add_arg(.75) #print('builder ', builder.address) #client.send(builder.build()) #osc_dispatch('/textquest', .75, ip=ip_osc_server, port=port_client_editor) # print("sent {0} to {1}:{2}".format(builder.args, ip_osc_editor, port_client_editor)) ip = ip_osc port = port_client_editor client = udp_client.UDPClient(ip, port, 1) print("Send Data to Line Editor {}:{}", ip, port) builder = osc_message_builder.OscMessageBuilder(address='/textques') for k, v in data.items(): print(k, v) builder.add_arg(v) client.send(builder.build()) print("sent {0} to {1}:{2}".format(builder.args, ip, port)) broadcast_state() return None
def send_message(address, message): client = udp_client.UDPClient(server_ip, server_port) # msg = osc_message_builder.OscMessageBuilder(address=address) msg = osc_message_builder.OscMessageBuilder() msg.address = address msg.add_arg(message) client.send(msg.build())
def parse_config(): global config_dict global osc_client global messages_and_bundles global sources messages_and_bundles = {} success = True try: host = config_dict["HOST"] port = config_dict["PORT"] osc_client = udp_client.UDPClient(host, port) except Exception as e: print("ERROR: Invalid host/port config") print("Failed with exception", e) success = False if success: try: messages = config_dict["MESSAGES"] for msg_id in messages: msg = messages[msg_id] addr_id = msg["ADDRESS"] addr = config_dict["ADDRESSES"][addr_id] osc_msg = osc_message_builder.OscMessageBuilder(addr) for arg in msg["ARGUMENTS"]: osc_msg.add_arg(arg) messages_and_bundles[msg_id] = osc_msg.build() except Exception as e: print("ERROR: Message parsing failed") print("Failed with exception", e) success = False if success: try: for bnd_id in config_dict["BUNDLES"]: success = parse_bundle(bnd_id) if not success: break except Exception as e: print("ERROR: Bundle parsing failed") print("Failed with exception", e) success = False if success: for src_id in config_dict["SOURCES"]: msg_bnd_id = config_dict["SOURCES"][src_id] if msg_bnd_id in messages_and_bundles: sources[src_id] = msg_bnd_id else: print( "ERROR: Source parsing failed. No message or bundle found with the name \"" + msg_bnd_id + "\".") success = False break return success
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) self.server = osc_server.ThreadingOSCUDPServer((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, context.window) context.window_manager.status = "Running" return {'RUNNING_MODAL'}
def init_osc_sender(ip, port): osc_client = udp_client.UDPClient(ip, port) # 設定のログ出し print("[Sender] sender_ip:{}, sender_port:{}, address:/data".format( ip, port)) return osc_client
def createClient( self, hostname: str = None, port: int = None, enableBroadcast: bool = False, ) -> None: """ One client per instance. Client sends to server at hostname:port. """ if self._client: log.critical("Client is ALREADY CREATED.") self._validateHostnameAndPort(hostname, port) self._client = udp_client.UDPClient(self.hostname, self.port, enableBroadcast) # enableBroadcastString = "" if enableBroadcast: enableBroadcastString = " Broadcast IS ENABLED." log.info( f"Created client to {self.hostname}:{self.port}.{enableBroadcastString}" )
def respond_message(address='/1/status', data=0, client=None, port=9000): if client is not None: active_client = udp_client.UDPClient(client, port) msg = osc_message_builder.OscMessageBuilder(address=address) msg.add_arg(data) msg = msg.build() active_client.send(msg)
def do_osc(arg): print('Sending package') # client = udp_client.UDPClient('127.0.0.1', 5005) client = udp_client.UDPClient('localhost', 5005) msg = osc_message_builder.OscMessageBuilder(address="/debug") # msg.add_arg(random.random()) msg = msg.build() client.send(msg)
def __init__(self, un_seance_controller, ip, port): ''' Create a client UDP with an OSC protocol ''' self.seance_controller = un_seance_controller self.client = udp_client.UDPClient(ip, port)
def setupOutputServer(self, context, envars): #For sending self.outputServer = udp_client.UDPClient(envars.udp_out, envars.port_out) msg = osc_message_builder.OscMessageBuilder(address="/NodeOSC") msg.add_arg("Python server started up") msg = msg.build() self.outputServer.send(msg) print("Python Server sended test message to " + envars.udp_out + " on port " + str(envars.port_out))
def start_server_comms(): ip = "127.0.0.1" port = 57120 # SuperCollider client = udp_client.UDPClient(ip, port) osc_statemachine['status'] = RUNNING osc_msg = osc_message_builder.OscMessageBuilder osc_statemachine['osc_msg'] = osc_msg osc_statemachine['client'] = client
def preload_destinations(): for destination in config['destinations']: if not destination['name'] in destinations: if DEBUG: print("Adding client [" + destination['name'] + "]: " + destination['address'] + ":" + str(destination['port'])) destinations[destination['name']] = udp_client.UDPClient( destination['address'], destination['port'])
def test_send(self, mock_socket_ctor): mock_socket = mock_socket_ctor.return_value client = udp_client.UDPClient('::1', 31337) msg = osc_message_builder.OscMessageBuilder('/').build() client.send(msg) self.assertTrue(mock_socket.sendto.called) mock_socket.sendto.assert_called_once_with(msg.dgram, ('::1', 31337))
def run(self, edit): self.settings = sublime.load_settings('Antescofo.sublime-settings') address = self.settings.get('antescofoip', 'localhost') port = self.settings.get('antescofoport', 5678) ascographip = self.settings.get('ascographip', 'localhost') ascographport = self.settings.get('ascographport', 6789) filename = self.view.file_name() print('Antescofo Loading ', filename) if pyosc: # We are in Sublime 2! # send to Antescofo Max/Pd objects client = OSC.OSCClient() client.connect((address, port)) oscmsg = OSC.OSCMessage('/antescofo/cmd') oscmsg.append('score') oscmsg.append(filename) client.send(oscmsg) # send to Ascograph ascoclient = OSC.OSCClient() ascoclient.connect((ascographip, ascographport)) oscmsg2 = OSC.OSCMessage('/antescofo/loadscore') oscmsg2.append(filename) ascoclient.send(oscmsg2) else: # We are in Sublime 3 / use PythonOSC #filename = self.window.extract_variables()['file'] # Send to Antescofo object in Max/Pd client = udp_client.UDPClient(address, port) oscmsg = osc_message_builder.OscMessageBuilder( address="/antescofo/cmd") oscmsg.add_arg("score") oscmsg.add_arg(filename) oscmsg = oscmsg.build() client.send(oscmsg) # Send to AscoGraph if any ascoclient = udp_client.UDPClient(ascographip, ascographport) oscmsg2 = osc_message_builder.OscMessageBuilder( address="/antescofo/loadscore") oscmsg2.add_arg(filename) oscmsg2 = oscmsg2.build() ascoclient.send(oscmsg2)
def setupOSC(self): # setup OSC server ip = '127.0.0.1' port_num = 8002 parser = argparse.ArgumentParser() parser.add_argument("--ip", default=ip, help="The ip of th OSC Server") parser.add_argument("--port", type=int, default=port_num, help="The port the OSC server is listening on") args = parser.parse_args() self.client = udp_client.UDPClient(args.ip, args.port) print('OSC server on: ' + ip + ':' + str(port_num))
def main(): ip = '127.0.0.1' port = 6700 client = udp_client.UDPClient(ip, port) args = [0, 228, 123] data = OscMessageBuilder(address='/address') data.add_arg(args) data = data.build() client.send(data)
def prepare_synth_streaming(scHost=None, scPort=None, scMsg='/b_setn', scIndex=0, scFirstFrame=None): print("obci_wifi.eeg_channels_per_sample:", obci_wifi.eeg_channels_per_sample) global osc_sender_synth, osc_synth_addr, osc_beginning_arr # osc_sender_synth = udp_client.SimpleUDPClient(scHost, scPort) osc_sender_synth = udp_client.UDPClient(scHost, scPort) osc_synth_addr = scMsg osc_synth_num_messages = 1 + obci_wifi.eeg_channels_per_sample + 3 # counter, eeg, accelerometer print("scFirstFrame", scFirstFrame) if scFirstFrame is not None: osc_beginning_arr = [int(scIndex), int(scFirstFrame), int(osc_synth_num_messages)] else: osc_beginning_arr = [int(scIndex), int(osc_synth_num_messages)]
def __init__(self, ip="127.0.0.1", port=5005): self.beads = [] self.bgcolor = Color(0,0,0) self.effects = [] self.osc_ip = ip self.osc_port = port self.effect_id = 0; self.BEAD_COUNT=60 self.run_mainloop = False self.mainloop_delay = 0.03 self.effect_registry = {} self.osc_client = udp_client.UDPClient(self.osc_ip, self.osc_port) for i in range(self.BEAD_COUNT): self.beads.append(Bead(i)) # some useful predefined sets of beads self.Set_None = frozenset() self.Set_All = frozenset(self.beads) self.Set_Stem = frozenset(self.beads[0:4]) self.Set_Ring = frozenset(self.beads[4:60]) self.Set_Eighth0 = frozenset(self.beads[4:11]) self.Set_Eighth1 = frozenset(self.beads[11:18]) self.Set_Eighth2 = frozenset(self.beads[18:25]) self.Set_Eighth3 = frozenset(self.beads[25:32]) self.Set_Eighth4 = frozenset(self.beads[32:39]) self.Set_Eighth5 = frozenset(self.beads[39:46]) self.Set_Eighth6 = frozenset(self.beads[46:53]) self.Set_Eighth7 = frozenset(self.beads[53:60]) self.Set_Quadrent0 = frozenset(self.beads[4:18]) self.Set_Quadrent1 = frozenset(self.beads[18:32]) self.Set_Quadrent2 = frozenset(self.beads[32:46]) self.Set_Quadrent3 = frozenset(self.beads[46:60]) self.Set_Half01 = frozenset(self.Set_Quadrent0.union(self.Set_Quadrent1)) self.Set_Half12 = frozenset(self.Set_Quadrent1.union(self.Set_Quadrent2)) self.Set_Half23 = frozenset(self.Set_Quadrent2.union(self.Set_Quadrent3)) self.Set_Half30 = frozenset(self.Set_Quadrent3.union(self.Set_Quadrent0)) self.Set_Even_All = frozenset(self.beads[0:60:2]) self.Set_Even_Ring = frozenset(self.beads[4:60:2]) self.Set_Odd_All = frozenset(self.beads[1:60:2]) self.Set_Odd_Ring = frozenset(self.beads[5:60:2]) # some useful predefined colors self.Color_White = Color(1,1,1) self.Color_Red = Color(1,0,0) self.Color_Yellow = Color(1,1,0) self.Color_Green = Color(0,1,0) self.Color_Blue = Color(0,0,1) self.Color_Violet = Color(1,0,1) self.Color_Cyan = Color(0,1,1) self.Color_Black = Color(0,0,0)
def __init__(self): self.registered = False self.robot = Robot.Robot(secondes=ROBOT_UPDATE_TIME) #self.update_robot() self.dispatcher = dispatcher.Dispatcher() self.dispatcher.map("/clock", self.update_robot, "TEST") self.dispatcher.map("/hack", self.server_hack, "Hack") self.dispatcher.map("/player", self.get_player, "Player") self.server = osc_server.ThreadingOSCUDPServer(("0.0.0.0", 5006), self.dispatcher) self.server_thread = threading.Thread(target=self.server.serve_forever) self.server_thread.start() self.to_server_client = udp_client.UDPClient("255.255.255.255", 5005) self.to_client_client = udp_client.UDPClient("255.255.255.255", 5006) if hasattr(socket, 'SO_BROADCAST'): self.to_server_client._sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) if hasattr(socket, 'SO_BROADCAST'): self.to_client_client._sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) print("Registering to server...") msg = osc_message_builder.OscMessageBuilder(address="/register") msg.add_arg(player_name) msg.add_arg(my_ip) # msg = msg.build() self.to_server_client.send(msg) print("Waiting for server") self.root = tk.Tk() self.root.geometry('{}x{}'.format(200, 500)) self.root.protocol("WM_DELETE_WINDOW", self.on_closing) self.players_list = {} self.playerListBox = tk.Listbox() self.playerListBox.pack() self.playerListBox.insert(tk.END, player_name + " 0") self.root.mainloop()
def main(): global args global client args = setup() client = udp_client.UDPClient(args.ip, args.port) mqttc = mqtt.Client() mqttc.connect(HOST, PORT) mqttc.subscribe('wrapper') mqttc.on_message = on_message while True: mqttc.loop()
def main(): parser = argparse.ArgumentParser() parser.add_argument("destination", help="Destination UDP IP") parser.add_argument("--port", help="Destination UDP port", default=DEFAULT_UDP_PORT) parser.add_argument( "-v", "--visualise", help= "Send OSC to visualisation server, the format for this argument is ip:port" ) parser.add_argument("-d", "--debug", action="store_true") parser.add_argument("-l", "--log") opts = parser.parse_args() logging.basicConfig(level=logging.DEBUG if opts.debug else logging.INFO, ) client = udp_client.UDPClient(opts.destination, opts.port) def logging_callback(*_): pass def visualise_callback(_): pass if opts.log: logging_callback = Logger(opts.log).logging_callback if opts.visualise is not None: ip, port = opts.visualise.split(":") vis_client = udp_client.UDPClient(ip, int(port)) def visualise_callback(message): vis_client.send(message) server = Server(DEFAULT_SERVER_PORT, client, visualise_callback, logging_callback) server.run_forever()
def __init__(self): port_num = 8884 parser = argparse.ArgumentParser() parser.add_argument("--ip", default="127.0.0.1", help="The ip of th OSC Server") parser.add_argument("--port", type=int, default=port_num, help="The port the OSC server is listening on") args = parser.parse_args() self.client = udp_client.UDPClient(args.ip, args.port) print("ip:127.0.0.1, port:" + str(port_num) + ", address:/filter")
def init_osc(): parser = argparse.ArgumentParser() parser.add_argument("--ip", default="127.0.0.1", help="The ip of th OSC Server") parser.add_argument("--port", type=int, default=config.port_num, help="The port the OSC server is listening on") args = parser.parse_args() osc_client = udp_client.UDPClient(args.ip, args.port) # 設定のログ出し print("ip:127.0.0.1, port:" + str(config.port_num) + ", address:/data") return osc_client
def osc_dispatch(addr, msg, ip=ip_osc, port=port_client, num_tries=1): """ Dispatches a message in state change over OSC to all listeners """ client = udp_client.UDPClient(ip, port, 1) ## SimpleOSCClientRedux(client) ## client._sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) builder = osc_message_builder.OscMessageBuilder(address=addr) builder.add_arg(msg) for _ in range(num_tries): client.send(builder.build()) logger.info("Sending {0} with {1} to {2} at {3}, Attempt {4}".format( addr, msg, ip, port, _)) return None
def osc_dispatch(addr, msg, ip=ip_osc, port=port_client): """ Dispatches a message in state change over OSC to all listeners """ client = udp_client.UDPClient(ip, port, 1) ## SimpleOSCClientRedux(client) ## client._sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) print("Sent {0} with {1} to {2} at {3}".format(addr, msg, ip, port)) builder = osc_message_builder.OscMessageBuilder(address=addr) builder.add_arg(msg) client.send(builder.build()) ## print(client(addr, msg)) return None
def make_video(tag): clips = [] for video in mergeSequence: #print mergeSequence #print each video of the sequence and tagsself.and colors #filename = "./videos/" + video['id'] filename = video["path"] #print video #print filename clip = Clip(filename, start=video['start'], end=video['end']) if "abstract" in video["tags"]: clip.fadein(1) clip.fadeout(1.5) if video in beginning: clip.fadein(3) if video in ending: clip.fadeout(1.5) if video in randomSounds: clip.fadein(1) clip.fadeout(1.5) clip.glow() clips.append(clip) #print (mergeSequence[0]["id"]) composition = Composition(clips, singletrack=True, width=800, height=800) #videoName = "render/videoConnected10" + datetime.datetime.now().strftime("%Y%m%d%H%M%S") +".mp4" # videoName = "render/video_" + tag + datetime.datetime.now().strftime("%Y%m%d%H%M%S") +".mp4" videoName = "render/video_" + tag + datetime.datetime.now().strftime( "%Y%m%d%H%M%S") + ".mov" composition.save(videoName) #composition.save(videoName) #datetime.datetime.now().strftime("%Y%m%d%H%M&S") #setup a client (api adress, localhost) client = udp_client.UDPClient("127.0.0.1", 8000) print("testing message") #composition.preview() #now built the messagingSenderId msg = osc_message_builder.OscMessageBuilder(address="/video") msg.add_arg("nature") msg = msg.build() client.send(msg)
def __init__(self): self._is_running = True self._points = [] dispatcher = Dispatcher() dispatcher.map(self.POINTS_LABEL, self._points_handler) dispatcher.map(self.STOP_LABEL, self._stop_handler) self._server = osc_server.ThreadingOSCUDPServer((self.IP, self.RECV_PORT), dispatcher) self._thread = Thread(target=self._recv_thread) self._thread.start() self._client = udp_client.UDPClient(self.IP, self.SEND_PORT) self._event = Event() self._semphore = Semaphore()