def make_oscserver(self): def heartbeat(path, args): self.heartbeat() def status_handler(path, args): status = args[0] self.set_status(status) def quit_handler(path, args): self.quit(quitcore=False) def reply_handler(path, args): method, ID = args[0], args[1] callback = self._reply_callbacks[ID] if callback: try: out = args[2:] if len(out) == 1: callback(out[0]) else: callback(out) except: print "Error in reply callback. ID=%s" % str( ID), sys.exc_info(), args return def calibrate_handler(path, args, types, src, self): self.queue.put(After(self.win, 150, self.statusbar_update)) def notify_reset_handler(path, args, types, src, self): self.queue.put(After(self.win, 0, self._flash_reset_button)) if self.guiport is None: s = liblo.ServerThread() self.guiport = s.port else: while True: try: s = liblo.ServerThread(self.guiport) break except liblo.ServerError: print "Could not create a Server at port %d. Trying with port %d" % ( self.guiport, self.guiport + 1) self.guiport += 1 print "gui: using port %d" % self.guiport s.add_method('/heartbeat', None, heartbeat) s.add_method('/status', 's', status_handler) s.add_method('/reply', None, reply_handler) s.add_method('/quit', None, quit_handler) s.add_method('/notify/calibrate', None, calibrate_handler, self) s.add_method('/notify/reset', None, notify_reset_handler, self) s.send(self.coreaddr, '/registerui') return s
def on_start(self): if self.port is not None: self.server = _liblo.ServerThread(self.port) self.server.register_methods(self) self.server.start() self.send_config()
def new_input(self, protocol="OSC", **kwargs): """ Create a new input for this device args: Mandatory argument is the protocol you want to use for this output (OSC, MIDI, serial, ArtNet) rtype: input object """ if not self._inputs: self._inputs = [] taille = len(self._inputs) if protocol == "OSC": the_input = 'OSC' self.osc_server = liblo.ServerThread(1235) for param in self.getparameters(): self.osc_server.add_method(param.address, 'i', param.listen) self.osc_server.start() elif protocol == "MIDI": the_input = InputMIDI() else: the_input = None if the_input: set_attributes(the_input, kwargs) self._inputs.append(the_input) return self._inputs[taille] else: return False
def __init__(self, config, converter): """Setup OSC and MQTT servers. @param config: configuration directory @param converter: Osc2MqttConverter instance """ self.converter = converter self.config = config self.mqtt_host, self.mqtt_port = parse_hostport( config.get("mqtt_broker", "localhost"), 1883) self.osc_port = int(config.get("osc_port", 9001)) self.osc_receiver = config.get("osc_receiver") self.subscriptions = config.get("subscriptions", ['#']) if self.osc_receiver: host, port = parse_hostport(self.osc_receiver, 9000) self.osc_receiver = liblo.Address(host, port, liblo.UDP) self.mqttclient = mqtt.Client(config.get("client_id", "osc2mqtt")) self.mqttclient.on_connect = self.mqtt_connect self.mqttclient.on_disconnect = self.mqtt_disconnect self.mqttclient.on_message = self.handle_mqtt self.oscserver = liblo.ServerThread(self.osc_port) self.oscserver.add_method(None, None, self.handle_osc)
def initNetwork(self): def onPlay(path, args): self.timer.start(args[0]) def onPause(path, args): self.timer.pause(args[0]) def onStop(path, args): self.timer.stop(args[0]) def onSeek(path, args): self.timer.seek(args[0], args[1]) self.server = liblo.ServerThread(self.network.port, group="224.0.0.1") self.server.add_method("/play", "t", onPlay) self.server.add_method("/pause", "t", onPause) self.server.add_method("/stop", "t", onStop) self.server.add_method("/seek", "tt", onSeek) #self.server.add_method(None, None, self.onMessageReceived) self.server.start() self._broadcast = liblo.Address("224.0.0.1", self.network.port, liblo.UDP) self._broadcast.ttl = 1 def onTimeout(): value = self.timer._clock.time liblo.send(self._broadcast, "/time", ('t', value)) self._heartbeat = QtCore.QTimer() self._heartbeat.timeout.connect(onTimeout)
def get_proc_status(port): """ Returns False, 'running' or 'unresponsive' """ try: s = liblo.Server(port) return 'notrunning' except liblo.ServerError: pass # the OSC port is used, so see if we receive pingbacks s = liblo.ServerThread() def handler(*args): ready.append('done') s.add_method("/pingback", None, handler) t0 = time.time() ready = [] s.start() s.send(PDPORT, '/ping', s.port) while True: if time.time() - t0 > 1: timedout = True break if ready: timedout = False break time.sleep(0.1) if timedout: return 'unresponsive' else: return 'running'
def __init__(self, port): self._port = port try: self._server = liblo.ServerThread(port) except liblo.ServerError, err: print unicode(err) sys.exit(1)
def setupInputServer(self, context, envars): if load_liblo_success == True: self.st = liblo.ServerThread(envars.port_in) print("Created Server Thread on Port", self.st.port) else: raise Exception( "Unable to create Server: Missing liblo library. Try installing liblo with homebrew: 'brew install liblo'" )
def __init__(self, device_port=5000): self.device_receiver = liblo.ServerThread(device_port) self.device_receiver.add_method("/monome/grid/key", "iii", self.on_grid_key) self.device_receiver.add_method("/serialosc/device", "ssi", self.on_serialosc_device) self.device_receiver.start() liblo.send(liblo.Address(12002), "/serialosc/list", "127.0.0.1", device_port)
def __init__(self, faders_callback, buttons_callback, encoder_button_callback, encoder_callback, pot_callback, sensei_ctrl_port=SENSEI_TO_BRIDGE_PORT, sensei_led_port=BRIDGE_TO_SENSEI_PORT): """ Initialization. Inputs: faders_callback : function with args (fader_idx, val) Will be invoked when an analog fader is moved. Callback arguments: fader_idx : int (0 = A, 1 = B, 2 = C, 3 = D) val : fader value from 0.0 to 1.0 buttons_callback : function with args (button_idx, val) It will be invoked whenever a button is pressed or released. Callback arguments: button_idx : index of the button (0..8) val : button status (1=pressed, 0=released) encoder_button_callback : callback to invoke when rotary encoder button is pressed Callback arguments: val : button status (1=pressed, 0=released) encoder_callback : function with a single argument (direction) Will be invoked when the encoder is rotated. Callback arguments: direction : +1 if turned right, -1 if turned left sensei_ctrl_port : UDP port for incoming OSC messages from Sensei sensei_led_port : UDP port to output LED changes to Sensei """ self._osc_server = liblo.ServerThread(sensei_ctrl_port) self._sensei_address = ('localhost', sensei_led_port) self._btn_cback = buttons_callback self._enc_btn_cback = encoder_button_callback self._enc_cback = encoder_callback self._faders_cback = faders_callback self._pot_cback = pot_callback self._register_osc_callbacks() self.reset_display() self._display_dev = get_display_device(DISPLAY_CONFIG) self._display_dirty = False self.set_rot_enc_initial_val()
def __init__(self, app, coreaddr=None, port=None, exclude=None): self.app = app self._quitting = False self.exclude = exclude self.coreaddr = coreaddr if coreaddr is not None else ('localhost', 47120) try: if port is None: self.server = liblo.ServerThread() else: self.server = liblo.ServerThread(port) self.ok = ok = True except: self.server = None self.ok = ok = False return self.started = False self.server.add_method('/quit', None, self.quit_handler) self.server.add_method('/ping', None, self.ping_handler) self.server.add_method(None, None, self.default_handler) self.port = self.server.port self.server.send(self.coreaddr, '/registerdata')
class OscServer(Widget): port = NumericProperty() port = "9999" server = _liblo.ServerThread(port) def on_start(self): self.server.register_methods(self) self.server.start() print "[OSC] listening on udp port: " + str(self.port) def on_exit(self): self.server.stop() del self.server
def __init__(self, port) -> None: success = False for t in range(5) : try : self.port = port + random.randint(1, 10000) self.url = 'osc.udp://localhost:' + str(self.port) self.server = liblo.ServerThread(self.port, liblo.UDP) success = True except liblo.ServerError : pass if not success : exit(-1)
def main(): options = docopt(__doc__, version=__version__) logging.basicConfig( level=logging.DEBUG if options.get('--verbose') else logging.INFO, format="%(message)s") log.debug("Options from cmdline are {}".format(options)) backend = get_mido_backend() if options.get('list'): if options.get('backends'): list_backends() elif options.get('ports'): list_ports(backend) else: try: server = None midi_in, midi_out = configure_ioports( backend, virtual=not (options.get('--midi-in') or options.get('--midi-out')), mido_in=options.get('--midi-in'), mido_out=options.get('--midi-out')) psa = Advertisement(ip=options.get('--ip')) psa.register() target_address = wait_for_target_address(psa.ip) log.debug("Listening for touchOSC on {}:{}.".format(psa.ip, PORT)) server = liblo.ServerThread(PORT) osc_handler = OscHandler(midi_out) server.add_method('/midi', 'm', osc_handler.on_osc) server.add_method('/sysex', 's', osc_handler.on_osc) target = liblo.Address(target_address, PORT + 1, liblo.UDP) log.info("Will send to {}.".format(target.get_url())) midi_handler = MidiHandler(target) midi_in.callback = midi_handler.on_midi log.info("Listening for midi at {}.".format(midi_in)) server.start() while True: time.sleep(.0001) except KeyboardInterrupt: psa.unregister() psa.close() if server: server.stop() server.free() midi_in.close() log.info("closed all ports")
def __init__(self, port): super().__init__() self.channel = '1' try: with open('/root/id') as f: self.channel = f.read().strip() except: pass self.server = liblo.ServerThread(port) self.server.add_method(None, None, self.handler) self.server.start() print("OSC listening on", port)
def startListening(): global server try: server = liblo.ServerThread(listenPort) print(" listening to incoming OSC on port %i" % listenPort) except liblo.ServerError as e: print(e) raise SystemError server.add_method("/generateText", None, markov.OSCgenerateText) server.add_method("/setCorpuses", None, markov.OSCsetCorpuses) server.add_method("/accelerometer", None, averageAcc) server.add_method(None, None, unknownOSC) server.start()
def osc_init(self, proto=liblo.UDP): self.start_loading() try: self.osc_target=liblo.Address('localhost',self.osc_target_port,proto) logging.info("OSC target in port %s" % str(self.osc_target_port)) self.osc_server=liblo.ServerThread(None,proto) self.osc_server_port=self.osc_server.get_port() self.osc_server_url=liblo.Address('localhost',self.osc_server_port,proto).get_url() logging.info("OSC server running in port %s" % str(self.osc_server_port)) self.osc_add_methods() self.osc_server.start() except liblo.AddressError as err: logging.error("OSC Server can't be initialized (%s). Running without OSC feedback." % err) self.stop_loading()
def __init__(self, port=9950, sl_port=9951, verbose=False): self.port = port self.sl_port = sl_port self.verbose = verbose self.server = liblo.ServerThread( self.port) #Define liblo server for replies self.ping_flag = Event() self.loop_count = 0 self.loops = [] self.loop_callbacks = [] self.looper_callbacks = [] self.ping_callbacks = []
def initNetwork(self): def onPlay(path, args): self.timer.start(args[0]) def onPause(path, args): self.timer.pause(args[0]) def onStop(path, args): self.timer.stop(args[0]) def onSeek(path, args): self.timer.seek(args[0], args[1]) self.server = liblo.ServerThread(self.network.port, group="224.0.0.1") self.server.add_method("/play", "t", onPlay) self.server.add_method("/pause", "t", onPause) self.server.add_method("/stop", "t", onStop) self.server.add_method("/seek", "tt", onSeek) #self.server.add_method(None, None, self.onMessageReceived) self.server.start()
def __init__(self, target_ip="localhost", home_ip="localhost", home_port="9952", on_exit=None, on_connected=None): self.state = Looper.State.UNKNOWN self.ping_event = Event() self.state_event = Event() # callbacks self.state_callback = None self.on_connected = on_connected # OSC client and server self.home_server = liblo.ServerThread(home_port) self.target = liblo.Address(target_ip, "9951") self.home_url = home_ip + ":" + home_port self.home_server.add_method("/state", "isf", self.receive_state, self) self.home_server.add_method("/ping", None, self.receive_ping, self) self.loop_count = 1 # Sooperlooper process self.sooperlooper = SooperLooper(gui=True, on_exit=on_exit) # jackd self.jack = None
def __init__(self): root = Tk() root.geometry('480x320') # root.configure(bg = BG_COLOR) root.title('Synth GUI') # root.attributes("-fullscreen", True) self.oled = OLED(root) #self.oled.pack(fill=X) self.oled.pack() frame = ttk.Frame(root) frame.pack(side=BOTTOM, fill=X) ttk.Button(frame, text='aux').pack(side=LEFT) ttk.Button(frame, text='up').pack(side=LEFT) ttk.Button(frame, text='down').pack(side=LEFT) ttk.Button(frame, text='sel').pack(side=LEFT) ttk.Button(frame, text='quit', command=root.destroy).pack(side=LEFT) try: # Create server server = liblo.ServerThread(4001) self.oled.add_osc_methods(server) # Register a fallback for unhandled messages server.add_method(None, None, self.fallback) # Start server server.start() except liblo.ServerError as err: print(err) sys.exit() root.mainloop()
import liblo import signal import sys import time from consts import CHUCK_IN_PORT, CHUCK_OUT_PORT, CHUCK_HOST, LOOPS_COUNT from row import Row from topbar import Topbar from patterns import Patterns from monome import Monome # setup chuck osc communication chuck_in = liblo.ServerThread(CHUCK_IN_PORT, reg_methods=False) chuck_out = liblo.Address(CHUCK_HOST, CHUCK_OUT_PORT) # setup monome monome = Monome() # setup ui rows = [] def chuck_send(path, loopId, *values): liblo.send(chuck_out, path, loopId, *values) patterns = Patterns(chuck_send) for i in range(LOOPS_COUNT): row = Row(i, i + 1, monome, patterns.on_msg)
stepperPitch.setSourceCompensation(parser.parse_args().srcCmp[0]) #print(port) #rudimentary ctrl-c catch to release the steppers when quitin def userCancel(): stepperYaw.stepperRelease() stepperPitch.stepperRelease() sys.exit(130) # 130 is standard exit code for ctrl-c signal.signal(signal.SIGINT, userCancel) #start a liblo OSC server thread so we don't have to block this thread st = liblo.ServerThread(port) print("Created Server Thread on Port", st.port) def angleYaw_cb(path, args, types): '''OSC callback function for setting the yaw (horizontal) angle''' #print("angleYaw") stepperYaw.updateAngle(args[0]) stepperYaw.setStepMode(args[1]) def anglePitch_cb(path, args, types): '''OSC callback function for setting the pitch (vertical) angle''' #print("anglePitch") stepperPitch.updateAngle(args[0]) stepperPitch.setStepMode(args[1])
from spectral import * # import code import spectralising as spect import ms_lbp import globals import osc import haralicks as hl import numpy as np import matplotlib.pyplot as plt import save_reload import liblo import math #import betti globals.st = liblo.ServerThread(4567) globals.sc_osc_target = osc.make_osc_target(57120) #globals.sc_osc_target = osc.make_osc_target(57121) globals.max_osc_target = osc.make_osc_target(7400) globals.st.start() print("Created Server Thread on Port", globals.st.port) data_file = globals.datapath + "analysis.pkl" # save_reload.save_images(data_file, globals.images) globals.images = save_reload.reload_images(data_file) print("Reloaded images") import utils #globals.images['/Users/hb/phd/data/Database_Chaddad/Intraepithelial_Neolplasia/10pin2.bsq']['img']
def __init__(self, osc_port): GObject.GObject.__init__(self) self.OSCReceiver = liblo.ServerThread(osc_port) self.OSCReceiver.add_method("/strip/fader", 'if', self.fader_callback) self.OSCReceiver.add_method("/strip/gain", 'if', self.fader_gain_callback) self.OSCReceiver.add_method("/strip/solo", 'if', self.solo_callback) self.OSCReceiver.add_method("/strip/mute", 'if', self.mute_callback) self.OSCReceiver.add_method("/strip/recenable", 'if', self.rec_callback) self.OSCReceiver.add_method("/strip/select", 'if', self.select_callback) self.OSCReceiver.add_method("/strip/meter", 'if', self.meter_callback) self.OSCReceiver.add_method("/reply", 'ssiiiiii', self.reply_callback_Track) self.OSCReceiver.add_method("/reply", 'ssiiiii', self.reply_callback_Bus) self.OSCReceiver.add_method("/reply", 'shhi', self.reply_callback_EndRoute) self.OSCReceiver.add_method("/position/smpte", 's', self.smpte_position_callback) self.OSCReceiver.add_method("/select/name", 's', self.select_name_callback) self.OSCReceiver.add_method("/select/polarity", 'i', self.select_phase_callback) self.OSCReceiver.add_method("/select/recenable", 'i', self.select_rec_callback) self.OSCReceiver.add_method("/select/mute", 'i', self.select_mute_callback) self.OSCReceiver.add_method("/select/solo", 'i', self.select_solo_callback) self.OSCReceiver.add_method("/select/solo_iso", 'i', self.select_soloIso_callback) self.OSCReceiver.add_method("/select/solo_safe", 'i', self.select_soloLock_callback) self.OSCReceiver.add_method("/select/monitor_input", 'i', self.select_monitorIn_callback) self.OSCReceiver.add_method("/select/monitor_disk", 'i', self.select_monitorDisk_callback) self.OSCReceiver.add_method("/select/n_inputs", 'i', self.select_ninputs_callback) self.OSCReceiver.add_method("/select/n_outputs", 'i', self.select_noutputs_callback) self.OSCReceiver.add_method("/select/trimdB", 'f', self.select_trimdB_callback) self.OSCReceiver.add_method("/select/fader", 'f', self.select_fader_callback) self.OSCReceiver.add_method("/select/gain", 'f', self.select_fader_gain_callback) self.OSCReceiver.add_method("/select/pan_stereo_position", 'f', self.select_pan_pos_callback) self.OSCReceiver.add_method("/select/pan_stereo_width", 'f', self.select_pan_width_callback) self.OSCReceiver.add_method("/select/trimdB/automation", 'i', self.select_trimdB_automation_callback) self.OSCReceiver.add_method("/select/fader/automation", 'i', self.select_fader_automation_callback) self.OSCReceiver.add_method("/select/send_name", 'is', self.select_send_name_callback) self.OSCReceiver.add_method("/select/send_fader", 'if', self.select_send_fader_callback) self.OSCReceiver.add_method("/select/send_gain", 'if', self.select_send_gain_callback) self.OSCReceiver.add_method("/select/send_enable", 'if', self.select_send_enable_callback) self.OSCReceiver.add_method("/strip/sends", None, self.sends_query_callback) #TODO add send callbacks self.OSCReceiver.add_method(None, None, self.fallback)
#!/usr/bin/env python from __future__ import print_function import liblo import time st = liblo.ServerThread() print("Created Server Thread on Port", st.port) def foo_cb(path, args, types): print("foo_cb():") for a, t in zip(args, types): print("received argument %s of type %s" % (a, t)) def bar_cb(path, args, types, src): print("bar_cb():") print("message from", src.url) print("typespec:", types) for a, t in zip(args, types): print("received argument %s of type %s" % (a, t)) class Blah: def __init__(self, x): self.x = x def baz_cb(self, path, args, types, src, user_data): print("baz_cb():") print(args[0]) print("self.x is", self.x, ", user data was", user_data) st.add_method('/foo', 'ifs', foo_cb) st.add_method('/bar', 'hdc', bar_cb)
if not fileh: print("file not open") return timestamp = str(time.time()) # concat arguments into one , seperated list: arguments = ",".join(str(x) for x in args) print(timestamp + "," + path + "," + types + "," + arguments) fileh.write(timestamp + "," + path + "," + types + "," + arguments + "\n") if RECORD: try: server = liblo.ServerThread(OSCPORT) print("server started on port:", OSCPORT) except liblo.ServerError as err: print(err) sys.exit() try: fileh = open(FILEPATH, 'w') except: print("error opening file:", FILEPATH) sys.exit() server.add_method(None, None, osc_callback) print("osc_callback method added") server.start() print("server started")
#!/usr/bin/python # incoming osc integers 0<>100 are processed and sent to counter osc from __future__ import print_function import liblo import sys, os, time, threading, traceback counter_osc_host = 'localhost' counter_osc_port = 9000 server_osc_port = 9001 DEBUG = True USE_AMPLITUDE = True # modify range of output based on current hr try: counter = liblo.Address(counter_osc_host, counter_osc_port) server = liblo.ServerThread(server_osc_port) except liblo.ServerError as err: print(err) sys.exit() # Generic timer thread def threaded(fn): def wrapper(*args, **kwargs): thread = threading.Thread(target=fn, args=args, kwargs=kwargs) thread.daemon = True thread.start() return thread return wrapper
autoget = not getflag(sys.argv, '--noautoget', remove=True) ADDR_BROADCAST = ('255.255.255.255', 47120) ADDR_LOCAL = (hostname, 47120) DEFAULT_ADDR = ADDR_LOCAL set_default_addr() try: port = sys.argv[1] except IndexError: port = None print ">> No port given. Will use a random generated port" if port: s = liblo.ServerThread(port) else: s = liblo.ServerThread() port = s.port s.add_method('/heartbeat', None, heartbeat_handler) s.add_method('/echo', None, echo_handler) s.add_method('/quit', None, quit_handler) s.add_method(None, None, main_callback) s.add_method('/println', None, println_handler) msg = "PEDLTALK -- Listening to port: {port}".format(port=port) print print "-" * len(msg) print msg
def setUp(self): ServerTestCaseBase.setUp(self) self.server = liblo.ServerThread('1234')