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()
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()
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()
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()
def main(): if len(sys.argv)>1: OSC_ADDRESS = str(sys.argv[1]) else: OSC_ADDRESS = OSC_ADDRESS_DEFAULT if len(sys.argv)>2: OSC_PORT = int(sys.argv[2]) else: OSC_PORT = OSC_PORT_DEFAULT if len(sys.argv)>3: WIFI_INT = str(sys.argv[3]) else: WIFI_INT = WIFI_INT_DEFAULT #creates directory to store sounds if not os.path.exists(sounddir): os.makedirs(sounddir) print("Sound directory: ",sounddir) #example of use of pyosc, #see: https://github.com/ptone/pyosc/blob/master/examples/knect-rcv.py #we use here the WiFi interface provided on device en0 ipcmd = "ipconfig getifaddr %s"%WIFI_INT print(ipcmd) ipaddress = os.popen(ipcmd).read().rstrip() print("IP address: ",ipaddress) server = OSCServer((ipaddress, OSC_PORT)) server.timeout = 0 global run run = True print("Listening to OSC address",OSC_ADDRESS,"on port",OSC_PORT) #python's way to add a method to an instance of a class server.handle_timeout = types.MethodType(handle_timeout, server) server.addMsgHandler(OSC_ADDRESS, user_callback) #sound query engine try: while run: #sleep(1) #call user script each_frame(server) except KeyboardInterrupt: #to quit program print("\n") pass server.close()
def main(opts): server = OSCServer((opts.ip_addres, int(opts.port))) server.handle_timeout = types.MethodType(handle_timeout, server) server.addMsgHandler("/user", user_callback) server.addMsgHandler("/quit", quit_callback) log_post('INFO: listening on to %s:%s' % (opts.ip_addres, opts.port)) spinner_ = spinner() while run: each_frame(server) sys.stdout.write(spinner_.next()) sys.stdout.flush() sleep(0.5) sys.stdout.write('\b') server.close()
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()
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()
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"
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"
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 ) )
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()
class KinectReceiver(avg.Publisher): """Class to process OSC messages from the kinect tracking system. Subscribers will receive messages for each joint or kill, containing either [skeleton_id, skeleton_joint] or [skeleton_id, 'kill') """ OSC_kinect_MessageID = avg.Publisher.genMessageID() OSC_kinect_hand_MessageID = avg.Publisher.genMessageID() def __init__(self, ip): """Initialize the server on localhost.""" avg.Publisher.__init__(self) self.__active_skeleton_ids = [] try: self.__server = OSCServer((ip, 27015)) self.__server.print_tracebacks = True # TODO check the ThreadingOSCServer class as possible alternative except OSCError: print "############################################" print "####### could not open OSCServer ###########" print "############################################" return if self.__server is None: print "OSC KINECT RECEIVER: server is not initialized" return print "Kinect receiver: ", self.__server self.__server.handle_timeout = types.MethodType( self.__handle_timeout, self.__server) self.__server.timeout = 0 self.__server.addMsgHandler("/joint", self.__on_osc_joint_message_received) self.__server.addMsgHandler("/hand", self.__on_osc_hand_message_received) self.__server.addMsgHandler("/kill", self.__on_osc_kill_message_received) self.publish(self.OSC_kinect_MessageID) self.publish(self.OSC_kinect_hand_MessageID) def __handle_timeout(self, statusnachricht): """Handle server timeouts.""" self.__server.timed_out = True def onFrame(self): """Stay active.""" self.__server.timed_out = False # handle all pending requests than return while not self.__server.timed_out: self.__server.handle_request() def run(self): """Start running the server.""" while True: self.__server.handle_request() self.__server.close() def __on_osc_joint_message_received(self, addr, tags, data, client_address): """Receives an OSC message, transforms the data and notifies subscribers by sending a message (type: list) containing skeleton_id and skeleton_joint (type: SkeletonJoint) Args: addr: the address (str e.g. /joint) tags: tags (str with i for int32 and f for float, e.g. iiiifff) data: tracking data, containing id, convertMode, jointtype, trackingstate, and if trackingstate != OKTS_NOTTRACKED, x,y and z client_address: client address as (ip, port) tuple """ # check if length could actually be a skeleton joint message if len(data) < 4: return # initialize position values x = 0 y = 0 z = 0 # only if joint is tracked, additional position values are given if data[3] is not OSCJointTrackingState.OKTS_NOTTRACKED and len( data) >= 7: x = data[4] y = data[5] z = data[6] # create the skeleton joint from received data # joint_type = OSCKinectJoint(data[2]) joint_type = data[2] skeleton_joint = SkeletonJoint(x, y, z, joint_type) skeleton_joint.tracking_state = data[3] # add skeletonID to active skeleton list if data[0] not in self.__active_skeleton_ids: self.__active_skeleton_ids.append(data[0]) # message for subscribers consists of skeletonID and joint message = [data[0], skeleton_joint] # send new skeleton_joint to subscriber self.notifySubscribers(self.OSC_kinect_MessageID, [message]) def __on_osc_hand_message_received(self, addr, tags, data, client_address): """ received hand state events from oscserver and if this skeleton already exists it norfies subscribers with message skeleton_id and list["left"/"right", value] """ if len(data) < 3: return if data[1] != "left" and data[1] != "right": return if data[0] in self.__active_skeleton_ids: message = [data[0], (data[1], data[2])] self.notifySubscribers(self.OSC_kinect_hand_MessageID, [message]) def __on_osc_kill_message_received(self, addr, tags, data, client_address): """ receives the kill event from oscserver and reacts by sending out a message (list) ONCE that includes skeleton_id and 'kill' """ # kill will be received constantly, only send message once # when skeletonID is still in active skeleton list if data[0] in self.__active_skeleton_ids: # message for subscribers consists of skeletonID and 'kill' message = [data[0], 'kill'] # send message self.notifySubscribers(self.OSC_kinect_MessageID, [message]) # remove skeletonID from active skeleton list self.__active_skeleton_ids.remove(data[0]) pass
# 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()
process_run = Popen('./runtrace.sh', stdout=PIPE, stderr=PIPE, shell=True) SERVER.addMsgHandler("/run", user_callback) SERVER.addMsgHandler("/stop", quit_callback) class KeyboardInterruptError(Exception): pass def process_frame(): SERVER.timed_out = False while not SERVER.timed_out: SERVER.handle_request() while oscserver_run: try: process_frame() time.sleep(0.1) except KeyboardInterrupt: oscserver_run = False process_stop = Popen(['tmux', 'kill-server'], stdout=PIPE, stderr=PIPE, shell=True) SERVER.close() clean_screen()
class Server(): """Listener to collect results of Keykit server. (Adaption of OSC package example.) """ def __init__(self, server_adr): self.server = OSCServer(server_adr) self.server.socket.settimeout(3) self.run = True self.timed_out = False # funny python's way to add a method to an instance of a class # import types # self.server.handle_timeout = types.MethodType( # self.handle_timeout, self.server) # or self.server.handle_timeout = self.handle_timeout # Handler self.server.addMsgHandler("/quit", self.quit_callback) self.server.addMsgHandler("/keykit/pyconsole/out", self.print_callback) self.server.addMsgHandler("/keykit/pyconsole/err", self.err_callback) self.server.addMsgHandler( "/keykit/pyconsole/start", self.print_callback) self.server.addMsgHandler("/keykit/pyconsole/lsdir", self.dir_callback) def handle_timeout(self, server=None): self.timed_out = True def each_frame(self): # clear timed_out flag self.timed_out = False # handle all pending requests then return while not self.timed_out and self.run: self.server.handle_request() # Line reached after each socket read sleep(.05) def start(self): # print("Wait on client input...") sys.stdout.write("%s" % (MY_PROMPT)) sys.stdout.flush() while self.run: self.each_frame() # Line reached after each socket timeout sleep(1) def stop(self): self.run = False # Invoke shutdown. Socket still wait on timeout... try: import socket self.server.socket.shutdown(socket.SHUT_RDWR) except socket.error: pass self.server.close() # Callbacks def quit_callback(self, path, tags, args, source): self.run = False def print_callback(self, path, tags, args, source, textColor=ColorOut): current_input = readline.get_line_buffer() # Add Tab at every input line out = args[0].replace("\n", "\n\t") # Delete current input, insert output and add input again. # \r : Carriage return, \033[K : Delete everything after the cursor. sys.stdout.write("\r\033[K") sys.stdout.write( "\t%s%s%s\n%s%s" % (textColor, out, ColorReset, MY_PROMPT, current_input)) sys.stdout.flush() def err_callback(self, path, tags, args, source): """ Same as print_callback but mark output as error. """ self.print_callback(path, tags, args, source, ColorWarn) def dir_callback(self, path, tags, args, source): """ Store current working dir for tab completion. This is mainly releated to chdir() and lsdir(). """ lsdir_string_part = args[0] if lsdir_string_part[0] == "^": self.keykit_lsdir_string = lsdir_string_part else: self.keykit_lsdir_string += lsdir_string_part if self.keykit_lsdir_string[-1] == "$": try: lsdir = [] # Convert string into list of files. Second argument flags # directories. # Example string: ^["foldername"=1,"filename"=0]$ re_entries = '".+?"=[01][,\]]' entries = re.finditer(re_entries, self.keykit_lsdir_string) for entry in entries: sname = entry.group()[1:-4] bFolder = entry.group()[-2] == "1" lsdir.append((sname, bFolder)) self.keykit_lsdir = lsdir except: sys.stderr.write("(dir_callback) Unable to fetch folder content.") self.keykit_lsdir = []
class OptiTrackReceiver(avg.Publisher): OSC_optitrack_MessageID = avg.Publisher.genMessageID() OSC_optitrack_KillMessageID = avg.Publisher.genMessageID() def __init__(self, ip="", port="5103"): avg.Publisher.__init__(self) try: rigidbody_format = config.optitrack_osc_format self.__index_id = rigidbody_format.index("id") self.__index_x = rigidbody_format.index("x") self.__index_y = rigidbody_format.index("y") self.__index_z = rigidbody_format.index("z") self.__index_roll = rigidbody_format.index("roll") self.__index_pitch = rigidbody_format.index("pitch") self.__index_yaw = rigidbody_format.index("yaw") self.__index_name = rigidbody_format.index("name") self.__index_quat_1 = rigidbody_format.index("quat_1") self.__index_quat_2 = rigidbody_format.index("quat_2") self.__index_quat_3 = rigidbody_format.index("quat_3") self.__index_quat_4 = rigidbody_format.index("quat_4") self.__osc_format_length = len(rigidbody_format) self.__server = OSCServer((ip, int(port))) # TODO check the ThreadingOSCServer class as possible alternative print "Optitrack:", self.__server self.__server.handle_timeout = types.MethodType( self.__handle_timeout, self.__server ) self.__server.timeout = 0 self.__server.addMsgHandler( "/tracking/optitrack/rigidbodies", self.__on_osc_rigidbody_message_received ) self.__server.addMsgHandler( "/kill", self.__on_osc_kill_message_received ) self.publish(self.OSC_optitrack_MessageID) self.publish(self.OSC_optitrack_KillMessageID) except OSCError: print "############################################" print "####### could not open OSCServer ###########" print "############################################" return def __handle_timeout(self, status): """Handle server timeouts.""" self.__server.timed_out = True def onFrame(self): """Stay active.""" self.__server.timed_out = False # handle all pending requests than return while not self.__server.timed_out: self.__server.handle_request() def run(self): """Start running the server.""" while True: self.__server.handle_request() self.__server.close() def __on_osc_rigidbody_message_received(self, addr, tags, data, client_address): """b Receives an OSC message, transforms the data and notifies subscribers by sending a message (type: list) containing skeleton_id and skeleton_joint (type: SkeletonJoint) Args: addr: the address (str e.g. /tracking/optitrack/rigidbodies) tags: tags (str with i for int32 and f for float, e.g. iiiifff) data: tracking data, containing id (0), position in space (1-3), and orientation in space (4-6) client_address: client address as (ip, port) tuple """ # check if length could actually be a rigid body message if len(data) < self.__osc_format_length: return data[self.__index_x] = data[self.__index_x] * 100 data[self.__index_y] = config.display_height_cm - data[self.__index_y] * 100 data[self.__index_z] = data[self.__index_z] * 100 # create RigidBody tuple rb = RigidBody( id=data[self.__index_id], name=data[self.__index_name], position=Point3D(data[self.__index_x], data[self.__index_y], data[self.__index_z]), orientation=(data[self.__index_roll], data[self.__index_pitch], data[self.__index_yaw]), orientation_quat=(data[self.__index_quat_1], data[self.__index_quat_2], data[self.__index_quat_3], data[self.__index_quat_4]), markers=None, mrk_ids=None, mrk_sizes=None, mrk_mean_error=None ) # send new rigidbody to subscriber self.notifySubscribers(self.OSC_optitrack_MessageID, [rb]) def __on_osc_kill_message_received(self, addr, tags, data, client_address): """ receives the kill event from oscserver and reacts ?? """ self.notifySubscribers(self.OSC_optitrack_KillMessageID, data)
class Osc(object): def __init__(self, listen_port=7331, timeout=4, timeout_fade_duration=4): # create an OSC server and bind it to listen on port 7331 self.server = OSCServer(("", listen_port)) self.server.timeout = 0 self.server.handle_timeout = types.MethodType( lambda x: self.handle_timeout(), self.server) # Create handlers for "/rgb" and "/hsv". This causes a packet to "/rgb" to call self.set_rgb() # and a packet to "/hsv" to call self.set_hsv(), with the arguments path, tags, args, source self.server.addMsgHandler("/rgbw", lambda p, t, a, s: self.set_rgbw(p, t, a, s)) self.server.addMsgHandler("/rgb", lambda p, t, a, s: self.set_rgb(p, t, a, s)) self.server.addMsgHandler("/r", lambda p, t, a, s: self.set_r(p, t, a, s)) self.server.addMsgHandler("/g", lambda p, t, a, s: self.set_g(p, t, a, s)) self.server.addMsgHandler("/b", lambda p, t, a, s: self.set_b(p, t, a, s)) self.server.addMsgHandler("/w", lambda p, t, a, s: self.set_w(p, t, a, s)) self.server.addMsgHandler("/hsv", lambda p, t, a, s: self.set_hsv(p, t, a, s)) self.server.addMsgHandler("/h", lambda p, t, a, s: self.set_h(p, t, a, s)) self.server.addMsgHandler("/s", lambda p, t, a, s: self.set_s(p, t, a, s)) self.server.addMsgHandler("/v", lambda p, t, a, s: self.set_v(p, t, a, s)) # Initialize variables self.color = Color(0.0, 0.0, 0.0, 0.0) self.opacity = 0.0 self.timeout = timeout self.timeout_fade_duration = timeout_fade_duration # Setup our animation queue self.anim_queue = AnimationQueue() # The last time we got a message on our socket self.last_msg_time = time.time() # Close the socket on exit def cleanup(self): self.server.close() def got_a_packet(self): self.opacity = 1.0 self.last_msg_time = time.time() self.anim_queue.clear() # Set the current color in either RGB or HSV colorspace def set_rgbw(self, path, tags, args, source): self.color.setRGBW(*args) self.got_a_packet() def set_rgb(self, path, tags, args, source): self.color.setRGB(*args) self.got_a_packet() def set_r(self, path, tags, args, source): print path, tags, args, source self.color.setR(args[0]) self.got_a_packet() def set_g(self, path, tags, args, source): self.color.setG(args[0]) self.got_a_packet() def set_b(self, path, tags, args, source): self.color.setB(args[0]) self.got_a_packet() def set_w(self, path, tags, args, source): self.color.setB(args[0]) self.got_a_packet() def set_hsv(self, path, tags, args, source): self.color.setHSV(*args) self.got_a_packet() def set_h(self, path, tags, args, source): self.color.setH(args[0]) self.got_a_packet() def set_s(self, path, tags, args, source): self.color.setS(args[0]) self.got_a_packet() def set_v(self, path, tags, args, source): self.color.setV(args[0]) self.got_a_packet() # This gets called when we have no more packets waiting to be processed def handle_timeout(self): self.timed_out = True # This function retrieves the next color from the Audio object def next(self, color_in): # process any messages we might have waiting for us. We do this by calling handle_request() until # handle_timeout() gets called, at which point we stop: self.timed_out = False while not self.timed_out: self.server.handle_request() # If we've not received a message for `timeout` seconds, slowly ease back to 1.0 power if self.last_msg_time + self.timeout < time.time( ) and self.opacity != 0.0: # Ease slowly from the current value of self.opacity to 0.0 self.anim_queue.push( ease(self.opacity, 0.0, self.timeout_fade_duration, sin_ease)) # This ensures that once the animation is done, we stay at 0.0, and also that we # don't keep on animating over and over again (e.g. the if statement directly above # doesn't keep on activating over and over again) self.opacity = 0.0 # If we're easing back to 0.0 after a client disconnect, then this animation does something. # If we're receiving packets like normal, this animation does nothing, it just returns self.opacity animated_opacity = self.anim_queue.animate(default_value=self.opacity) # Mix between color_in and our stored self.color return color_in * (1.0 - animated_opacity) + animated_opacity * self.color
def main(robotIP, PORT = 9559): myBroker = ALBroker("myBroker", #needed for subscribers and to construct naoqi modules "0.0.0.0", 0, robotIP, PORT) meanx = 0.21835 meany = 0.035625 global ReactToTouch, go_to_center, global_time global server, client client = OSCClient() client.connect(("192.168.0.5",1234)) global motionProxy, jointNames motionProxy = ALProxy("ALMotion", robotIP, PORT) postureProxy = ALProxy("ALRobotPosture", robotIP, PORT) motionProxy.setStiffnesses("Body",0) motionProxy.setStiffnesses(jointNames,1) #motionProxy.openHand("LHand") #motionProxy.closeHand("LHand") maxSpeedFraction = 0.3 for i in range(1): motionProxy.angleInterpolationWithSpeed(jointNames, p[i], maxSpeedFraction) time.sleep(1.0) minx = -999 maxx = 999 miny = -999 maxy = 999 # Copy from inverse kinematics effector = "LArm" space = motion.FRAME_ROBOT axisMask = almath.AXIS_MASK_VEL # just control position isAbsolute = False # Since we are in relative, the current position is zero currentPos = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0] center = currentPos # Define the changes relative to the current position dx = 0.03 # translation axis X (meters) dy = -0.04 # translation axis Y (meters) dz = 0.03 # translation axis Z (meters) dwx = 0.00 # rotation axis X (radians) dwy = 0.00 # rotation axis Y (radians) dwz = 0.00 # rotation axis Z (radians) targetPos = [dx, dy, dz, dwx, dwy, dwz] # Go to the target and back again path = [targetPos] times = [1.5] # seconds motionProxy.positionInterpolation(effector, space, path, axisMask, times, isAbsolute) dz=0.00 currentPos = motionProxy.getPosition(effector, space, True) offx = 0.034 offy = 0.02 xy=[1345+103-(currentPos[0]+offx)*400/(0.07), (currentPos[1]+offy)*400/(0.07)+11-87-45] #print xy input('Press 1 to begin: ') k=2.5 L=0.5 n=10 speed = 0.15 #Initialize listener ReactToTouch = ReactToTouch("ReactToTouch") center = motionProxy.getPosition(effector, space, True) print "center: " + str(center[0]) + ", " + str(center[1]) try: while 1:#for i in range(n): if go_to_center: if random.random()<0.95: k=max(0.9,k-0.15) speed = 0.4 go_to_center = False #print 'going to center!' # Get current Position & define target position if random.random()<0.8: currentPos = motionProxy.getPosition(effector, space, True) maxx = min(maxx,abs(currentPos[0]-meanx)) maxy = min(maxy,abs(currentPos[1]-meany)) #targetPos = currentPos targetPos[0] = center[0] targetPos[1] = center[1] targetPos[2] = center[2] #print 'new target' #print targetPos # Move to position, being able to interrupt motionProxy.setPosition(effector, space, targetPos, speed, axisMask) #Try it twice, because it doesn't seem to get there '''currentPos = motionProxy.getPosition(effector, space, True) motionProxy.positionInterpolation(effector, space, [currentPos], axisMask, [0.51], isAbsolute) targetPos = [currentPos[0]-center[0], currentPos[1]-center[1], currentPos[2]-center[2], 0.0, 0.0, 0.0] path = [targetPos] print targetPos motionProxy.positionInterpolation(effector, space, path, axisMask, [0.51], isAbsolute) print "sleeping 2 seconds"''' global_time = time.time() else: speed = 0.18 # False learning if random.random()<0.15: k=max(0.85,k-0.15) # Generate next target x,y x = k*random.random()*L-L/2 + center[0] y = k*random.random()*L-L/2 + center[1] # Get current Position & define target position #currentPos = motionProxy.getPosition(effector, space, True) #targetPos = currentPos targetPos[0] = x#min(max(x,meanx-maxx),meanx+maxx) targetPos[1] = y#min(max(y,meany-maxy),meany+maxy) targetPos[2] = center[2] #print 'new target' #print targetPos # Move to position, being able to interrupt motionProxy.setPosition(effector, space, targetPos, speed, axisMask) now = time.time() go_to_center = False while time.time()-now < times[0] and not go_to_center: #time.sleep(0.1) currentPos = motionProxy.getPosition(effector, space, True) offx = 0.034 offy = 0.04 xy=[1345+97-(currentPos[0]+offx)*400/(0.07), (currentPos[1]+offy)*400/(0.07)+107-87-45] #print xy sendOSC('/xy',xy) time.sleep(0.01) print 'out of the loop' """else: #currentPos = motionProxy.getPosition(effector, space, True) #center[0] -= targetPos[0] #center[1] -= targetPos[1] """ print 'Done!' server = OSCServer( ("" , 2222) ) server.addMsgHandler("/move", move) while 1: server.handle_request() except KeyboardInterrupt: print "closing all OSC connections... and exit" motionProxy.rest() myBroker.shutdown() server.close() motionProxy.rest()
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): return self.coords[hand][Y] < 0 and self.hand_over_piano(hand) def hand_up(self, hand): return self.coords[hand][Y] >= 0 or not self.hand_over_piano(hand) def hand_over_piano(self, hand): return Magnitude(SubVector(self.coords[hand], Y,Z)) > 350 def hand_hit(self, hand): """waits for a hit from the specified hand""" if self.hand_down(hand): wait_for(self.hand_up, (hand,)) wait_for(self.hand_down, (hand,)) return self.coords[hand][X] def joint_moved_x(self, prev_x, joint, hit_location): """used to wait for a change in joint in X dimension""" if self.hand_up(joint): return True if hit_location is not None and abs(hit_location - self.coords[joint][X]) < 140: return False return abs(prev_x - self.coords[joint][X]) > 70 def hand_slide(self, hand, hit_location): x = self.coords[hand][X] wait_for(self.joint_moved_x, (x, hand, hit_location)) if self.hand_up(hand): return False return self.coords[hand][X] def get_coord(self, joint): if joint == 'leftshoulder': return -250, 200, -50 elif joint == 'rightshoulder': return 250, 200, -50 else: return self.coords[joint] def sendToKinect(self, address, items): self._sendMsg(self.kinect_client, address, items) def sendToMax(self, address, items): self._sendMsg(self.max_client, address, items) @staticmethod def _sendMsg(client, address, items): m = OSCMessage() m.setAddress(address) m.append(items) client.send(m)
class LiveRawAPI(object): """ This is close to live's API objects as possible Of course, they are designed to be manipulated from a patcher, not real code, so a bit more wrapping is in order. To keep everything minimal, this is done in a subclass. """ _incoming = None _handled = True _received = False debug = False 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 raw_query(self, *args): """Posts a query, waits for a response. Returns it. Note that state is fragile here, so you'd better be sure that there will be a response, or it will hang waiting.""" self.oscclient.send(OSCMessage('/query', args)) return self.handle_request() def raw_call(self, *args): """Posts a call, returns nothing. Note that state is fragile here, so you'd better be sure that there will be no response, or you won't know what returned what.""" self.oscclient.send(OSCMessage('/query', ['path', 'getpath'])) def _handle_response(self, path, tags, args, source): """private callback to handle OSC responses. Sets state.""" if self.debug: print "callback", path, args, source self._incoming.append(args) self._received = True def handle_request(self): """hack to handle asynchronous calls: 1 try to get something returned and tacked onto the class. 2 Return it and reset. This is completely f****d at the momenl I can't make timeouts work in any usable fashion.""" try: self.oscserver.handle_request() while self._received: self._received = False self.oscserver.handle_request() _incoming = self._incoming return _incoming finally: self._incoming = [] self._received = False def close(self): self.oscserver.close() ### more structured access involves navigating places with the path object def goto(self, *args): resp = self.raw_query('path', 'goto', *args) prefix, path = resp[1], resp[2:] #sanity check that we are getting the right message assert prefix=='path' self.path = path def path(self, *args): return self.goto(*args) def getchildren(self): resp = self.raw_query('path', 'getchildren') return resp[1:] def getcount(self): resp = self.raw_query('path', 'getcount') return resp[1:]
# OSC Communication # - receiving OSC Messages in Python from OSC import OSCServer import time, threading recvAddress = ('127.0.0.1', 9001) oscServer = OSCServer(recvAddress) def oscTestHandler(addr, tags, data, source): print "Received '/oscTest %s'" % data oscServer.addMsgHandler("/oscTest", oscTestHandler) print "\nWaiting for messages from SuperCollider. Use ctrl-C to quit." oscServerThread = threading.Thread( target = oscServer.serve_forever ) oscServerThread.start() try : while 1 : time.sleep(5) except KeyboardInterrupt : print "\nClosing OSCServer." oscServer.close() print "Waiting for Server-thread to finish" oscServerThread.join() print "Done"
# 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
class OscInput(BaseComponent): config_name = 'osc_inputs' def __init__(self, options={}): BaseComponent.__init__(self, options) # attributes self.osc_server = None self.connected = False self.running = False self.osc_map = None self.threaded = self.getOption('threaded', True) self.thread = None def __del__(self): self.destroy() def setup(self, event_manager=None): BaseComponent.setup(self, event_manager) self.msgEventMapping = self.getOption('output_events', {}) self.autoAddrToEvent = 'auto' in self.msgEventMapping and self.msgEventMapping[ 'auto'] # events self.connectEvent = self.getOutputEvent('connect') self.disconnectEvent = self.getOutputEvent('disconnect') self.messageEvent = self.getOutputEvent( 'message', dummy=False) # can be None if not configured if self.getOption('autoStart', True): self.start() def destroy(self): self.msgEventMapping = None self.event_manager = None self.stop() def start(self): if self._connect(): self.running = True def stop(self): if self.connected: self._disconnect() self.running = False def update(self): if self.connected: if not self.threaded: self._processIncomingMessages() def _processIncomingMessages(self): # we'll enforce a limit to the number of osc requests # 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()
class Kinect(threading.Thread): kRightHand = "/righthand" kLeftHand = "/lefthand" kRightElbow = "/rightelbow" kLeftElbow = "/leftelbow" kRightFoot = "/rightfoot" kLeftFoot = "/leftfoot" kRightKnee = "/rightknee" kLeftKnee = "/leftknee" kHead = "/head" kTorso = "/torso" kLeftShoulder = "/leftshoulder" kRightShoulder = "/rightshoulder" kLeftHip = "/lefthip" kRightHip = "/righthip" kClosestHand = "/closesthand" # position coordinate system type kBody = '_pos_body' kWorld = '_pos_world' kScreen = '_pos_screen' kPosNum = {kBody: 1, kWorld: 2, kScreen: 3} def __init__(self, remote_ip=None, pos_type=kBody): super(Kinect, self).__init__() self.pos_type = pos_type # 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() core.register_terminate_func(self.close) # 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 + self.pos_type, self.callback) self.active_joints[joint] = np.array([0.0, 0.0, 0.0]) def remove_joint(self, joint): self.server.delMsgHandler(joint + self.pos_type) 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: self.client.send( OSCMessage(j + "_trackjointpos", Kinect.kPosNum[self.pos_type])) 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(self.pos_type, "") self.active_joints[joint_name] = np.array(args) def callback_tracking_skeleton(self, path, tags, args, source): pass
class XAirClient: """ Handles the communication with the X-Air mixer via the OSC protocol """ _CONNECT_TIMEOUT = 0.5 _WAIT_TIME = 0.02 _REFRESH_TIMEOUT = 5 XAIR_PORT = 10024 last_cmd_addr = '' last_cmd_time = 0 info_response = [] 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 validate_connection(self): self.send('/xinfo') time.sleep(self._CONNECT_TIMEOUT) if len(self.info_response) > 0: print 'Successfully connected to %s with firmware %s at %s.' % (self.info_response[2], self.info_response[3], self.info_response[0]) else: print 'Error: Failed to setup OSC connection to mixer. Please check for correct ip address.' exit() def run_server(self): try: self.server.serve_forever() except KeyboardInterrupt: self.client.close() self.server.close() exit() def msg_handler(self, addr, tags, data, client_address): if time.time() - self.last_cmd_time < self._WAIT_TIME and addr == self.last_cmd_addr: #print 'Ignoring %s' % addr self.last_cmd_addr = '' else: #print 'OSCReceived("%s", %s, %s)' % (addr, tags, data) if addr.endswith('/fader') or addr.endswith('/on') or addr.startswith('/config/mute') or addr.startswith('/fx/'): self.state.received_osc(addr, data[0]) elif addr == '/xinfo': self.info_response = data[:] def refresh_connection(self): try: while True: if self.client != None: self.send("/xremote") time.sleep(self._REFRESH_TIMEOUT) except KeyboardInterrupt: exit() def send(self, address, param = None): if self.client != None: msg = OSCMessage(address) if param != None: # when sending values, ignore ACK response self.last_cmd_time = time.time() self.last_cmd_addr = address if isinstance(param, list): msg.extend(param) else: msg.append(param) else: # sending parameter request, don't ignore response self.last_cmd_time = 0 self.last_cmd_addr = '' self.client.send(msg)
def step_impl(context, message): listen = OSCServer(("127.0.0.1", 4589)) listen.timeout = 0 #infinite timeout listen.addMsgHandler("/err", listen_handler) listen.close()
class OscReader: def __init__(self, host="127.0.0.1", port=8080, manager=None, threaded=False, autoStart=True): # params self.manager = manager self.host = host self.port = port self.threaded = threaded # attrs self._kill = False self.oscServer = None self.thread = None if autoStart: self.start() def setup(self): if self.oscServer != None: self.destroy() ColorTerminal().output("Starting OSC server with host {0} and port {1}".format(self.host, self.port)) self.oscServer = OSCServer((self.host, self.port)) self.oscServer.handle_timeout = self.handleTimeout self.oscServer.addMsgHandler('/marker', self.oscMarkerHandler) self.oscServer.addMsgHandler('/rigidbody', self.oscRigidBodyHandler) ColorTerminal().success("Server running") def destroy(self): if self.oscServer == None: return self.oscServer.close() self.oscServer = None def update(self): if self.oscServer == None: return # we'll enforce a limit to the number of osc requests # we'll handle in a single iteration, otherwise we might # get stuck in processing an endless stream of data limit = 10 count = 0 # clear timed_out flag self.oscServer.timed_out = False # handle all pending requests then return while not self.oscServer.timed_out and count < limit: self.oscServer.handle_request() count += 1 def oscMarkerHandler(self, addr, tags, data, client_address): if self.manager: self.manager.processMarkersData([data[0]]) def oscRigidBodyHandler(self, addr, tags, data, client_address): # readers can interface with the mocap data manager directly (most efficient) if self.manager: self.manager.processRigidBodyJson(data[0]) def handleTimeout(self): if self.oscServer != None: self.oscServer.timed_out = True def start(self): if not self.threaded: self.setup() return if self.thread and self.thread.isAlive(): ColorTerminal().warn("OscReader - Can't start while a thread is already running") return self._kill = False # threaded loop method will call setup self.thread = threading.Thread(target=self.threaded_loop) self.thread.start() def stop(self): if self.threaded: # threaded loop method will call destroy self._kill = True else: self.destroy() def threaded_loop(self): self.setup() while not self._kill: self.update() self.destroy()
print args print source print mDirection print '-----------' if mDirection == 'forward' and msgVal == 1: moveRover.forward(config.getint('motor_params', 'DEFAULT_SPEED')) elif mDirection == 'backward' and msgVal == 1: moveRover.backward(config.getint('motor_params', 'DEFAULT_SPEED')) elif mDirection == 'right' and msgVal == 1: moveRover.right(config.getint('motor_params', 'DEFAULT_SPEED')) elif mDirection == 'left' and msgVal == 1: moveRover.left(config.getint('motor_params', 'DEFAULT_SPEED')) else: moveRover.stop() directions = ['forward', 'backward', 'right', 'left'] #Message Handlers and Callback functions for direction in directions: oscSrv.addMsgHandler("/move/" + direction, move) print "\n listening on port: %s" % config.get('osc_srv', 'PORT') try: while True: oscSrv.handle_request() except KeyboardInterrupt: print "Quit" oscSrv.close()
class OscReceiver(MessageReceiverInterface): """A class for receiving Osc messages and passing them to its subscribers""" def __init__(self, others, protos, ip="127.0.0.1", port=8888): MessageReceiverInterface.__init__(self) self.oscServerIp = ip self.oscServerPort = port self.oscMasterIp = None self.oscMasterPort = None ## this is a dict of names to receivers ## like: 'sms' -> SmsReceiver_instance ## keys are used to match against osc requests self.allReceivers = others ## to enable osc forwarding, add osc server as subscriber to all receivers for k in self.allReceivers: self.allReceivers[k].addSubscriber((self.oscServerIp,self.oscServerPort)) ## this is a dict of (ip,port) -> prototype ## like: (192.168.2.5, 8888) -> megavoice self.allPrototypes = protos def _oscHandler(self, addr, tags, stuff, source): addrTokens = addr.lstrip('/').split('/') ## /LocalNet/{Add,Remove}/Type -> port-number if ((addrTokens[0].lower() == "localnet") and (addrTokens[1].lower() == "add")): ip = getUrlStr(source).split(":")[0] port = int(stuff[0]) self.allPrototypes[(ip,port)] = addrTokens[2] if (addrTokens[3].lower() in self.allReceivers): 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()
class OscInput(BaseComponent): config_name = 'osc_inputs' def __init__(self, options = {}): BaseComponent.__init__(self, options) # attributes self.osc_server = None self.connected = False self.running = False self.osc_map = None self.threaded = self.getOption('threaded', True) self.thread = None def __del__(self): self.destroy() def setup(self, event_manager=None): BaseComponent.setup(self, event_manager) self.msgEventMapping = self.getOption('output_events', {}) self.autoAddrToEvent = 'auto' in self.msgEventMapping and self.msgEventMapping['auto'] # events self.connectEvent = self.getOutputEvent('connect') self.disconnectEvent = self.getOutputEvent('disconnect') self.messageEvent = self.getOutputEvent('message', dummy=False) # can be None if not configured if self.getOption('autoStart', True): self.start() def destroy(self): self.msgEventMapping = None self.event_manager = None self.stop() def start(self): if self._connect(): self.running = True def stop(self): if self.connected: self._disconnect() self.running = False def update(self): if self.connected: if not self.threaded: self._processIncomingMessages() def _processIncomingMessages(self): # we'll enforce a limit to the number of osc requests # 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()
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
class LiveRawAPI(object): """ This is close to live's API objects as possible Of course, they are designed to be manipulated from a patcher, not real code, so a bit more wrapping is in order. To keep everything minimal, this is done in a subclass. """ _incoming = None _handled = True _received = False debug = False 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 raw_query(self, *args): """Posts a query, waits for a response. Returns it. Note that state is fragile here, so you'd better be sure that there will be a response, or it will hang waiting.""" self.oscclient.send(OSCMessage('/query', args)) return self.handle_request() def raw_call(self, *args): """Posts a call, returns nothing. Note that state is fragile here, so you'd better be sure that there will be no response, or you won't know what returned what.""" self.oscclient.send(OSCMessage('/query', ['path', 'getpath'])) def _handle_response(self, path, tags, args, source): """private callback to handle OSC responses. Sets state.""" if self.debug: print "callback", path, args, source self._incoming.append(args) self._received = True def handle_request(self): """hack to handle asynchronous calls: 1 try to get something returned and tacked onto the class. 2 Return it and reset. This is completely f****d at the momenl I can't make timeouts work in any usable fashion.""" try: self.oscserver.handle_request() while self._received: self._received = False self.oscserver.handle_request() _incoming = self._incoming return _incoming finally: self._incoming = [] self._received = False def close(self): self.oscserver.close() ### more structured access involves navigating places with the path object def goto(self, *args): resp = self.raw_query('path', 'goto', *args) prefix, path = resp[1], resp[2:] #sanity check that we are getting the right message assert prefix == 'path' self.path = path def path(self, *args): return self.goto(*args) def getchildren(self): resp = self.raw_query('path', 'getchildren') return resp[1:] def getcount(self): resp = self.raw_query('path', 'getcount') return resp[1:]
class OscReader: def __init__(self, host="127.0.0.1", port=8080, manager=None, threaded=False, autoStart=True): # params self.manager = manager self.host = host self.port = port self.threaded = threaded # attrs self._kill = False self.oscServer = None self.thread = None if autoStart: self.start() def setup(self): if self.oscServer != None: self.destroy() ColorTerminal().output( "Starting OSC server with host {0} and port {1}".format( self.host, self.port)) self.oscServer = OSCServer((self.host, self.port)) self.oscServer.handle_timeout = self.handleTimeout self.oscServer.addMsgHandler('/marker', self.oscMarkerHandler) self.oscServer.addMsgHandler('/rigidbody', self.oscRigidBodyHandler) ColorTerminal().success("Server running") def destroy(self): if self.oscServer == None: return self.oscServer.close() self.oscServer = None def update(self): if self.oscServer == None: return # we'll enforce a limit to the number of osc requests # we'll handle in a single iteration, otherwise we might # get stuck in processing an endless stream of data limit = 10 count = 0 # clear timed_out flag self.oscServer.timed_out = False # handle all pending requests then return while not self.oscServer.timed_out and count < limit: self.oscServer.handle_request() count += 1 def oscMarkerHandler(self, addr, tags, data, client_address): if self.manager: self.manager.processMarkersData([data[0]]) def oscRigidBodyHandler(self, addr, tags, data, client_address): # readers can interface with the mocap data manager directly (most efficient) if self.manager: self.manager.processRigidBodyJson(data[0]) def handleTimeout(self): if self.oscServer != None: self.oscServer.timed_out = True def start(self): if not self.threaded: self.setup() return if self.thread and self.thread.isAlive(): ColorTerminal().warn( "OscReader - Can't start while a thread is already running") return self._kill = False # threaded loop method will call setup self.thread = threading.Thread(target=self.threaded_loop) self.thread.start() def stop(self): if self.threaded: # threaded loop method will call destroy self._kill = True else: self.destroy() def threaded_loop(self): self.setup() while not self._kill: self.update() self.destroy()
class liveScriptWindow(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.exitFlag = False self.parent = parent self.ck_ctl = ck_ctl self.is_locked = False self.is_muted = False self.lock_timer = None self.offset_time = 0.0 self.current_song_name = "" self.tempo = 120.0 self.signature_numerator = 4 self.signature_denominator = 4 self.song_saved = True self.arrQueue = [] self.undoables = 0 self.first_run = True self.setlist_window = None self.filler_words = ['slot','sl','scene','ch','channel','track'] self.xpos = 870 self.ypos = 420 self.ls = ls(self) self.setlist = [] self.setlist_file = "setlist.txt" self.setlist_window = ls_setlist_window(self) self.setlist_xpos = 150 self.setlist_ypos = 350 if ck_ctl: self.control_panel = ck_control_panel(self) self.control_panel_xpos = 0 self.control_panel_ypos = 0 self.prefs_file = "prefs.txt" self.load_prefs() parent.wm_title("LiveScript") parent.geometry("720x400+" + str(self.xpos) + "+" + str(self.ypos) ) parent.configure(bg="black") self.font_big = Font(family="Ariel", size=24) self.font_med = Font(family="Ariel", size=18) label_title = Label(parent, text="Name:", bg="black", fg="white") label_title.grid(row=0, column=0, sticky=E) self.sv = StringVar() self.sv.trace("w", lambda name, index, mode, sv=self.sv: self.text_changed()) self.entry_title = Entry(parent, width=22,exportselection=False, bg="black", fg="lightblue", font=self.font_big, insertbackground="white", textvariable = self.sv, borderwidth=0) self.entry_title.grid(row=0, column=1,sticky=W) self.label_count = Label(parent, text="0/0", bg="black", fg="white", font=self.font_med) self.label_count.grid(row=0, column=2, sticky=S) self.button_add = Button(parent, text="Add", command=self.scene_add,bg="#003366", fg="white", width=5) self.button_add.grid(row=0, column=3, sticky=S) self.button_del = Button(parent, text="Delete", command=self.scene_del,bg="#664433", fg="white", width=5) self.button_del.grid(row=0, column=4, padx=6, sticky=S) self.listbox_setlist = Listbox(parent, height=18,width=15,exportselection=False, bg="black", fg="white") self.listbox_setlist.grid(row=0, column=5, columnspan=2, rowspan=5, sticky=NW, pady=12) label_desc = Label(parent, text="Info:", bg="black", fg="white") label_desc.grid(row=1, column=0, sticky=E) self.sv2 = StringVar() self.sv2.trace("w", lambda name, index, mode, sv=self.sv2: self.text_changed()) self.entry_desc = Entry(parent, width=22,exportselection=False, bg="black", fg="blue", font=self.font_big, insertbackground="white", textvariable = self.sv2, borderwidth=0) self.entry_desc.grid(row=1, column=1,sticky=NW) self.button_reload = Button(parent, text="Reload", command=self.reload,bg="#664433", fg="white", width=8) self.button_reload.grid(row=1, column=2, sticky=W, padx=0) self.button_move_up = Button(parent, text="Up", command=self.scene_up,bg="#333333", fg="white", width=5) self.button_move_up.grid(row=1, column=3, padx=6, pady=10) self.button_move_down = Button(parent, text="Down", command=self.scene_down,bg="#333333", fg="white", width=5) self.button_move_down.grid(row=1, column=4, padx=6, pady=10) self.button_undo = Button(parent, text="Undo", command=self.undo,bg="#003366", fg="white") self.button_undo.grid(row=2, column=0, sticky=N) self.text_scroll = Scrollbar(parent) self.text_script = Text(parent, height=14, width=50, bg="#333333", selectbackground="blue", fg="white", insertbackground="white", wrap=WORD) self.text_script.grid(row=2, column=1, rowspan=2,sticky=W) self.text_scroll.grid(row=2,column=2, sticky=N+S+W,rowspan=2) self.text_script.config(yscrollcommand=self.text_scroll.set) self.text_scroll.config(command=self.text_script.yview) self.text_script.tag_configure("even",background="#222222") self.text_script.tag_configure("odd",background="#000000") self.text_script.tag_configure("sel",bgstipple="@solid.xbm", borderwidth=1) #background="#cc0000", self.button_prev = Button(parent, text="Previous", command=self.prevScene,bg="#003366", fg="white", width=13, height=3) self.button_prev.grid(row=2, column=3, columnspan=2, sticky=N) self.button_undo_all = Button(parent, text="Undo\nAll", command=self.undo_all,bg="#003366", fg="white") self.button_undo_all.grid(row=3, column=0, sticky=N, pady=20) self.button_undo_all = Button(parent, text="Undo\n+\nRedo", command=self.undo_redo,bg="#003366", fg="white") self.button_undo_all.grid(row=3, column=0, sticky=S) self.button_next = Button(parent, text="Next", command=self.nextScene,bg="#003366", fg="white", height=9, width=13) self.button_next.grid(row=3, column=3, columnspan=2, sticky=S, pady=6) label_next = Label(parent, text="Next:", bg="black", fg="white") label_next.grid(row=4, column=0, sticky=E) self.label_next_title = Label(parent, text="(next scene)", bg="black", fg="#FF6666", font=self.font_big, width=21, anchor=W) self.label_next_title.grid(row=4, column=1, sticky=W) self.button_save = Button(parent, text="Save", command=self.saveSong,bg="green", fg="black", width=8) self.button_save.grid(row=4, column=2) self.button_mute = Button(parent, text="Mute", command=self.mute,bg="#333333", fg="white", width=13) self.button_mute.grid(row=4, column=3, columnspan=2) self.button_setlist = Button(parent, text="Setlist\nManager", command=self.setlist_window.open,bg="#003366", fg="white", width=13) self.button_setlist.grid(row=4, column=5, sticky=N) label_info2 = Label(parent, text="Info:", bg="black", fg="white") label_info2.grid(row=5, column=0, sticky=E) self.label_next_info = Label(parent, text="(next desc)", bg="black", fg="red", font=self.font_big, width=21, anchor=W) self.label_next_info.grid(row=5, column=1, sticky=NW) self.button_send = Button(parent, text="Send", command=self.sendBox,bg="#003366", fg="white", width=8) self.button_send.grid(row=5, column=2) #self.liveTime = Label(parent, text="0") #self.liveTime.pack(side="top",anchor="n") self.button_play = Button(parent, text="Play", command=lambda: self.ls.playback(['foo','play'],True),bg="#003366", fg="white", width=5) self.button_play.grid(row=5, column=3) self.button_stop = Button(parent, text="Stop", command=lambda: self.ls.playback(['foo','stop'],True),bg="#003366", fg="white", width=5) self.button_stop.grid(row=5, column=4) if ck_ctl: self.button_stop = Button(parent, text="Ctl", command=self.control_panel.open,bg="#003366", fg="white", width=5) self.button_stop.grid(row=5, column=5) self.server = OSCServer( ("localhost", 9000) ) self.server.timeout = 0 self.timed_out = False self.server.addMsgHandler( "/livescript/next", self.nextScene ) self.server.addMsgHandler( "/live/sync", self.update_sync ) self.server.addMsgHandler( "/live/error", self.live_error ) for crap in ['master/devices','startup','track/devices','track/device/param','return/devices','track/volume','track/select','track/send','tempo','metronome','play','track/state']: self.server.addMsgHandler( "/live/" + crap, self.foo ) self.server.handle_timeout = types.MethodType(self.handle_timeout, self.server) self.client = OSCClient() self.client.connect( ("localhost", 9001) ) self.scene_index = 0 self.song_index = -1 self.arrSong = [] self.arrScene = [] #self.setPath = "songs/" self.load_set() #def setlist_window_remove(self): # self.setlist_window.destroy() # self.setlist_window = None def foo(self,*args): pass def text_changed(self,*args): self.button_save.configure(bg="red",text="Save Me") def mute(self,*args): if self.is_muted: self.is_muted = False self.button_mute.configure(bg="#333333",text="Mute", fg="white") else: self.is_muted = True self.button_mute.configure(bg="red",text="Muted!") def update_sync(self,path, tags, args, source): network_lag = .01 self.offset_time = args[2] - time.clock() + network_lag self.tempo = args[1] live_time = (time.clock() + self.offset_time ) / (self.signature_numerator / (self.tempo / 60.0)) print(str(live_time)[0:5] + " time:" + str(args)) def live_error(self,path, tags, args, source): print("live error! " + str(args)) def load_prefs(self): if os.path.isfile(self.prefs_file): f = open(self.prefs_file,'r+') prefs_data = json.load(f) print("loading from prefs file") f.close() print(prefs_data) for pref in prefs_data: print(str(pref) + ":" + str(prefs_data[pref])) setattr(self, pref, prefs_data[pref]) else: print("creating new prefs file") self.save_prefs() #prefs_data = json.loads('{"setlist_file":"setlist.txt"}') #prefs_data = {"setlist_file":"setlist.txt",} #json.dumps(prefs_data) def save_prefs(self): saveable_prefs = ['setlist_file','tempo','xpos','ypos','setlist_xpos','setlist_ypos','control_panel_xpos','control_panel_ypos'] print("window at:" + str(self.parent.winfo_x()) + " x " + str(self.parent.winfo_y())) self.xpos = self.parent.winfo_x() self.ypos = self.parent.winfo_y() # if os.path.isfile(self.prefs_file): f = open(self.prefs_file,'w') print("saving to prefs file") # else: # print("creating new prefs file!") # f = open(self.prefs_file,'a') dict_prefs = {} for pref in saveable_prefs: dict_prefs[pref] = getattr(self,pref) f.write(json.dumps(dict_prefs)) f.close() def load_set(self): if os.path.isfile(self.setlist_file): f = open(self.setlist_file,'r') setlist = json.load(f) print("loading from set file") else: print("creating new set file") f = open(self.setlist_file,'a') setlist = "empty set," #ex.prefs = json.loads('{"mod":0}') #json.dump(ex.prefs, f) f.close() self.setlist = setlist #.split('\n') #ls.text_script.insert(END,ls.setlist) self.listbox_setlist.delete(0, END) self.setlist = [] for song in setlist: #.split('\n'): #song = song.split(",") self.setlist.append(song) self.listbox_setlist.insert(END,song[0]) self.listbox_setlist.selection_set(0) #print("setlist:" + str(self.setlist)) def handle_timeout(self,server): self.timed_out = True def saveSong(self): self.arrSong[self.scene_index] = self.entry_title.get() + "," + self.entry_desc.get() + "," + self.text_script.get("1.0",END).replace('\n',',').replace('\r','').strip(',').strip(' ') #songFile = self.setPath + self.current_song_name + ".csv" songFile = self.setlist[self.song_index][1] f = open(songFile,'w') f.write('\n'.join(self.arrSong)) print("saving to ",songFile) f.close() self.button_save.configure(bg="green",text="Saved") self.text_script.edit_modified(False) self.song_saved = True def loadSong(self): songFile = self.setlist[self.song_index][1] if os.path.isfile(songFile): f = open(songFile,'r+') self.arrSong = f.read().split('\n') #json.load(f) we gonna json this bitch yet? #print("loading from song file" + str(self.arrSong)) else: print("creating new song file") f = open(songFile,'a') self.arrSong = ["empty"] #ex.prefs = json.loads('{"mod":0}') #json.dump(ex.prefs, f) f.close() #ls.text_script.insert(END,ls.setlist) #ls.listbox_setlist.clear() self.scene_index = 0 self.song_saved = True self.button_save.configure(bg="green", text="Saved") self.refreshScene() def scene_del(self,*arg): if len(self.arrSong) > 1: self.arrSong.pop(self.scene_index) if self.scene_index > 0: self.scene_index -= 1 self.song_saved = False self.button_save.configure(bg="red",text="Save Me") self.refreshScene() def scene_add(self,*arg): new_scene = "New Scene,New Info" self.arrSong.insert(self.scene_index+1,new_scene) self.scene_index += 1 self.song_saved = False self.button_save.configure(bg="red",text="Save Me") self.refreshScene() def scene_up(self,*arg): if self.scene_index < len(self.arrSong) - 1: self.arrSong.insert(self.scene_index + 1,self.arrSong.pop(self.scene_index)) self.scene_index += 1 self.song_saved = False self.button_save.configure(bg="red",text="Save Me") self.refreshScene() def scene_down(self,*arg): if self.scene_index > 0: self.arrSong.insert(self.scene_index - 1,self.arrSong.pop(self.scene_index)) self.scene_index -= 1 self.song_saved = False self.button_save.configure(bg="red",text="Save Me") self.refreshScene() def nextScene(self,*arg): if not self.is_locked: self.scene_index += 1 if self.scene_index >= len(self.arrSong): print("end of song") if self.song_index + 1 < len(self.setlist): self.song_index += 1 else: self.song_index = 0 self.scene_index = 0 self.current_song_name = self.setlist[self.song_index][0] self.listbox_setlist.select_clear(0,END) self.listbox_setlist.selection_set(self.song_index) self.loadSong() else: self.refreshScene() else: self.locker(False) def reload(self,*arg): #self.locker(False) self.scene_index = 0 self.loadSong() def prevScene(self): if self.scene_index < 1 : self.scene_index = len(self.arrSong) self.scene_index = self.scene_index - 1 self.refreshScene() def quit(self): self.server.close() self.parent.destroy() def locker(self,lock = False, lock_bars = 0): if lock: self.button_next.configure(bg = "red", text="Locked") #print("timer",lock_bars ,self.tempo ,self.signature_numerator,lock_bars * (self.signature_numerator / (self.tempo / 60.0))+ .1) self.lock_timer = Timer(lock_bars * (self.signature_numerator / (self.tempo / 60.0))+ .1, self.locker) self.lock_timer.start() else: self.button_next.configure(bg = "#003366", text="Next") if self.lock_timer != None: self.lock_timer.cancel() #= None print("lock",lock) self.is_locked = lock def refreshScene(self): print("-----------AND SCENE---------------------------") self.arrScene = self.arrSong[self.scene_index].split(",") if self.scene_index < (len(self.arrSong) - 1): nxt = self.arrSong[self.scene_index + 1].split(",") else: nxt = ["END OF SONG","(load next song)"] self.label_count.configure(text=str(self.scene_index +1) + "/" + str(len(self.arrSong))) self.text_script.delete('1.0', END) tag = "even" for line in self.arrScene[2:len(self.arrScene)]: self.text_script.insert(END,line+"\n",tag) tag = "even" if tag == "odd" else "odd" self.entry_title.delete(0, END) self.entry_title.insert(END,self.arrScene[0]) self.entry_desc.delete(0, END) self.entry_desc.insert(END,self.arrScene[1]) self.label_next_title.configure(text=nxt[0]) self.label_next_info.configure(text=nxt[1]) """ for lsCmd in self.arrScene[2:len(self.arrScene)]: lsCmd = re.sub('\[([^\]]+)\]','',re.sub('[\s]+', ' ',lsCmd.lower().strip())) arrCmd = lsCmd.split(" ") #if there is a delay command make sure it's the last element delayCmds = [i for i, s in enumerate(arrCmd) if '+' in s] if delayCmds: barDelay = arrCmd.pop(delayCmds[0]) print( "delay " + str(barDelay) + "bars: " + str(arrCmd)) arrCmd.append(barDelay) try: result = getattr(self, 'ls_'+arrCmd[0])(arrCmd) except Exception, e: print('404! ' + str(e) + "\n" + str(arrCmd)) """ self.text_script.edit_modified(False) if self.song_saved: self.button_save.configure(bg="green", text="Saved") self.sendBox() def sendBox(self): try: txtScene = self.text_script.selection_get() whole_box = False except: # txtScene = "" #if len(txtScene) < 1: txtScene = self.text_script.get("1.0",END) whole_box = True if not self.is_muted or not whole_box: print("processing:",txtScene) else: print("(muted)") wait_time = 0 self.undoables = 0 if self.first_run: self.first_run = False return #dont send the patch at startup else: txtScene = re.sub('\[([^\]]+)\]','',txtScene.lower()) #remove comments and extra breaks, lower case for lsCmd in txtScene.split("\n"): lsCmd = re.sub('[\s]+', ' ',lsCmd.strip()) #remove extra space #lsCmd = re.sub('\[([^\]]+)\]','',re.sub('[\s]+', ' ',lsCmd.lower().strip())) #arrCmd = lsCmd.split(" ") arrCmd = shlex.split(lsCmd) if len(arrCmd) < 2: #print("no valid cmd") continue oscm = None #if there is a delay command only use the first one (they can be nested this way but that's dumb) delayCmds = [[i,s] for i, s in enumerate(arrCmd) if (s[0] == '+')] if delayCmds: print(["delay",delayCmds]) if delayCmds[0][1][-1] == 'b': #if the last character is a b then the number is for beats, not bars delayCmd = ['beats',int(delayCmds[0][1][1:-1])] else: delayCmd = ['bars',int(delayCmds[0][1][1:])] arrCmd.pop(delayCmds[0][0]) #print( "delay " + str(barDelay) + "bars: " + str(arrCmd)) #arrCmd.append(barDelay) try: if arrCmd[0] not in ["fade","playback","lock"]: self.undoables += 1 if not self.is_muted or not whole_box and oscm !='\n': oscm = getattr(self.ls, arrCmd[0])(arrCmd[1:]) if arrCmd[0].lower() == 'wait': wait_time += arrCmd[1] if oscm is not None: if delayCmds and whole_box and not self.is_muted: #oscm.append(barDelay,'k') secPerBeat = 1 / (self.tempo / 60.0) secPerBar = self.signature_numerator * secPerBeat live_time = (time.clock() + self.offset_time ) / (self.signature_numerator / (self.tempo / 60.0)) pctToNextBar = (1 - (live_time - int(live_time))) secToNextBeat = (pctToNextBar * self.signature_numerator - int(pctToNextBar * self.signature_numerator)) * secPerBeat secToNextBar = pctToNextBar * secPerBar #secToNextBar = (self.signature_numerator - (live_time % self.signature_numerator)) * secPerBar / self.signature_numerator if delayCmd[0] == 'beats': secDelay = delayCmd[1] * secPerBeat + secToNextBeat + .01 else: secDelay = delayCmd[1] * secPerBar + secToNextBar + .01 schTime = (time.clock() + self.offset_time + secDelay ) / (self.signature_numerator / (self.tempo / 60.0)) print(str(live_time)[0:5]+ " delay " + str( delayCmd[1]) + delayCmd[0] + str(oscm) + " del=" + str(schTime)[0:5] + " sec=" + str(secDelay)[:5] + " snb=" + str(secToNextBar)[:5]) self.q(oscm,secDelay) #self.arrQueue.append([oscm,time.clock() + secDelay]) #Timer(secDelay, self.send, [oscm]).start() else: if not self.is_muted or not whole_box: self.arrQueue.append([oscm,time.clock() + wait_time]) #self.send( oscm ) except Exception, e: print('cmd err! ' + str(e) + str(arrCmd))
def main(stdcr): stdscr = curses.initscr() stdscr.nodelay(1) activeLight = False activeVideoOn = False activeVideoOff = False lastButtonCar = 1 sentButtonCar = 0 timerButtonCar = 0 connected = False raspberryAddress = '192.168.0.197', 7100 milluminAddress = '192.168.1.21', 5000 milluminAddress2 = '192.168.1.22', 5000 while not connected: try: server = OSCServer(raspberryAddress) server.timeout = 0 # Creamos el objeto "Cliente" client = OSCClient() client2 = OSCClient() # Realizamos la conexion # client.connect( milluminAddress ) # client2.connect( milluminAddress2 ) connected = True except: print("No se encuentra el servidor OSC. Reintentando...") time.sleep(5) # funny python's way to add a method to an instance of a class server.handle_timeout = types.MethodType(handle_timeout, server) server.addMsgHandler("/1/lightPlus", callback_lightOn) server.addMsgHandler("/1/lightMinus", callback_lightOff) server.addMsgHandler("/1/videoOn1", callback_videoOn1) server.addMsgHandler("/1/videoOn1eng", callback_videoOn1eng) server.addMsgHandler("/1/videoOn2", callback_videoOn2) server.addMsgHandler("/1/videoOn2eng", callback_videoOn2eng) server.addMsgHandler("/1/videoOn3", callback_videoOn3) server.addMsgHandler("/1/videoOn4", callback_videoOn4) server.addMsgHandler("/1/videoStop", callback_videoStop) GPIO.setmode(GPIO.BCM) GPIO.setup(17, GPIO.OUT) ## GPIO 17 como salida (bajar luz) GPIO.setup(27, GPIO.OUT) ## GPIO 27 como salida (subir luz) GPIO.setup( 22, GPIO.IN, pull_up_down=GPIO.PUD_UP) ## GPIO 23 como entrada (boton iniciar show) time_stamp = time.time() - 30 # simulate a "game engine" while True: while not connected: try: server = OSCServer(raspberryAddress) server.timeout = 0 # Creamos el objeto "Cliente" client = OSCClient() client2 = OSCClient() # Realizamos la conexion client.connect(milluminAddress) client2.connect(milluminAddress2) connected = True except: # print("No se encuentra el servidor OSC. Reintentando...") stdscr.addstr( "No se encuentra el servidor OSC. Reintentando..." + ' ') stdscr.refresh() # return curser to start position stdscr.move(0, 0) time.sleep(5) try: stdscr.move(0, 0) c = stdscr.getch() if c != -1: # print numeric value stdscr.addstr(str(c) + ' ') stdscr.refresh() # return curser to start position stdscr.move(0, 0) # do the game stuff: if activeLight: GPIO.output(17, False) else: GPIO.output(17, True) # print GPIO.input(22) if (GPIO.input(22) == 0) and (lastButtonCar == 1): timerButtonCar = time.time() lastButtonCar = 0 # print "Inicio Pulso" elif (GPIO.input(22) == 0) and (lastButtonCar == 0) and (not sentButtonCar): delta = time.time() - timerButtonCar if delta > 1.0: msg = OSCMessage() msg.setAddress("/millumin/action/launchorStopColumn") msg.append(9.0) #client.send(msg) # now we dont need to tell the client the address anymore #client2.send(msg) # now we dont need to tell the client the address anymore sentButtonCar = True # print "Lanzando mapping coche" stdscr.addstr("Lanzando mapping coche..." + ' ') stdscr.refresh() # return curser to start position stdscr.move(0, 0) elif (GPIO.input(22) == 1) and (lastButtonCar == 0): timerButtonCar = time.time() lastButtonCar = 1 # print "Fin pulso" elif (GPIO.input(22) == 1) and (lastButtonCar == 1) and (sentButtonCar): if (time.time() - timerButtonCar > 1.0): # print "Reseteando boton de coche" sentButtonCar = False each_frame(server) except KeyboardInterrupt: #client.close() #client2.close() server.close() GPIO.cleanup()
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): return self.coords[hand][Y] < 0 and self.hand_over_piano(hand) def hand_up(self, hand): return self.coords[hand][Y] >= 0 or not self.hand_over_piano(hand) def hand_over_piano(self, hand): return Magnitude(SubVector(self.coords[hand], Y, Z)) > 350 def hand_hit(self, hand): """waits for a hit from the specified hand""" if self.hand_down(hand): wait_for(self.hand_up, (hand, )) wait_for(self.hand_down, (hand, )) return self.coords[hand][X] def joint_moved_x(self, prev_x, joint, hit_location): """used to wait for a change in joint in X dimension""" if self.hand_up(joint): return True if hit_location is not None and abs(hit_location - self.coords[joint][X]) < 140: return False return abs(prev_x - self.coords[joint][X]) > 70 def hand_slide(self, hand, hit_location): x = self.coords[hand][X] wait_for(self.joint_moved_x, (x, hand, hit_location)) if self.hand_up(hand): return False return self.coords[hand][X] def get_coord(self, joint): if joint == 'leftshoulder': return -250, 200, -50 elif joint == 'rightshoulder': return 250, 200, -50 else: return self.coords[joint] def sendToKinect(self, address, items): self._sendMsg(self.kinect_client, address, items) def sendToMax(self, address, items): self._sendMsg(self.max_client, address, items) @staticmethod def _sendMsg(client, address, items): m = OSCMessage() m.setAddress(address) m.append(items) client.send(m)
sys.stdout.write(RED) print '\n waiting for Phone TouchOSC App...\n' sys.stdout.write(RESET) # Create virtual environment ------------------------------------------------------------------------------------------- # first we create the arrow to show current position of the servo measuringArrow = arrow(pos=(0, -10, 0), axis=(0, 10, 0), shaftwidth=0.4, headwidth=0.6) # and now the labels angleLabel = label(text='angle: 90', pos=(0, 5, 0), height=15, box=false) angle0 = label(text='0', pos=(-10, -10, 0), height=15, box=false) angle45 = label(text='45', pos=(-7.5, -2.5, 0), height=15, box=false) angle90 = label(text='90', pos=(0, 1, 0), height=15, box=false) angle135 = label(text='135', pos=(7.5, -2.5, 0), height=15, box=false) angle180 = label(text='180', pos=(10, -10, 0), height=15, box=false) # Main ----------------------------------------------------------------------------------------------------------------- while True: Conrol = get_Conrol() # get path control string from Phone touchOSC server = OSCServer( (serverAdr, serverPort)) # define OSC server on computer client = OSCClient() # define OSC client on Phone touchOSC client.connect((clientAdr, clientPort)) # connect to client server.addMsgHandler( Conrol, servo_call) # use the control path and process message server.handle_request() # handle request rate(20) # refresh rate required for VPython server.close() # close the server, start over again and again.
#print "hello" msg = args[0] print msg outlet.push_sample([str(msg)]) server.addMsgHandler("/OSC-Marker-Stream", user_callback) def quit_callback(path, tags, args, source): # don't do this at home (or it'll quit blender) global run run = False # user script that's called by the game engine every frame def each_frame(): # 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" while run: sleep(0.001) each_frame() server.close()
class StretchIO(object): def __init__(self, send, listen=("0.0.0.0", 12340)): self.server = OSCServer(listen) self.server.timeout = 0.0 self.server.timed_out = False def timeout(self): self.timed_out = True self.server.handle_timeout = types.MethodType(timeout, self.server) self.client = OSCClient() self.client.connect(send) self.__fader_state = [8, 8, 8, 8] self.__fader_cb = None self.__toggle_cb = None for i in range(1, 5): self.led(i, 0.) self.toggle(i, 0.) self.fader(i, self.__fader_state[i - 1]) self.server.addMsgHandler('/1/toggle' + str(i), self.osc_handler) self.server.addMsgHandler('/1/fader' + str(i), self.osc_handler) def step(self): self.server.timed_out = False while not self.server.timed_out: self.server.handle_request() def send(self, m): try: self.client.send(m) except OSCClientError: sys.stdout.write('Send Fail: {0} \r'.format(m)) sys.stdout.flush() def close(self): self.server.close() def set_toggle_handler(self, cb): """ Register the function to be called when we press the toggle. <cb> should be a functio with the signature cb(button_number, button_state) """ self.__toggle_cb = cb def set_fader_handler(self, cb): self.__fader_cb = cb def osc_handler(self, path, tags, args, source): paths = path.split('/') # paths looks like this for 'auto' touchOSC elements ['', '1', 'toggle1'] if len(paths) < 3: return match = re.match('([a-zA-Z]+)(\d+)', paths[2]) if not match: print 'osc path match failed' return if len(args) < 1: print 'handler has no arguments' return parts = match.groups() name = parts[0] num = int(parts[1]) state = args[0] if name == 'fader': self.__fader_state[num - 1] = state if name == 'toggle' and self.__toggle_cb is not None: self.__toggle_cb(num, state) elif name == 'fader' and self.__fader_cb is not None: self.__fader_cb(num, state) def led(self, led_num, value): m = OSCMessage('/1/led{0:d}'.format(led_num)) m.append(value) if value > 1.0: value = 1.0 if value < 0.0: value = 0.0 self.send(m) def toggle(self, toggle_num, value): m = OSCMessage('/1/toggle{0:d}'.format(toggle_num)) m.append(1 if value else 0) self.send(m) def fader(self, fader_num, value): m = OSCMessage('/1/fader{0:d}'.format(fader_num)) m.append(float(value)) self.send(m) def fader_state(self, i): """ <i> is the index from zero (unlike the setters, that index from 1) """ return self.__fader_state[i]
print "with addr : %s" % addr print "typetags %s" % tags print "data %s" % stuff print "---" # Hookup handlers server.addMsgHandler("/1/elbow", elbow) server.addMsgHandler("/1/head", head) server.addMsgHandler("/1/btn", btn) # Main print "\nRegistered Callback Functions:" for addr in server.getOSCAddressSpace(): print addr print "\nStarting OSCServer. Use Ctrl-C to quit." st = threading.Thread( target = server.serve_forever ) st.start() try: while 1: #print "Waiting..." sleep(5) except KeyboardInterrupt: print "\nClosing OSCServer." server.close() print "Waiting for Server thread to finish." st.join() print "Done!"
# 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()