def main(): global bRun global inOSCport, outOSCport global myOSC_Server, myOSC_Client global cTrial, nTrials, breaksxTrial cTrial = 1 global debug_data global CS_US_1 CS_US_1['inputs']=[] cerebellumConfig['weights']=[] cerebellumConfig['config']=[] cerebellumConfig['constants']=[] debug_data['trials']=[] if save_bases: debug_data['basis']=[] debug_data['inputs']=[] inOSCport = 1234 outOSCport = 1235 # myOSC_Server = OSCServer( ('' , inOSCport) ) # myOSC_Client = OSCClient() # myOSC_Client.connect( ('10.0.0.116' , outOSCport) ) myOSC_Server = OSCServer( ('127.0.0.1' , inOSCport) ) myOSC_Client = OSCClient() myOSC_Client.connect( ('127.0.0.1' , outOSCport) ) print "Receiving messages /trial,/input in port", inOSCport print "Sending messages to port", outOSCport myOSC_Server.addMsgHandler("/config", receiveConfig) myOSC_Server.addMsgHandler("/trial", receiveTrial) myOSC_Server.addMsgHandler("/endtrial", receiveEndTrial) myOSC_Server.addMsgHandler("/input", receiveInput) myOSC_Server.addMsgHandler("/debug", receiveDebug) myOSC_Server.addMsgHandler("/update", receiveUpdate) myOSC_Server.addMsgHandler("/freeze", receiveFreeze) myOSC_Server.addMsgHandler("/saveConfig", receiveSaveConf) # if (cTrial==nTrials): # pl.figure(figsize=(10,6)) # plot(breaksxTrial) print "Ready" myOSC_Server.serve_forever()
class OSC_MPD(object): def __init__(self, osc=('0.0.0.0', 8000), mpd=('127.0.0.1', 6600)): self.mpc = MPDClient() self.mpc.connect(mpd[0], mpd[1]) self.server = OSCServer(osc) def musicManage(addr, tags, data, client_address): cmd = addr.strip('/').split('/')[-1] self.mpc.__getattr__(cmd)(*data) self.server.addMsgHandler('/bearstech/music/play', musicManage) self.server.addMsgHandler('/bearstech/music/pause', musicManage) self.server.addMsgHandler('/bearstech/music/next', musicManage) self.server.addMsgHandler('/bearstech/music/previous', musicManage) self.server.addMsgHandler('/bearstech/music/stop', musicManage) def serve_forever(self): self.server.serve_forever()
class OSCForwarder(threading.Thread): def __init__(self, from_ip, from_port, to_ip, to_port): super(OSCForwarder, self).__init__() # create the server to listen to messages arriving at from_ip self.server = OSCServer( (from_ip, from_port) ) self.server.addMsgHandler( 'default', self.callback ) # create the clieent to forward those message to to_ip self.client = OSCClient() self.client.connect( (to_ip, to_port) ) print '%s:%d --> %s:%d' % (from_ip, from_port, to_ip, to_port) self.done_running = False # start the server listening for messages self.start() # close must be called before app termination or the app might hang def close(self): # this is a workaround of a bug in the OSC server # we have to stop the thread first, make sure it is done, # and only then call server.close() self.server.running = False while not self.done_running: time.sleep(.01) self.server.close() def run(self): #print "Worker thread entry point" self.server.serve_forever() self.done_running = True def callback(self, path, tags, args, source): #print 'got:', path, args, 'from:', source self.client.send( OSCMessage(path, args ) )
from OSC import OSCServer import sys from time import sleep server = OSCServer( ("localhost", 7110) ) server.timeout = 0 run = True def user_callback(path, tags, args, source): # which user will be determined by path: # we just throw away all slashes and join together what's left user = ''.join(path.split("/")) # tags will contain 'fff' # args is a OSCMessage with data # source is where the message came from (in case you need to reply) print user, args, source for i in range(2): for c in range(1,5): server.addMsgHandler( "/EEG_%d/channel_%d/notch_50/lpf_75"%(i,c), user_callback ) server.addMsgHandler( "/markers" , user_callback ) server.serve_forever()
from OSC import OSCServer """Called whenever we get a trigger message from an interface box""" def got_trigger(path, tags, args, source): board = path.split("/")[3] pad = path.split("/")[4] status_string = "board %s pad %s" % (board, pad) if args[0] == 1: status_string = "Touch " + status_string else: status_string = "Release " + status_string print(status_string) Popen(['say', "%s %s" % (board, pad)]) listen_port = 12346 print("Attempting to listen on port %d" % listen_port) listener = OSCServer(("0.0.0.0", 12346)) for i in range(20): for j in range(24): listener.addMsgHandler("/tactus/trigger/%d/%d" % (i, j), got_trigger) print("Listening...") listener.serve_forever() print("Exiting")
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)
class SSI_interface_Receiver: def __init__(self, board_id, measure): try: self.ports_config = json.loads(open("ssi_ports.json").read()) print "ports config loaded" except: print "couldn't load ports file" self.measure = measure self.port = self.ports_config[board_id][self.measure] self.myOSC_Server = OSCServer(("", self.port)) self.myOSC_Server.addMsgHandler("/strm", self.receiveStream) self.myOSC_Server.addMsgHandler("/evnt", self.receiveEvent) self.myOSC_Server.addMsgHandler("/text", self.receiveText) self.datapack = { "receive_ecg": 0, "receive_ecg-hr": 0, "receive_ecg-rspike": 0, "receive_ecg-pulse": 0, "receive_ecg-tdf": 0, "receive_ecg-sdf": 0, "receive_gsr": 0, "receive_gsr_pre": 0, "receive_gsr_arousal": 0, "receive_gsr_peak": 0, "receive_gsr_slope": 0, "receive_gsr_drop": 0, "air": 0, "air_pre": 0, "air_pulse": 0, "air_exhale": 0 } self.osc_thread = th.Thread(target=self.main) self.osc_thread.start() def receiveStream(self, addr, tags, data, source): data[7] = self.readBlob(data[7]) self.datapack[self.measure] = data def receiveEvent(self, addr, tags, data, source): data[7] = self.readBlob(data[7]) self.datapack[self.measure] = data def receiveText(self, addr, tags, data, source): data[7] = self.readBlob(data[7]) self.datapack[self.measure] = data def readBlob(self, binary): decoded = [] for i in range(len(binary)): if i % 4 == 0 and i != 0: decoded.append(struct.unpack('f', binary[i - 4:i])[0]) return decoded def main(self): print "osc is listening" self.myOSC_Server.serve_forever()
# 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 SSI_interface_Receiver: def __init__(self, board_id, measure): try: self.ports_config = json.loads(open("ssi_ports.json").read()) print "ports config loaded" except: print "couldn't load ports file" self.measure = measure self.port= self.ports_config[board_id][self.measure] self.myOSC_Server = OSCServer( ("" , self.port )) self.myOSC_Server.addMsgHandler("/strm", self.receiveStream) self.myOSC_Server.addMsgHandler("/evnt", self.receiveEvent) self.myOSC_Server.addMsgHandler("/text", self.receiveText) self.datapack = { "receive_ecg":0, "receive_ecg-hr":0, "receive_ecg-rspike":0, "receive_ecg-pulse":0, "receive_ecg-tdf":0, "receive_ecg-sdf":0, "receive_gsr":0, "receive_gsr_pre":0, "receive_gsr_arousal":0, "receive_gsr_peak":0, "receive_gsr_slope":0, "receive_gsr_drop":0, "air":0, "air_pre":0, "air_pulse":0, "air_exhale":0 } self.osc_thread = th.Thread(target=self.main) self.osc_thread.start() def receiveStream(self, addr, tags, data, source): data[7] = self.readBlob(data[7]) self.datapack[self.measure] = data def receiveEvent(self, addr, tags, data, source): data[7] = self.readBlob(data[7]) self.datapack[self.measure] = data def receiveText(self, addr, tags, data, source): data[7] = self.readBlob(data[7]) self.datapack[self.measure] = data def readBlob(self, binary): decoded = [] for i in range(len(binary)): if i%4 == 0 and i != 0: decoded.append(struct.unpack('f', binary[i-4:i])[0]) return decoded def main(self): print "osc is listening" self.myOSC_Server.serve_forever()
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