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')
