Python OSCServer.close方法代码示例

# 需要导入模块: from OSC import OSCServer [as 别名]
# 或者: from OSC.OSCServer import close [as 别名]
def main():
    print("Waiting for boot signal")
    print(s.read())
    print("Writing sway command")
    s.write("".join(map(chr, [0x55, 0x0, 0x3, 0, 2, 72]))) # equivalent to .join['U', '\x00', '\x03', '\x00', '\x02', 'H']
    # between every elements in the list, put ""
    # that will convert it as one string ''Ux00x03x00x02H''
    print(s.read())
    # print("Reading motor encoders")
    # s.write("".join(map(chr, [0x55, 0x1, 0x12])))
    # print(["0x%.02x " % ord(x) for x in s.read(12)])
    server = OSCServer( ("192.168.123.75", 10000) )
    server.timeout = 0
    # funny python's way to add a method to an instance of a class
    import types
    server.handle_timeout = types.MethodType(handle_timeout, server)

    server.addMsgHandler( "/rotate", rotate_callback )
    server.addMsgHandler( "/bf", bf_callback )
    
    try:
        while 1:
            server.handle_request()
    except KeyboardInterrupt:
        pass


    server.close()

# 需要导入模块: from OSC import OSCServer [as 别名]
# 或者: from OSC.OSCServer import close [as 别名]
def main():
    print("Waiting for boot signal")
    print(s.read())
    print("Writing sway command")
    s.write("".join(map(chr, [0x55, 0x0, 0x3, 0, 2, 72])))
    print(s.read())
    # print("Reading motor encoders")
    # s.write("".join(map(chr, [0x55, 0x1, 0x12])))
    # print(["0x%.02x " % ord(x) for x in s.read(12)])
    server = OSCServer( ("192.168.123.75", 10000) )
    server.timeout = 0
    # funny python's way to add a method to an instance of a class
    import types
    server.handle_timeout = types.MethodType(handle_timeout, server)

    server.addMsgHandler( "/rotate", rotate_callback )
    server.addMsgHandler( "/bf", bf_callback )
    
    try:
        while 1:
            server.handle_request()
    except KeyboardInterrupt:
        pass


    server.close()

# 需要导入模块: from OSC import OSCServer [as 别名]
# 或者: from OSC.OSCServer import close [as 别名]
class ColorsIn:
# this method of reporting timeouts only works by convention
# that before calling handle_request() field .timed_out is 
# set to False


    def set_colors(self,path, tags, args, source):
        # which user will be determined by path:
        # we just throw away all slashes and join together what's left
        #print "Here's what we got : path:%s tags:%s args:%s source:%s"%(str(path),str(tags),str(args),str(source))
        pixels = []
        for i in range(0,len(args)/3):
            pixel = (clamp(args[i*3]), clamp(args[i*3+1]), clamp(args[i*3+2]))
            pixels.append( pixel )
        #print "Pixels: %s"%str(pixels)
        #print "Time: "+str((time.time()*1000) % 10000)
        octoapi.write(pixels)
        self.lastwrite=time.time()
        self.server.lastpixels = pixels

    def diff_colors(self, path, tags, args, source):
        # which user will be determined by path:
        # we just throw away all slashes and join together what's left
        #print "Here's what we got : path:%s tags:%s args:%s source:%s"%(str(path),str(tags),str(args),str(source))
        pixels = server.lastpixels
        for i in range(0,len(args)/3):
            pp = (args[i*3],args[i*3+1],args[i*3+2])
            p = pixels[i]
            pixels[i] = (clamp(p[0]+pp[0]), clamp(p[1]+pp[1]), clamp(p[2]+pp[2]))
        #print "Pixels: %s"%str(pixels)
        #print "Time: "+str((time.time()*1000) % 10000)
        octoapi.write(pixels)
        self.lastwrite=time.time()
        self.server.lastpixels = pixels

    def each_frame(self):
        self.server.timed_out = False
        while not self.server.timed_out:
            if time.time() - self.lastwrite > CLEAR_TIME:
                self.lastwrite = time.time()
                octoapi.write([(0,0,0)]*24)
                print "Clearing"
            self.server.handle_request()

    def start(self):
        #server = OSCServer( ("128.174.251.39", 11661) )
        self.server = OSCServer( ("localhost", 11661) )
        self.server.timeout = 0
        self.lastwrite = time.time()        
        self.server.handle_timeout = types.MethodType(handle_timeout, self.server)
        self.server.lastpixels = [(0,0,0)]*24

        self.server.addMsgHandler( "/setcolors", self.set_colors)
        self.server.addMsgHandler( "/diffcolors", self.diff_colors)
        while True:
            self.each_frame()

        self.server.close()

# 需要导入模块: from OSC import OSCServer [as 别名]
# 或者: from OSC.OSCServer import close [as 别名]
	class OscServerThread(Thread):
		def __init__(self, host, stopEvent):
			Thread.__init__(self)
			self.server = OSCServer(host)
			self.stopEvent = stopEvent
		def setCallBacks(self, callBacks):
			for callBack in callBacks:
				self.server.addMsgHandler(callBack[0], callBack[1])
		def run(self):
			while not self.stopEvent.is_set():
				self.server.handle_request()
			self.server.close()

# 需要导入模块: from OSC import OSCServer [as 别名]
# 或者: from OSC.OSCServer import close [as 别名]
def main(hostname="localhost",port="8000"):
    server = OSCServer((hostname, int(port)))
    server.timeout = 0
    run = True
    global message_count
    message_count = 0

    # this method of reporting timeouts only works by convention
    # that before calling handle_request() field .timed_out is 
    # set to False
    def handle_timeout(self):
        self.timed_out = True

    # funny python's way to add a method to an instance of a class
    import types
    server.handle_timeout = types.MethodType(handle_timeout, server)

    def user_callback(path, tags, args, source):
        log("%s %s\n" % (path, args))
        global message_count
        message_count += 1

    def quit_callback(path, tags, args, source):
        #global run
        run = False

    server.addMsgHandler( "default", user_callback )
    server.addMsgHandler( "/quit", quit_callback )

    # user script that's called by the game engine every frame
    def each_frame():
        log("Messages received: %s\n" % message_count)
        # clear timed_out flag
        server.timed_out = False
        # handle all pending requests then return
        while not server.timed_out:
            server.handle_request()

    # simulate a "game engine"
    print "Server running at %s:%s" % (hostname, port)
    while run:
        # do the game stuff:
        sleep(1)
        # call user script
        each_frame()

    server.close()

# 需要导入模块: from OSC import OSCServer [as 别名]
# 或者: from OSC.OSCServer import close [as 别名]
class OscServer:
    def __init__(self, port, cbks = None):
        self.server = OSCServer( ("localhost", port) )
        self.server.addDefaultHandlers()
        self.thread = threading.Thread(target = self.server.serve_forever)

        if cbks is not None:
            for path, cbk in cbks:
                self.on_msg(path, cbk)

    def on_msg(self, path, f):
        def go_zero(path, tags, args, source):
            f()            

        def go_args(path, tags, args, source):
            f(*args)

        if f.func_code.co_argcount == 0:
            go = go_zero
        else:
            go = go_args

        self.server.addMsgHandler(path, go)

    def start(self):
        self.thread.start()
        try :
            while 1 :
                time.sleep(10) 
        except KeyboardInterrupt :
            print "\nClosing OSCServer."
            self.server.close()
            print "Waiting for Server-thread to finish"
            self.thread.join()
            print "Done"

    def close(self):
        self.server.close()    
        try:
            self.thread.join()
        except:
            pass
        print "Done"

# 需要导入模块: from OSC import OSCServer [as 别名]
# 或者: from OSC.OSCServer import close [as 别名]
class OSCForwarder(threading.Thread):
   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()

   # close must be called before app termination or the app might hang
   def close(self):
      # this is a workaround of a bug in the OSC server
      # we have to stop the thread first, make sure it is done,
      # and only then call server.close()
      self.server.running = False

      while not self.done_running:
         time.sleep(.01)
      self.server.close()

   def run(self):
      #print "Worker thread entry point"
      self.server.serve_forever()
      self.done_running = True


   def callback(self, path, tags, args, source):
      #print 'got:', path, args, 'from:', source
      self.client.send( OSCMessage(path, args ) )

# 需要导入模块: from OSC import OSCServer [as 别名]
# 或者: from OSC.OSCServer import close [as 别名]
def main():
    #incoming(HOST,PORT)
    server = OSCServer(('127.0.0.1',42003))
    client = OSC.OSCClient()
    client.connect(('127.0.0.1',42002))

    server.addDefaultHandlers()
    server.addMsgHandler("/exo/hand/gesture",handler_func)

    st = threading.Thread( target = server.serve_forever )
    st.start()

    try :
        while 1 :
                time.sleep(10)
    except KeyboardInterrupt :
        print "\nClosing OSCServer."
        s.close()
        print "Waiting for Server-thread to finish"
        st.join()
        print "Done"

    server.close()

# 需要导入模块: from OSC import OSCServer [as 别名]
# 或者: from OSC.OSCServer import close [as 别名]
    #         self.send_response(301)

    #         self.end_headers()
    #         upfilecontent = query.get('upfile')
    #         print "filecontent", upfilecontent[0]
    #         self.wfile.write("<HTML>POST OK.<BR><BR>");
    #         self.wfile.write(upfilecontent[0]);

    #     except :
    #         pass


if __name__ == "__main__":
    # will get better args
    if sys.argv[1:]:
        http_port = int(sys.argv[1])
    else:
        http_port = 8000
    osc_host = "127.0.0.1"
    osc_port = 12000
    try:
        sc = OSCServer((osc_host, osc_port))
        client = OSCClient(sc)
        server = HTTPServer(("", http_port), JSONHandler)
        print "started http to OSC bridge..."
        server.serve_forever()
    except KeyboardInterrupt:
        print "^C received, shutting down server"
        server.socket.close()
        sc.close()

# 需要导入模块: from OSC import OSCServer [as 别名]
# 或者: from OSC.OSCServer import close [as 别名]

#.........这里部分代码省略.........
                print "adding "+ip+":"+str(port)+" to "+addrTokens[3].lower()+" receivers"
                self.allReceivers[addrTokens[3].lower()].addSubscriber((ip,port))
                ## if adding osc listener need to setup osc master
                if((addrTokens[3].lower().startswith('osc')) 
                    and (not self.oscMasterIp is None)
                    and (not self.oscMasterPort is None)):
                    print ("adding osc master")
                    try:
                        oscSubscribeMessage = OSCMessage()
                        oscSubscribeMessage.setAddress("/LocalNet/Add/"+addrTokens[2]+"/Osc")
                        oscSubscribeMessage.append(str(self.oscServerPort).encode('utf-8'), 'b')
                        self.oscClient.connect((self.oscMasterIp, int(self.oscMasterPort)))
                        self.oscClient.sendto(oscSubscribeMessage, (self.oscMasterIp, int(self.oscMasterPort)))
                        self.oscClient.connect((self.oscMasterIp, int(self.oscMasterPort)))
                    except OSCClientError:
                        print ("no connection to "+self.oscMasterIp+":"+str(self.oscMasterPort))
        elif ((addrTokens[0].lower() == "localnet")
              and (addrTokens[1].lower() == "remove")):
            ip = getUrlStr(source).split(":")[0]
            port = int(stuff[0])
            if (addrTokens[2].lower() in self.allReceivers):
                print "removing "+ip+":"+str(port)+" from "+addrTokens[2].lower()+" receivers"
                self.allReceivers[addrTokens[2].lower()].removeSubscriber((ip,port))
            ## only remove from list of prototypes when not in any receiver...
            inSomeSubscriber = False
            for k in self.allReceivers:
                inSomeSubscriber |= self.allReceivers[k].hasSubscriber((ip,port))
            if ((not inSomeSubscriber) and ((ip,port) in self.allPrototypes)):
                print("removing "+self.allPrototypes[(ip,port)]+" @ "+ip+":"+str(port)
                      +" from list of prototypes")
                del self.allPrototypes[(ip,port)]
        ## /LocalNet/ListReceivers -> port-number
        elif ((addrTokens[0].lower() == "localnet")
              and (addrTokens[1].lower().startswith("listreceiver"))):
            ip = getUrlStr(source).split(":")[0]
            port = int(stuff[0])
            ## send list of receivers to client
            msg = OSCMessage()
            msg.setAddress("/LocalNet/Receivers")
            msg.append(",".join(self.allReceivers.keys()))
            try:
                self.oscClient.connect((ip, port))
                self.oscClient.sendto(msg, (ip, port))
                self.oscClient.connect((ip, port))
            except OSCClientError:
                print ("no connection to "+ip+":"+str(port)
                       +", can't send list of receivers")
        ## /LocalNet/ListReceivers -> port-number
        elif ((addrTokens[0].lower() == "localnet")
              and (addrTokens[1].lower().startswith("listprototype"))):
            ip = getUrlStr(source).split(":")[0]
            port = int(stuff[0])
            ## send list of prototypes to client
            msg = OSCMessage()
            msg.setAddress("/LocalNet/Prototypes")
            msg.append(",".join(self.allPrototypes.values()))
            try:
                self.oscClient.connect((ip, port))
                self.oscClient.sendto(msg, (ip, port))
                self.oscClient.connect((ip, port))
            except OSCClientError:
                print ("no connection to "+ip+":"+str(port)
                       +", can't send list of prototypes")

        ## /AEffectLab/{local}/{type} -> msg
        elif (addrTokens[0].lower() == "aeffectlab"):
            oscTxt = stuff[0].decode('utf-8')
            print "forwarding "+addr+" : "+oscTxt+" to my osc subscribers"
            ## send to all subscribers
            addr = "/AEffectLab/"+addrTokens[1]+"/"+addrTokens[2]
            self.sendToAllSubscribers(oscTxt, addr)

    ## setup osc server
    def setup(self, db, osc, loc):
        self.database = db
        self.oscClient = osc
        self.location = loc
        self.name = "osc"
        self.oscServer = OSCServer((self.oscServerIp,self.oscServerPort))
        ## handler
        self.oscServer.addMsgHandler('default', self._oscHandler)
        ## start server
        self.oscThread = Thread( target = self.oscServer.serve_forever )
        self.oscThread.start()
        ## return
        return True

    ## setup master ip,port
    def setupMaster(self,ip,port):
        self.oscMasterIp = ip
        self.oscMasterPort = int(port)

    ## update osc server
    def update(self):
        pass

    ## end oscReceiver
    def stop(self):
        self.oscServer.close()
        self.oscThread.join()

# 需要导入模块: from OSC import OSCServer [as 别名]
# 或者: from OSC.OSCServer import close [as 别名]

#.........这里部分代码省略.........
        # we'll handle in a single iteration, otherwise we might
        # get stuck in processing an endless stream of data
        limit = 50
        count = 0

        # clear timed_out flag
        self.osc_server.timed_out = False

        # handle all pending requests then return
        # NOTE; if you get weird bugs because self.osc_server is None,
        # one of handled OSC messages probably triggered the destruction
        # of this component. This should not happen until after this update
        # loop is finished, so destructive operations should be queued for later
        while self.osc_server.timed_out == False and count < limit:
            try:
                self.osc_server.handle_request()
                count += 1
            except Exception as exc:
                self.logger.error("Something went wrong while handling incoming OSC messages:")
                self.logger.error(exc)

    def port(self):
        return self.getOption('port', DEFAULT_PORT)

    def host(self):
        return self.getOption('ip', DEFAULT_IP)

    def _connect(self):
        if self.connected:
            self.logger.warning('already connected')
            return False

        try:
            self.osc_server = OSCServer((self.host(), self.port()))
        except Exception as err:
            # something went wrong, cleanup
            self.connected = False
            self.osc_server = None
            # notify
            self.logger.error("{0}\n\tOSC Server could not start @ {1}:{2}".format(err, self.host(), str(self.port())))
            # abort
            return False

        # register time out callback
        self.osc_server.handle_timeout = self._onTimeout
        self.osc_server.addMsgHandler('default', self._onOscMsg)

        # set internal connected flag
        self.connected = True
        # notify
        self.connectEvent(self)
        self.logger.info("OSC Server running @ {0}:{1}".format(self.host(), str(self.port())))

        if self.threaded:
            self._threadStopFlag = False
            self.thread = threading.Thread(target=self._threadMethod, args=())
            self.thread.start()
            self.logger.info("started separate OSC-listener thread")

        return True

    def _disconnect(self):
        if self.threaded:
            self._threadStopFlag = True
            self.logger.info("stopping separate OSC-listener thread...")
            while self.thread and self.thread.isAlive():
                pass
            self.logger.info('done')
            self.thread = None

        if self.osc_server:
            self.osc_server.close()
            self.connected = False
            self.osc_server = None
            self.disconnectEvent(self)
            self.logger.info('OSC Server ({0}:{1}) stopped'.format(self.host(), str(self.port())))

    def _onTimeout(self):
        if self.osc_server:
            self.osc_server.timed_out = True

    def _onOscMsg(self, addr, tags=[], data=[], client_address=''):
        # skip touch osc touch-up events
        # if len(data) == 1 and data[0] == 0.0:
        #     return
        self.logger.debug('osc-in {0}:{1} {2} [{3}] from {4}'.format(self.host(), self.port(), addr, ", ".join(map(lambda x: str(x), data)), client_address))
        if self.messageEvent:
            self.messageEvent(addr, tags, data, client_address)

        # trigger events based on incoming messages if configured
        if addr in self.msgEventMapping:
            self.logger.debug('triggering output event: {0}'.format(self.msgEventMapping[addr]))
            self.event_manager.fire(self.msgEventMapping[addr])
        elif self.autoAddrToEvent:
            self.logger.debug('triggering auto-output event: {0}'.format(addr))
            self.event_manager.fire(addr)

    def _threadMethod(self):
        while not self._threadStopFlag:
            self._processIncomingMessages()

# 需要导入模块: from OSC import OSCServer [as 别名]
# 或者: from OSC.OSCServer import close [as 别名]
    # RPi.GPIO Layout verwenden (wie Pin-Nummern)
    GPIO.setmode(GPIO.BOARD)

    for _button in button_map:
      GPIO.setup(_button, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) # PUD_DOWN, because we use a pull down resistor, use RISING in next line then!
      GPIO.add_event_detect(_button, GPIO.RISING, callback=button_press, bouncetime=args.bouncetime)

    client.connect( (args.ip, args.port) )
    notifications.addMsgHandler( "/stopped", remote_stopped_callback )
    notifications.addMsgHandler( "/playing", remote_started_callback )
    notifications.addMsgHandler( "/files", remote_files_callback )

    print "StaalPiPlayer Button Client ready!"
    print "\tListening for player with:",notifications
    print "\tSending commands to player with:",client

    while True:
      try:
        notifications.serve_forever()
      except Exception, e:
        time.sleep(5)
        pass

  except Exception, e:
    pass
  finally:
    GPIO.cleanup()
    client.send( OSCMessage("/stop" ) )
    notifications.close()
    pass

# 需要导入模块: from OSC import OSCServer [as 别名]
# 或者: from OSC.OSCServer import close [as 别名]
class Kinect:
    """Manages connection to Kinect, and saves and processes coordinates"""
    
    @staticmethod
    def retrieve(joints=None, max_port=5555):
        """ Retrieves a singleton Kinect instance, and creates it if it doesn't exist. """
        global kinect_instance
        if kinect_instance is None:
            kinect_instance = Kinect(joints, max_port)
        return kinect_instance
    
    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)
        #sprout(self._calc_speed)
    
    def __enter__(self):
        return self
    
    def __exit__(self, _type, value, traceback):
        self.server.close()
        self.kinect_client.close()
        self.max_client.close()
    
    def process_message(self, addr, tags, data, source):
        """process data coming in from Synapse, happens about every 0.03 seconds"""
        
        if addr[-9:] == '_pos_body':
            if self.flipped:
                if addr[:5] == '/left':
                    addr = '/right' + addr[5:]
                    data[X] = -data[X]
                elif addr[:6] == '/right':
                    addr = '/left'+addr[6:]
                    data[X] = -data[X]
            self.coords[addr[1:-9]] = data
    
    def _remind_synapse(self):
        """Send Synapse an OSC message to ask it to continue polling the required joints"""
        while True:
            for track in self.joints:
                self.sendToKinect('/'+track+'_trackjointpos', 1)
            time.sleep(1)
    
    def calc_speed(self):
        """Calculate speed of movement, at 0.06 second intervals"""
        self.calculating_speed = True
        while self.calculating_speed:
            total_speed = 0.
            for joint, v in self.coords.items():
                magnitude = Magnitude(v)
                prev_magnitude = Magnitude(self.prev_coords[joint])
                speed = abs(magnitude - prev_magnitude)
                if joint in ('lefthand', 'righthand'):
                    speed_x = Distance(SubVector(self.prev_coords[joint], X), 
                                              SubVector(self.coords[joint], X))
                    speed_y = Distance(SubVector(self.prev_coords[joint], Y), 
                                              SubVector(self.coords[joint], Y))
                    self.speed_piano[joint][X] += (speed_x - self.speed_piano[joint][X]) * 0.5
                    self.speed_piano[joint][Y] += (speed_y - self.speed_piano[joint][Y]) * 0.5
                total_speed += speed
            total_speed /= len(self.coords)
            self.speed = total_speed
            self.speed_ramp = self.speed_ramp + (self.speed - self.speed_ramp) * 0.125
            self.prev_coords = copy.copy(self.coords)
            time.sleep(0.06)
    
    @property
    def area(self):
        return Area( self.coords['head'], 
                     self.coords['lefthand'], 
                     self.coords['leftfoot'], 
                     self.coords['rightfoot'], 
                     self.coords['righthand'] ) / 1000000.
        
    @property
    def facing(self):
        return self.coords['rightfoot'][X] >= self.coords['leftfoot'][X]
    
    def hand_down(self, hand):
#.........这里部分代码省略.........

# 需要导入模块: from OSC import OSCServer [as 别名]
# 或者: from OSC.OSCServer import close [as 别名]
class Kinect(threading.Thread):
   def __init__(self, remote_ip = None):
      super(Kinect, self).__init__()

      core.register_terminate_func(self.close)

      # Synapse is running on a remote machine:
      if remote_ip:
         listen_ip = socket.gethostbyname(socket.gethostname())
         listen_port = 12345

         send_ip = remote_ip
         send_port = 12321

      # Synapse is running locally on this machine, using localhost
      else:
         listen_ip = 'localhost'
         listen_port = 12345

         send_ip = 'localhost'
         send_port = 12346

      self.server = OSCServer( (listen_ip, listen_port) )
      self.server.addMsgHandler( '/tracking_skeleton', self.callback_tracking_skeleton )
      self.server.addMsgHandler( 'default', self.callback_ignore )

      # create the client, which sends control messages to Synapse
      self.client = OSCClient()
      self.client.connect( (send_ip, send_port) )

      # member vars
      self.active_joints = {}
      self.last_heartbeat_time = 0
      self.done_running = False

      # start the server listening for messages
      self.start()

   # close must be called before app termination or the app might hang
   def close(self):
      # this is a workaround of a bug in the OSC server
      # we have to stop the thread first, make sure it is done,
      # and only then class server.close()
      self.server.running = False
      while not self.done_running:
         time.sleep(.01)
      self.server.close()

   def run(self):
      print "Worker thread entry point"
      self.server.serve_forever()
      self.done_running = True

   def add_joint(self, joint):
      self.server.addMsgHandler(joint + '_pos_body', self.callback)
      self.active_joints[joint] = np.array([0.0, 0.0, 0.0])

   def remove_joint(self, joint):
      self.server.delMsgHandler(joint + '_pos_body')
      del self.active_joints[joint]

   def on_update(self):
      now = time.time()
      send_heartbeat = now - self.last_heartbeat_time > 3.0
      if send_heartbeat:
         self.last_heartbeat_time = now

      try:
         for j in self.active_joints:
            if send_heartbeat:
               #print 'heartbeat:', j
               self.client.send( OSCMessage(j + "_trackjointpos", 1) )
      except Exception as x:
         print x, 'sending to', self.client.client_address

   def get_joint(self, joint) :
      return np.copy(self.active_joints[joint])

   def callback_ignore(self, path, tags, args, source):
      pass

   def callback(self, path, tags, args, source):
      #print path, args
      joint_name = path.replace("_pos_body", "")
      self.active_joints[joint_name] = np.array(args)

   def callback_tracking_skeleton(self, path, tags, args, source):
      pass

# 需要导入模块: from OSC import OSCServer [as 别名]
# 或者: from OSC.OSCServer import close [as 别名]
def step_impl(context, message):
    listen = OSCServer(("127.0.0.1", 4589))
    listen.timeout = 0 #infinite timeout
    listen.addMsgHandler("/err", listen_handler)
    listen.close()