class PacketManager(object): def __init__(self, num_datapoints, port=DEFAULTPORT): self.num_datapoints = num_datapoints self.data_source = None self.client = OSCClient() self.client.connect(("localhost", port)) def add_data_source(self, data_source): self.data_source = data_source def send_to_max(self): bundle = OSCBundle() for i in range(NUM_CAPS_AND_POTS): bundle.append({ 'addr': "/d" + str(i) + "/hz", 'args': self.data_source.get_pitch_data(i) }) bundle.append({ 'addr': "/d" + str(i) + "/on", 'args': self.data_source.get_cap_data(i) }) bundle.append({ 'addr': "/duration", 'args': self.data_source.get_duration_data() }) bundle.append({ 'addr': "/mod", 'args': self.data_source.get_mod_data() }) self.client.send(bundle)
class oscSender(object): def __init__(self,port): self.client = OSCClient() self.client.connect( ("172.16.1.110", port) ) print "Started server on port : " + str(port) def newNode(self,args,BSSID,kind): msg = OSCMessage("/new" ) msg.append(kind.strip()) msg.append(args) msg.append(BSSID.strip()) self.client.send(msg) # print "new" def updateNode(self,args,BSSID,kind): if BSSID == " ": return msg = OSCMessage("/update") msg.append(kind.strip()) msg.append(args) msg.append(BSSID.strip()) self.client.send(msg) # print "update" def removeNode(self,args,BSSID, kind): msg = OSCMessage("/remove") msg.append(kind.strip()) msg.append(args) msg.append(BSSID.strip()) self.client.send(msg) def closeConnection(self): self.client.send( OSCMessage("/quit", args ) )
class SendOSC(object): def __init__(self): self.osc_message = None self.osc_client = OSCClient() self.osc_message = OSCMessage() self.ip = "" self.port = 0 def connect(self, ip="localhost", port=8080): self.ip = ip self.port = port self.osc_client.connect((self.ip, self.port)) def send(self, address, value): self.osc_message.setAddress(address) self.osc_message.append(value) self.osc_client.send(self.osc_message) def send_distane(self, distance): oscdump = "/dumpOSC/DistanceTipTarget" self.send(oscdump, distance) def send_needle_tip_position(self, x, y, z): oscdump = "/dumpOSC/needltip/x" self.send(oscdump, x) oscdump = "/dumpOSC/needltip/y" self.send(oscdump, y) oscdump = "/dumpOSC/needltip/z" self.send(oscdump, z)
def setup(): # OSC global client client = OSCClient() client.connect(("localhost", 7300)) # DISPLAY window_width = 640 window_height = 480 # OPENCV # img = cv2.imread(filename) global camera camera = cv2.VideoCapture(0) camera.set(3, window_width) camera.set(4, window_height) # ds_factor = 1.0 # FACIAL FEATURES DETECTORS global face_detector, mouth_detector, smile_detector, nose_detector, right_eye_detector, left_eye_detector face_detector = FaceDetector() # eye_detector = EyeDetector() mouth_detector = MouthDetector() smile_detector = SmileDetector() nose_detector = NoseDetector() # right_ear_detector = RightEarDetector() right_eye_detector = RightEyeDetector() left_eye_detector = LeftEyeDetector()
def messageServer(self, messagePath, argument): client = OSCClient() client.connect((self.serverIP, self.serverPort)) message = OSCMessage(messagePath) message.append(argument) client.send(message)
def __init__(self, joints=None, max_port=5555): if joints is None: self.joints = [ 'righthand', 'lefthand', 'rightfoot', 'leftfoot', 'head', 'torso' ] else: self.joints = joints self.coords = {k: (0., 0., 0.) for k in self.joints} self.prev_coords = {k: (0., 0., 0.) for k in self.joints} self.joint_speed = {k: False for k in self.joints} self.speed_piano = { 'lefthand': { X: 0, Y: 0 }, 'righthand': { X: 0, Y: 0 } } self.kinect_client = OSCClient() self.max_client = OSCClient() self.server = OSCServer(('127.0.0.1', 12345)) self.kinect_client.connect(('127.0.0.1', 12346)) self.max_client.connect(('127.0.0.1', max_port)) self.server.addMsgHandler('default', self.process_message) self.flipped = False self.speed = 0. self.speed_ramp = 0. sprout(self.server.serve_forever) sprout(self._remind_synapse)
def main(): global client, group, clientOSC try: rospy.init_node("test_move", anonymous=True, disable_signals=True) client = actionlib.SimpleActionClient('follow_joint_trajectory', FollowJointTrajectoryAction) print "Waiting for server..." client.wait_for_server() print "Connected to server" parameters = rospy.get_param(None) print "============ Starting tutorial setup" moveit_commander.roscpp_initialize(sys.argv) time.sleep(1) robot = moveit_commander.RobotCommander() group = moveit_commander.MoveGroupCommander("manipulator") clientOSC = OSCClient() clientOSC.connect( ("192.168.1.51", 12000) ) thread.start_new_thread ( printRoll, () ) move1() except KeyboardInterrupt: rospy.signal_shutdown("KeyboardInterrupt") raise
def __init__(self, address, state): self.state = state self.server = OSCServer(("", 0)) self.server.addMsgHandler("default", self.msg_handler) self.client = OSCClient(server = self.server) self.client.connect((address, self.XAIR_PORT)) thread.start_new_thread(self.run_server, ())
def __init__(self, address="localhost", port=3333): self.address = "localhost" self.port = 3333 self.client = OSCClient() self.client.connect((address, port)) self.fseqCount = -1 self.alive = []
def init(osc_setup): host, port, root = osc_setup client = OSCClient() client.connect((host, port)) print "Connected to the OSC server %s:%s%s" % osc_setup send_parameter('osd_initialized', 'Done') return client
def send_oscbundle(self): # send a bundle with current bpm and polar coordinates of # sound-objects relative to player # /game/bpm client = OSCClient() bpm = OSCMessage() bpm.setAddress("/game/bpm") bpm.append(self.player['bpm']) bundle = OSCBundle() bundle.append(bpm) # /game/sndobj/id-bola (ang, mod) scn = bge.logic.getCurrentScene() play = scn.objects["player"] for ball in self.soundobjects: ballpos = ball.worldPosition vect = mathutils.Vector((0,1)) dist = play.getVectTo(ballpos)[0] vect2 = play.getVectTo(ballpos)[2].to_2d() angle = math.degrees(-vect.angle_signed(vect2)) #print("angle ", angle, "distancia ",dist) data = (angle, dist) # append data to bundle msg = OSCMessage() tag = "/game/sndobj/position/" + str(ball['id']) msg.setAddress(tag) msg.append(data) bundle.append(msg) #print(msg) #gl.client is a tuple in gl with ip and port client.sendto(bundle, gl.send_to)
def init(osc_setup): host, port, root = osc_setup client = OSCClient() client.connect( (host, port) ) print "Connected to the OSC server %s:%s%s" %osc_setup send_parameter('osd_initialized','Done') return client
class slOscSend: """ Osc Sender """ def __init__(self, adr, port): self.ip_adr = adr self.port = port self.destination = (self.ip_adr, self.port) # self.client = OSC.OSCClient() self.client = OSCClient() self.client.connect(self.destination) self.adr = "/unset" self.str = 'IP: ' self.str += self.ip_adr self.str += ' PORT: ' self.str += str(port) print(self.str) def send(self, adr, *args): self.adr = adr # msg = OSC.OSCMessage() msg = OSCMessage() msg.setAddress(self.adr) for i in args: msg.append(i) try: self.client.send(msg) except: print ">>> ERR :: Could not connect to ", self.ip_adr, ":", self.port
def main(): global bRun global inOSCport, outOSCport global myOSC_Server, myOSC_Client global cTrial, nTrials, breaksxTrial cTrial = 1 global debug_data global CS_US_1 CS_US_1['inputs']=[] cerebellumConfig['weights']=[] cerebellumConfig['config']=[] cerebellumConfig['constants']=[] debug_data['trials']=[] if save_bases: debug_data['basis']=[] debug_data['inputs']=[] inOSCport = 1234 outOSCport = 1235 # myOSC_Server = OSCServer( ('' , inOSCport) ) # myOSC_Client = OSCClient() # myOSC_Client.connect( ('10.0.0.116' , outOSCport) ) myOSC_Server = OSCServer( ('127.0.0.1' , inOSCport) ) myOSC_Client = OSCClient() myOSC_Client.connect( ('127.0.0.1' , outOSCport) ) print "Receiving messages /trial,/input in port", inOSCport print "Sending messages to port", outOSCport myOSC_Server.addMsgHandler("/config", receiveConfig) myOSC_Server.addMsgHandler("/trial", receiveTrial) myOSC_Server.addMsgHandler("/endtrial", receiveEndTrial) myOSC_Server.addMsgHandler("/input", receiveInput) myOSC_Server.addMsgHandler("/debug", receiveDebug) myOSC_Server.addMsgHandler("/update", receiveUpdate) myOSC_Server.addMsgHandler("/freeze", receiveFreeze) myOSC_Server.addMsgHandler("/saveConfig", receiveSaveConf) # if (cTrial==nTrials): # pl.figure(figsize=(10,6)) # plot(breaksxTrial) print "Ready" myOSC_Server.serve_forever()
def __init__(self, ip='localhost', port=12345, address="/openbci"): # connection infos self.ip = ip self.port = port self.address = address self.client = OSCClient() self.client.connect((self.ip, self.port)) self.board = bci.OpenBCIBoard()
def connectOsc(): global client, timeLastConnection if timeLastConnection < time.time() - 7200: print("connecting to OSC server") updateDNS() client = OSCClient() client.connect( ("146.164.80.56", 22244) ) timeLastConnection = time.time()
def connectOsc(): global client, timeLastConnection if timeLastConnection < time.time() - 7200: # Reconnect every two hours print("connecting to OSC server") updateDNS() client = OSCClient() client.connect(("146.164.80.56", 22244)) timeLastConnection = time.time()
def __init__(self, ip, port,address="/openbci"): self.ip = ip self.port = port self.address = address # init network print "Selecting OSC streaming. IP: ", self.ip, ", port: ", self.port, ", address: ", self.address self.client = OSCClient() self.client.connect( (self.ip, self.port) )
def sendOSCnextlevel(): client = OSCClient() msg = OSCMessage() # gl.client is a tuple in gl with ip and port address = "/game/nextlevel" msg.setAddress(address) msg.append(currentlevel) client.sendto(msg, gl.send_to) #print('Send message example =', msg, "to ", gl.send_to) return
def main(): # OSC SERVER myip = socket.gethostbyname(socket.gethostname()) myip = "127.0.0.1" print("IP adress is : "+myip) try: server = SimpleServer((myip, 12354)) except: print(" ERROR : creating server") print("server created") try: st = threading.Thread(target = server.serve_forever) except: print(" ERROR : creating thread") try: st.start() except: print(" ERROR : starting thread") print(" OSC server is running") # OSC CLIENT global client client = OSCClient() client.connect( ('127.0.0.1', 9998)) #START ON BOOT global machine machine = 7 start_app() # MAIN LOOP global runningApp runningApp = True print(" ===== STARTING MAIN LOOP ====" ) while runningApp: # This is the main loop # Do something here try: time.sleep(1) except: print("User attempt to close programm") runningApp = False #CLOSING THREAD AND SERVER print(" Ending programme") server.running = False print(" Join thread") st.join() server.close() print(" This is probably the end")
def get_osc_client(host='localhost', port=defaults['port'], say_hello=False): # String, int -> OSCClient client = OSCClient() client.connect((host, port)) # TODO Make this work if say_hello: send_simple_message(client, "/hello", timeout=None) return client
def activate(self): if len(self.args) > 0: self.ip = self.args[0] if len(self.args) > 1: self.port = int(self.args[1]) if len(self.args) > 2: self.address = self.args[2] # init network print "Selecting OSC streaming. IP: ", self.ip, ", port: ", self.port, ", address: ", self.address self.client = OSCClient() self.client.connect((self.ip, self.port))
def send_destroy(self,id): # client = OSCClient() msg = OSCMessage() # gl.client is a tuple in gl with ip and port address = "/game/sndobj/destroy" msg.setAddress(address) msg.append(id) client.sendto(msg, gl.send_to) #print('Send message example =', msg, "to ", gl.send_to) return
def send_choque(self): # client = OSCClient() msg = OSCMessage() # gl.client is a tuple in gl with ip and port address = "/player/choque" msg.setAddress(address) msg.append(0) client.sendto(msg, gl.send_to) #print('Send message example =', msg, "to ", gl.send_to) return
def send_osccreation(self, lista): # crea los objetos en el sound engine client = OSCClient() msg = OSCMessage() # gl.client is a tuple in gl with ip and port address = "/game/create" msg.setAddress(address) msg.append(lista) client.sendto(msg, gl.send_to) #print('Send message example =', msg, "to ", gl.send_to) return
def send_stop(self): # da stop al soundengine client = OSCClient() msg = OSCMessage() # gl.client is a tuple in gl with ip and port address = "/game/stop" msg.setAddress(address) msg.append(0) client.sendto(msg, gl.send_to) #print('Send message example =', msg, "to ", gl.send_to) return
def sendOSCend(): # client = OSCClient() msg = OSCMessage() # gl.client is a tuple in gl with ip and port address = "/game/end" msg.setAddress(address) msg.append(1) client.sendto(msg, gl.send_to) print('Send message example =', msg, "to ", gl.send_to) return
class Manta(object): def __init__(self, receive_port=31416, send_port=31417, send_address='127.0.0.1'): self.osc_client = OSCClient() self.osc_server = OSCServer(('127.0.0.1', receive_port)) self.osc_client.connect(('127.0.0.1', send_port)) # set the osc server to time out after 1ms self.osc_server.timeout = 0.001 self.event_queue = [] self.osc_server.addMsgHandler('/manta/continuous/pad', self._pad_value_callback) self.osc_server.addMsgHandler('/manta/continuous/slider', self._slider_value_callback) self.osc_server.addMsgHandler('/manta/continuous/button', self._button_value_callback) self.osc_server.addMsgHandler('/manta/velocity/pad', self._pad_velocity_callback) self.osc_server.addMsgHandler('/manta/velocity/button', self._button_velocity_callback) def process(self): self.osc_server.handle_request() ret_list = self.event_queue self.event_queue = [] return ret_list def _pad_value_callback(self, path, tags, args, source): self.event_queue.append(PadValueEvent(args[0], args[1])) def _slider_value_callback(self, path, tags, args, source): touched = False if args[1] == 0xffff else True scaled_value = args[1] / 4096.0 self.event_queue.append(SliderValueEvent(args[0], touched, scaled_value)) def _button_value_callback(self, path, tags, args, source): pass def _pad_velocity_callback(self, path, tags, args, source): self.event_queue.append(PadVelocityEvent(args[0], args[1])) def _button_velocity_callback(self, path, tags, args, source): self.event_queue.append(ButtonVelocityEvent(args[0], args[1])) def _send_osc(self, path, *args): msg = OSCMessage(path) msg.append(args) self.osc_client.send(msg) def set_led_enable(self, led_type, enabled): self._send_osc('/manta/ledcontrol', led_type, 1 if enabled else 0) def set_led_pad(self, led_state, pad_index): self._send_osc('/manta/led/pad', led_state, pad_index)
def __init__(self, remote_osc_address, json_to_osc_q, osc_command_name, bridge=None, *args, **kwargs): self.remote_osc_address = remote_osc_address self.json_to_osc_q = json_to_osc_q self.osc_client = OSCClient() self.osc_client.connect(remote_osc_address) self.osc_command_name = osc_command_name self.bridge = bridge
def __init__(self, adr, port): self.ip_adr = adr self.port = port self.destination = (self.ip_adr, self.port) # self.client = OSC.OSCClient() self.client = OSCClient() self.client.connect(self.destination) self.adr = "/unset" self.str = 'IP: ' self.str += self.ip_adr self.str += ' PORT: ' self.str += str(port) print(self.str)
def __init__(self, ip, port,address="/openbci"): self.ip = ip self.port = port self.address = address if len(args) > 0: self.ip = args[0] if len(args) > 1: self.port = args[1] if len(args) > 2: self.address = args[2] # init network print "Selecting OSC streaming. IP: ", self.ip, ", port: ", self.port, ", address: ", self.address self.client = OSCClient() self.client.connect( (self.ip, self.port) )
class osc_sender_t: def __init__(self, server, port): self.client = OSCClient() self.client.connect((server, port)) self.need_send_names = SEND_NAMES def send_data(self, data): msg = OSCMessage("/wek/inputs") for k, v in data.items(): if k.endswith("_flag"): msg.append(v) else: msg.append([v[0], v[1], v[2]]) self._send(msg) def send_DTW_record(self, cls): msg = OSCMessage("/wekinator/control/startDtwRecording") msg.append(int(cls)) self._send(msg) def send_DTW_stop(self): msg = OSCMessage("/wekinator/control/stopDtwRecording") self._send(msg) def send_run(self): msg = OSCMessage("/wekinator/control/startRunning") self._send(msg) def send_stop(self): msg = OSCMessage("/wekinator/control/stopRunning") self._send(msg) def send_names(self, data): if self.need_send_names: self.need_send_names = False msg = OSCMessage("/wekinator/control/setInputNames") for k, v in data.items(): if k.endswith("flag"): msg.append(k) else: msg.append(k + "_x") msg.append(k + "_y") msg.append(k + "_z") self._send(msg) def _send(self, msg): try: self.client.send(msg) except OSCError: pass
def __init__(self, there_host="localhost", there_port=7400, here_host="localhost", here_port=7401, debug=False, *args, **kwargs): super(LiveRawAPI, self).__init__(*args, **kwargs) self.oscserver = OSCServer((here_host, here_port)) self.oscclient = OSCClient() self.oscclient.connect((there_host, there_port)) self.oscserver.addMsgHandler('/response', self._handle_response) self._incoming = []
def main(args): # Default host and port HOST = '192.168.1.8' PORT = 3032 if len(args) == 2: HOST = args[0] PORT = args[1] elif len(args) == 1: HOST = args[0] elif len(args) > 2: errorPrint("OSC Go button accepts at most 2 arguments.\n" + len(args) + " were provided."); client = OSCClient() client.connect((HOST, PORT)) msg = OSCMessage("/eos/key/go_0"); client.send(msg); client.close(); print print "GO" print exit();
def setup(): print "setup" global currentButtonState, lastDownTime, isRecording, audioInput global messageQ, clientMap, oscIn, oscOut, oscThread, mAudioServer messageQ = PriorityQueue() clientMap = {} ## setup osc client oscOut = OSCClient() ## setup osc receiver oscIn = OSCServer((OSC_IN_ADDRESS, OSC_IN_PORT)) oscIn.addMsgHandler('default', _oscHandler) oscThread = Thread(target=oscIn.serve_forever) oscThread.start() print "osc in ready" ## setup audio server #mAudioServer = ThreadedServer() #mAudioServer.start() ## setup gpio GPIO.setmode(GPIO.BCM) GPIO.setup(SWITCH_PIN, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(LED_PIN, GPIO.OUT) GPIO.output(LED_PIN, GPIO.LOW) currentButtonState = GPIO.input(SWITCH_PIN) lastDownTime = 0 isRecording = False _setupAudio()
class OscSender(): def __init__(self, osc_setup): self.host, self.port, self.root = osc_setup self.client = OSCClient() self.client.connect( (self.host, self.port) ) print "Connected to the OSC server %s:%s%s" %osc_setup self.send_parameter('osd_initialized','Done') def send_parameters(self, hand_params): for path, value in hand_params.items(): self.send_parameter(path, value) def send_parameter(self, rel_path, data): full_path = self.root+rel_path #self.client.send( OSCMessage( full_path, data ) ) print "[osc]\t%s\t\t\t%s" %(full_path, data)
class OscSender(): def __init__(self, osc_setup): self.host, self.port, self.root = osc_setup self.client = OSCClient() self.client.connect((self.host, self.port)) print "Connected to the OSC server %s:%s%s" % osc_setup self.send_parameter('osd_initialized', 'Done') def send_parameters(self, hand_params): for path, value in hand_params.items(): self.send_parameter(path, value) def send_parameter(self, rel_path, data): full_path = self.root + rel_path #self.client.send( OSCMessage( full_path, data ) ) print "[osc]\t%s\t\t\t%s" % (full_path, data)
def __init__(self): self.osc_message = None self.osc_client = OSCClient() self.osc_message = OSCMessage() self.ip = "" self.port = 0
class OSCServer(object): def __init__(self, ip, port,address="/openbci"): self.ip = ip self.port = port self.address = address if len(args) > 0: self.ip = args[0] if len(args) > 1: self.port = args[1] if len(args) > 2: self.address = args[2] # init network print "Selecting OSC streaming. IP: ", self.ip, ", port: ", self.port, ", address: ", self.address self.client = OSCClient() self.client.connect( (self.ip, self.port) )
def app(): global dxlIO, server, client ports = pypot.dynamixel.get_available_ports() if not ports: raise IOError('No port available.') dxlIO = pypot.dynamixel.DxlIO(ports[0]) availableIDs = dxlIO.scan() server = OSCServer(('0.0.0.0', 8000)) for motorID in availableIDs: server.addMsgHandler('/motor/' + str(motorID), motorHandler) # Register OSC handlers for each found ID client = OSCClient() client.connect(('localhost', 8001)) print 'Ready. Found ID(s) ' + str(availableIDs) while True: server.handle_request() sleep(0.01)
def setup(): # OSC global client client = OSCClient() client.connect(("localhost", 7300)) # DISPLAY global full_screen full_screen = False # global window_width, window_height window_width = 640 window_height = 480 # PYGAME global FPS FPS = 30 pygame.init() global screen screen = pygame.display.set_mode((window_width, window_height))#, 0, 32) pygame.display.set_caption("Le Reuz") global clock clock = pygame.time.Clock() global logo, grass logo = pygame.image.load("pictures/lereuz.jpg").convert() grass = pygame.image.load("pictures/test5.jpg").convert() global index index = 0 global fontObj fontObj = pygame.font.Font('freesansbold.ttf', 16) # OPENCV global camera camera = cv2.VideoCapture(0) camera.set(3, window_width) camera.set(4, window_height) # ds_factor = 1.0 # logo = cv2.imread("pictures/lereuz.jpg") # FACIAL FEATURES DETECTORS global face_detector, mouth_detector, smile_detector, nose_detector, right_eye_detector, left_eye_detector face_detector = FaceDetector() mouth_detector = MouthDetector() smile_detector = SmileDetector() nose_detector = NoseDetector() right_eye_detector = RightEyeDetector() left_eye_detector = LeftEyeDetector()
def __init__(self, ip='localhost', port=12345, address="/openbci"): # connection infos self.ip = ip self.port = port self.address = address self.client = OSCClient() self.client.connect( (self.ip, self.port) ) self.board = bci.OpenBCIBoard()
def main(): led_setup() client = OSCClient() address = ('127.0.0.1', 6666) while True: state = hand_state() led_control(state) if state['left']: msg = OSCMessage('/volume') msg.append(clamp(state['left'], 100, 600)) client.sendto(msg, address) if state['right']: msg = OSCMessage('/pitch') msg.append(clamp(state['right'], 100, 600)) client.sendto(msg, address) time.sleep(0.01) led_teardown()
def __init__(self, from_ip, from_port, to_ip, to_port): super(OSCForwarder, self).__init__() # create the server to listen to messages arriving at from_ip self.server = OSCServer( (from_ip, from_port) ) self.server.addMsgHandler( 'default', self.callback ) # create the clieent to forward those message to to_ip self.client = OSCClient() self.client.connect( (to_ip, to_port) ) print '%s:%d --> %s:%d' % (from_ip, from_port, to_ip, to_port) self.done_running = False # start the server listening for messages self.start()
def send_value(self): for add, d in self.neighbors.items(): c = OSCClient() c.connect(("localhost", add)) msg = OSCMessage("/receive") msg.append(self._address) msg.append(self.data["value"]) msg.append(self.data["iter"]) c.send(msg) c.close()
def step_impl(context, host, port, int_one, int_sec): client = OSCClient() client.connect((host, port)) if int_sec > 0: client.send(OSCMessage('/test', int_one, int_sec)) else: client.send(OSCMessage('/test', int_one))
def send_osclocation(self): #cuando hay un cambio de situacion se envia # /player/in /player/out /player/border client = OSCClient() msg = OSCMessage() # gl.client is a tuple in gl with ip and port if self['location'] == 'IN': address = "/player/in" elif self['location'] == 'OUT': address = "/player/out" else: address = "/player/border" msg.setAddress(address) msg.append(1) client.sendto(msg, gl.send_to) print(msg) #print('Send message example =', msg, "to ", gl.send_to) return
class Renoise(object): def __init__(self, address): self.client = OSCClient() self.client.connect(address) def panic(self): self.send_osc('/renoise/transport/panic') def note_on(self, instrument, track, note, velocity): self.send_osc('/renoise/trigger/note_on', instrument, track, note, velocity) def note_off(self, instrument, track, note): self.send_osc('/renoise/trigger/note_off', instrument, track, note) def send_osc(self, path, *args): msg = OSCMessage(path) map(msg.append, args) self.client.send(msg)
def on_data(self, data): #print(data) duration = 0 try: all_data = json.loads(data) tweet = all_data["text"] split_tweet = tweet.split(' ') first_word = split_tweet[0] if first_word == 'RT': first_word = split_tweet[1] num = 0 for char in first_word: num += ord(char) length_of_tweet = len(split_tweet)/40.0 duration = length_of_tweet * 1000 #print duration sharp_freqs = [185, 207.65, 233.08, 261.63, 277.18, 311.13, 349.23,] freqs = [174.61, 196, 220, 246.94, 261.63, 293.66, 329.62, 349.23, ]#369.99, 391.96, 415.30, 440, 466.16, 493.88, 523.25] note = num % 7 freq = 0 if '#' in tweet: freq = sharp_freqs[note] else: freq = freqs[note] except UnicodeEncodeError: duration = 500 client = OSCClient() client.connect(("localhost", 54345)) ### Create a bundle: bundle = OSCBundle() bundle.append({'addr': "/frequency", 'args':[freq]}) #bundle.append({'addr': "/amplitude", 'args':[52]}) #bundle.append({'addr': "/envelope/line", 'args:['}) bundle.append({'addr': "/envelope/line", 'args': [10., 20, 0., duration]}) client.send(bundle) time.sleep(duration/1000) return(True)
class OSCServer(object): def __init__(self, ip, port,address="/openbci"): self.ip = ip self.port = port self.address = address # init network print "Selecting OSC streaming. IP: ", self.ip, ", port: ", self.port, ", address: ", self.address self.client = OSCClient() self.client.connect( (self.ip, self.port) ) def handle_sample(self, sample): mes = OSCMessage(self.address) mes.append(sample.channel_data) # silently pass if connection drops try: self.client.send(mes) except: return
def activate(self): if len(self.args) > 0: self.ip = self.args[0] if len(self.args) > 1: self.port = int(self.args[1]) if len(self.args) > 2: self.address = self.args[2] # init network print "Selecting OSC streaming. IP: ", self.ip, ", port: ", self.port, ", address: ", self.address self.client = OSCClient() self.client.connect( (self.ip, self.port) )
def setup(self): self.name = "VLE" self.allClients = {} self.oscClient = OSCClient() ## subscribe to all receivers from localnet self.subscribeToAll() self.oldMessages = [] self.lastQueueCheck = time.time() self.oscPingMessage = OSCMessage() self.oscPingMessage.setAddress("/LocalNet/Ping") ## use empty byte blob self.oscPingMessage.append("", 'b')
class Sender(): #Takes the short moves defined by the user, parse them and store them in a strucured hash table. #Process the gestures from the listener : find the associated command, ask for a confirmation, execute the command. def __init__(self, osc_setup): self.host, self.port, self.root = osc_setup self.client = OSCClient() self.client.connect( (self.host, self.port) ) print "Connected to the OSC server %s:%s%s" %osc_setup self.send('init','leap_listener initialized') def send_hand(self, hand_params): print '********* HAND ***********' which = hand_params['which'] for path, value in hand_params.items(): path = path.replace('<which>',which) self.send(path, value) def send(self, rel_path, data): full_path = self.root+rel_path #self.client.send( OSCMessage( full_path, data ) ) print "[osc]\t%s\t\t\t%s" %(full_path, data)
def main(): print "=================" print "Sratch2OSC %s" % VERSION print "=================" print "" while True: s = connect() osc_client = OSCClient() osc_client.connect(OSC_HOST, OSC_PORT) if (s): print _("Connected to Scratch") s.broadcast("goo") s.broadcast("choki") s.broadcast("par") listen(s, osc_client) time.sleep(5)
def ping_callback(path, tags, args, source): try: client = OSCClient() client.connect((source[0], 8001)) client.send(OSCMessage("/ping")) except Exception as e: print e
def OSCsend(name, oscaddress, oscargs=''): ip = midi2OSC[name]["oscip"] port = midi2OSC[name]["oscport"] osclient = OSCClient() osclient.connect((ip, port)) oscmsg = OSCMessage() oscmsg.setAddress(oscaddress) oscmsg.append(oscargs) try: if gstt.debug > 0: print("Midi OSCSend : sending", oscmsg, "to", name, "at", gstt.LjayServerIP, ":", PluginPort) osclient.sendto(oscmsg, (ip, port)) oscmsg.clearData() #if gstt.debug >0: # print oscaddress, oscargs, "was sent to",name return True except: if gstt.debug > 0: print('Midi OSCSend : Connection to IP', ip, ':', port, 'refused : died ?') #sendWSall("/status No plugin.") #sendWSall("/status " + name + " is offline") #sendWSall("/" + name + "/start 0") #PluginStart(name) return False