def main(): global server connected = False while not connected: try: server = OSCServer( ("10.101.203.74", 10000) ) server.timeout = 0 run = True connected = True except: print "OSC Server no encontrado" time.sleep(5) GPIO.setmode(GPIO.BCM) m = Motor([17,18,27,22]) server.handle_timeout = types.MethodType(handle_timeout, server) server.addMsgHandler( "/base", base_move ) server.addMsgHandler( "/altura", altura_move ) while(True): each_frame() try: m.rpm = 10 m.move_to(rotateBase) # m.move_to(0) except KeyboardInterrupt: GPIO.cleanup() print "Saliendo..." exit()
def __init__(self): global run threading.Thread.__init__(self) self.daemon = True self.server = OSCServer(("localhost", 15000)) self.server.timeout = 0 def handle_timeout(self): self.time_out = True self.server.handle_timeout = types.MethodType(handle_timeout, self.server) def user_callback(path, tags, args, source): global RGB global BRIGHTNESS #print "here" RGB[0] = args[0] RGB[1] = args[1] RGB[2] = args[2] BRIGHTNESS = args[3] def quit_callback(path, tags, args, source): global run run = False self.server.addMsgHandler("/colors", user_callback) self.server.addMsgHandler("/quit", quit_callback)
def __init__(self, joints=None, max_port=5555): if joints is None: self.joints = [ 'righthand', 'lefthand', 'rightfoot', 'leftfoot', 'head', 'torso' ] else: self.joints = joints self.coords = {k: (0., 0., 0.) for k in self.joints} self.prev_coords = {k: (0., 0., 0.) for k in self.joints} self.joint_speed = {k: False for k in self.joints} self.speed_piano = { 'lefthand': { X: 0, Y: 0 }, 'righthand': { X: 0, Y: 0 } } self.kinect_client = OSCClient() self.max_client = OSCClient() self.server = OSCServer(('127.0.0.1', 12345)) self.kinect_client.connect(('127.0.0.1', 12346)) self.max_client.connect(('127.0.0.1', max_port)) self.server.addMsgHandler('default', self.process_message) self.flipped = False self.speed = 0. self.speed_ramp = 0. sprout(self.server.serve_forever) sprout(self._remind_synapse)
def __init__(self, port=DEFAULT_MUSEIO_PORT, signal=None, ip=DEFAULT_MUSEIO_IP): self.signal = signal self.port = port self.udp_ip = ip if not has_oscserver: raise Exception('ERROR: OSC not found') self.server = OSCServer((self.udp_ip, self.port)) self.server.timeout = 0 self.current_sample_id = 0 # funny python's way to add a method to an instance of a class self.server.handle_timeout = types.MethodType(handle_timeout, self.server) # add message handlers if 'eeg' in self.signal: self.server.addMsgHandler('/muse/eeg', self.callback_eeg_raw) if 'concentration' in self.signal: self.server.addMsgHandler('/muse/elements/beta_relative/', self.callback_concentration)
def invoke(self, context, event): if context.object: SERVER_ADDR = 7113 self.server = OSCServer(("localhost", SERVER_ADDR)) self.server.timeout = 0.0001 self.server.addMsgHandler("/leap/frame/timestamp", self.log_timestamp) self.server.addMsgHandler("/leap/frame/hand/pos", self.move_object) self.server.addMsgHandler("/leap/frame/hand/orientation", self.log_timestamp) self.server.addMsgHandler("/quit", self.quit_callback) self.first_mouse_x = event.mouse_x self.first_value = context.object.location context.window_manager.modal_handler_add(self) self._timer = context.window_manager.event_timer_add( 0.001, context.window) self.obj = context.object return {'RUNNING_MODAL'} else: self.report({'WARNING'}, "No active object, could not finish") return {'CANCELLED'}
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 setup(): print "setup" global currentButtonState, lastDownTime, isRecording, audioInput global messageQ, clientMap, oscIn, oscOut, oscThread, mAudioServer messageQ = PriorityQueue() clientMap = {} ## setup osc client oscOut = OSCClient() ## setup osc receiver oscIn = OSCServer((OSC_IN_ADDRESS, OSC_IN_PORT)) oscIn.addMsgHandler('default', _oscHandler) oscThread = Thread(target=oscIn.serve_forever) oscThread.start() print "osc in ready" ## setup audio server #mAudioServer = ThreadedServer() #mAudioServer.start() ## setup gpio GPIO.setmode(GPIO.BCM) GPIO.setup(SWITCH_PIN, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(LED_PIN, GPIO.OUT) GPIO.output(LED_PIN, GPIO.LOW) currentButtonState = GPIO.input(SWITCH_PIN) lastDownTime = 0 isRecording = False _setupAudio()
def __init__(self): self.radio = radio.radio([0xa7, 0xa7, 0xa7, 0xa7, 0xaa]) self.swarm = [ #robot.robot([0xa7, 0xa7, 0xa7, 0xa7, 0x01]), #robot.robot([0xa7, 0xa7, 0xa7, 0xa7, 0x02]), #robot.robot([0xa7, 0xa7, 0xa7, 0xa7, 0x03]), #robot.robot([0xa7, 0xa7, 0xa7, 0xa7, 0x04]), #robot.robot([0xa7, 0xa7, 0xa7, 0xa7, 0x05]), #robot.robot([0xa7, 0xa7, 0xa7, 0xa7, 0x06]), #robot.robot([0xa7, 0xa7, 0xa7, 0xa7, 0x07]), #robot.robot([0xa7, 0xa7, 0xa7, 0xa7, 0x08]), robot.robot([0xa7, 0xa7, 0xa7, 0xa7, 0x09]) ] self.bpm = 150 self.beat = 0 self.beats_per_cycle = 1 self.ms_per_beat = self.bpm_to_mspb(self.bpm) self.last_sync = time.time() self.weft_swarm = [0, 1, 2, 3] self.warp_swarm = [4, 5, 6, 7] self.state = "weft-walking" self.compiler = yarn.compiler() self.osc_server = OSCServer(("0.0.0.0", 8000)) self.osc_server.timeout = 0 self.osc_server.addMsgHandler("/sync", sync_callback) self.sync_pos = 0 # load code here self.swarm[0].load_asm("../asm/led_flash.asm", self.compiler, self.radio)
def __init__(self, port=5001, signal=None): self.signal = signal self.port = port self.udp_ip = '127.0.0.1' if not has_oscserver: raise Exception('ERROR: OSC not found') self.server = OSCServer((self.udp_ip, self.port)) self.server.timeout = 0 self.current_sample_id = 0 self.init_time = None self.sample_rate = 220.0 # funny python's way to add a method to an instance of a class self.server.handle_timeout = types.MethodType(handle_timeout, self.server) # add message handlers if 'eeg' in self.signal: self.server.addMsgHandler('/muse/eeg', self.callback_eeg_raw) if 'concentration' in self.signal: self.server.addMsgHandler('/muse/elements/experimental/concentration', self.callback_concentration) if 'mellow' in self.signal: self.server.addMsgHandler('/muse/elements/experimental/mellow', self.callback_mellow) self.server.addMsgHandler("default", self.default_handler)
def __init__(self, address, state): self.state = state self.server = OSCServer(("", 0)) self.server.addMsgHandler("default", self.msg_handler) self.client = OSCClient(server = self.server) self.client.connect((address, self.XAIR_PORT)) thread.start_new_thread(self.run_server, ())
def __init__(self, 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 initOSCServer(ip='127.0.0.1', port=9000, mode=0): """ mode 0 for basic server, 1 for threading server, 2 for forking server """ global server, st if mode == 0: server = OSCServer((ip, port)) # basic elif mode == 1: server = ThreadingOSCServer((ip, port)) # threading elif mode == 2: server = ForkingOSCServer((ip, port)) # forking
def server_start(port=7110): global server server = OSCServer(("localhost", 7110)) server.timeout = 0 server.handle_timeout = types.MethodType(handle_timeout, server) server.addMsgHandler("/sco", handle_score) server.addMsgHandler("/cc", handle_cc) server.addMsgHandler("/quit", quit_callback) server.addMsgHandler("default", default_callback)
def _get_osc_test_server(self, port=None): def intercepting_handler(addr, tags, data, source): msg_string = "%s [%s] %s" % (addr, tags, str(data)) sys.stdout.write("OSCServer Got: '%s' from %s\n" % (msg_string, getUrlStr(source))) self.testQueue.put(data) port = port or self.remote_osc_address[1] s = OSCServer(('localhost', port)) s.addMsgHandler('default', intercepting_handler) return s
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 initOSCServer(ip='localhost', port=8080, mode=0): """ mode 0 for basic server, 1 for threading server, 2 for forking server """ global server, st if mode == 0: server = OSCServer((ip, port)) # basic elif mode == 1: server = ThreadingOSCServer((ip, port)) # threading elif mode == 2: server = ForkingOSCServer((ip, port)) # forking server.addDefaultHandlers()
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 __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 __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 frame(savePath): print 'getting osc' # funny python's way to add a method to an instance of a class server = OSCServer(("192.168.1.209", 12000)) server.timeout = 0 run = True server.handle_timeout = types.MethodType(handle_timeout, server) server.addMsgHandler("/acc", acc_callback) server.addMsgHandler("/e", eul_callback) server.addMsgHandler("/raw", raw_callback) while True: each_frame(server) #print 'hello' sleep(0.001) return
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 __init__(self, from_ip, from_port, to_ip, to_port): super(OSCForwarder, self).__init__() # create the server to listen to messages arriving at from_ip self.server = OSCServer( (from_ip, from_port) ) self.server.addMsgHandler( 'default', self.callback ) # create the clieent to forward those message to to_ip self.client = OSCClient() self.client.connect( (to_ip, to_port) ) print '%s:%d --> %s:%d' % (from_ip, from_port, to_ip, to_port) self.done_running = False # start the server listening for messages self.start()
def __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 __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()
def setup(): global lastTwitterCheck, myTwitterStream, streamThread global lastSmsCheck, mySmsClient, newestSmsSeconds global myOscSubscribers, myOscServer, oscThread, myOscClient global logFile secrets = {} myOscSubscribers = {} lastTwitterCheck = time() lastSmsCheck = time() newestSmsSeconds = timegm(gmtime()) ## read secrets from file inFile = open('oauth.txt', 'r') for line in inFile: (k, v) = line.split() secrets[k] = v ## start Twitter stream reader myTwitterStream = TwitterStreamReceiver( app_key=secrets['CONSUMER_KEY'], app_secret=secrets['CONSUMER_SECRET'], oauth_token=secrets['ACCESS_TOKEN'], oauth_token_secret=secrets['ACCESS_SECRET']) streamThread = Thread(target=myTwitterStream.statuses.filter, kwargs={'track': ','.join(SEARCH_TERMS)}) streamThread.start() ## start Twilio client mySmsClient = TwilioRestClient(account=secrets['ACCOUNT_SID'], token=secrets['AUTH_TOKEN']) myOscClient = OSCClient() myOscServer = OSCServer(('127.0.0.1', 8888)) myOscServer.addMsgHandler('/NotTooPublic/call', oscSubscribeHandler) myOscServer.addMsgHandler('default', lambda addr, tags, args, source: None) oscThread = Thread(target=myOscServer.serve_forever) oscThread.start() ## open new file for writing log logFile = open("data/" + strftime("%Y%m%d-%H%M%S", localtime()) + ".log", "a")
def __init__(self): self.server = OSCServer(("192.168.2.122", 5005)) self.server.timeout = 0 self.driver = DriverAdaMatrix(rows=32, chain=2) self.driver.SetPWMBits(6) self.led = LEDMatrix(self.driver, 64, 32, serpentine=False) self.modes = [ self.mode_presets, self.color_presets, self.color_gradient, self.white_gradient, self.direct_control, self.arcade, self.mindfuck ] self.color = colors.Salmon self.wheel = ColorWheel() self.running = True self.joysticks = [0] * 5 self.pong = Pong(self.led) self.scope = Scope(self.led, self.wheel) self.scheme = [] # funny python's way to add a method to an instance of a class # import types # self.server.handle_timeout = types.MethodType(lambda: self.handle_timeout(self), self.server) self.server.addMsgHandler("/mode", self.mode_callback) self.server.addMsgHandler("/coin", self.coin_callback) self.server.addMsgHandler("/js", self.joystick_callback) self.server.addMsgHandler("/pot", self.pot_callback) self.server.addMsgHandler("/fad", self.fader_callback) self.server.addMsgHandler("/beam", self.beam_callback) self.server.addMsgHandler("/scheme", self.scheme_callback) self.server.addMsgHandler("/sleep", self.sleep_callback)
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)
def __init__(self): self.radio = radio.radio([0xa7, 0xa7, 0xa7, 0xa7, 0xaa]) self.swarm = [ #robot.robot([0xa7, 0xa7, 0xa7, 0xa7, 0x01]), robot.robot([0xa7, 0xa7, 0xa7, 0xa7, 0x02]), robot.robot([0xa7, 0xa7, 0xa7, 0xa7, 0x03]), robot.robot([0xa7, 0xa7, 0xa7, 0xa7, 0x04]), robot.robot([0xa7, 0xa7, 0xa7, 0xa7, 0x05]), #robot.robot([0xa7, 0xa7, 0xa7, 0xa7, 0x06]), #robot.robot([0xa7, 0xa7, 0xa7, 0xa7, 0x07]), #robot.robot([0xa7, 0xa7, 0xa7, 0xa7, 0x08]) ] self.bpm = 150 self.beat = 0 self.beats_per_cycle = 1 self.ms_per_beat = self.bpm_to_mspb(self.bpm) self.last_sync = time.time() self.last = "" self.compiler = yarn.compiler() self.osc_server = OSCServer(("0.0.0.0", 8000)) self.osc_server.timeout = 0 self.osc_server.addMsgHandler("/sync", sync_callback) self.sync_pos = 0 self.ms_per_step = (frequency * len(i2c_addrs)) * 1000 self.ms_per_step /= 8 print(self.ms_per_step) # load code here #for r in self.swarm: # r.load_asm("../asm/pm.asm",self.compiler,self.radio) # r.write(13,self.ms_per_step,self.radio) self.grid = tangible.sensor_grid(16, layout, tokens) self.last = "" self.next_address = 0 self.seq = 0
def __init__(self): self.server = OSCServer (("0.0.0.0", 8000)) self.server.addMsgHandler("/1/rollpitch", self.roll_pitch_callback) self.server.addMsgHandler("/1/yawthrust", self.yaw_thrust_callback) self.server.addMsgHandler("/1/stop", self.stop_callback) self.server.addMsgHandler("/1/hovermode", self.hovermode_callback) self.crazyflie = Crazyflie() cflib.crtp.init_drivers() available_radios = cflib.crtp.scan_interfaces() print available_radios #For now assume we want the 1st radio radio = available_radios[0][0] #Connect to the flie self.crazyflie.open_link(radio) self.crazyflie.connectSetupFinished.add_callback(self.connectSetupFinished) self.crazyflie.connectionFailed.add_callback(self.connectionLost) self.crazyflie.connectionLost.add_callback(self.connectionLost)