def start():
"""
Starts a UDP server on localhost:5000 listening for incoming OSC data on /muse/eeg.
"""
parser = argparse.ArgumentParser()
parser.add_argument("--ip",
default="127.0.0.1",
help="The ip to listen on")
parser.add_argument("--port",
type=int,
default=5000,
help="The port to listen on")
args = parser.parse_args()
d = dispatcher.Dispatcher()
d.map("/debug", print)
d.map("/muse/eeg", eeg_handler, "EEG")
server = osc_server.BlockingOSCUDPServer((args.ip, args.port), d)
print("OSC server started {}".format(server.server_address))
try:
server.serve_forever()
except KeyboardInterrupt:
print("Server stopped.")
def start(self):
self._running=True
self._server = osc_server.BlockingOSCUDPServer((socket.gethostbyname(socket.gethostname()),self._port), self._dispatcher)
while self._running:
self._server.handle_request()
self._server.server_close()
self._server=None
def updateServer(self):
if self.server:
self.server.server_address = (self.sv_ip, self.sv_port)
else:
self.server = osc_server.BlockingOSCUDPServer(
(self.sv_ip, self.sv_port), self.disp)
print('Server updated', self.sv_ip, self.sv_port)
def start():
"""
Starts a UDP server on localhost:5000 listening for incoming OSC data on /muse/eeg.
"""
parser = argparse.ArgumentParser()
parser.add_argument("--ip",
default="192.168.1.86",
help="The ip to listen on")
parser.add_argument("--port",
type=int,
default=5000,
help="The port to listen on")
args = parser.parse_args()
print("listening on ip", args.ip, "with port", args.port)
d = dispatcher.Dispatcher()
d.map("/debug", print)
d.map("/muse/eeg", eeg_handler, "EEG")
d.map("/muse/elements/alpha_absolute", alpha_handler, "ALPHA")
d.map("/muse/elements/beta_absolute", beta_handler, "BETA")
d.map("/muse/elements/theta_absolute", theta_handler, "THETA")
d.map("/muse/elements/gamma_absolute", gamma_handler, "GAMMA")
d.map("/muse/elements/delta_absolute", delta_handler, "DELTA")
server = osc_server.BlockingOSCUDPServer((args.ip, args.port), d)
print("OSC server started {}".format(server.server_address))
try:
server.serve_forever()
except KeyboardInterrupt:
print("Server stopped.")
def _osc_server_thread(self):
""" Thread for OSC blocking server """
self._oscserver = osc_server.BlockingOSCUDPServer(
(self.udp_ip, self.udp_port), self._dispatcher)
self._pr('Starting OSC server on {:s}:{:d}...'.format(
self.udp_ip, self.udp_port))
self._oscserver.serve_forever()
self._pr('OSC server shut down.')
def main():
disp = dispatcher.Dispatcher()
disp.set_default_handler(handle_default)
disp.map("/SOSC", handle_simple_osc)
server = osc_server.BlockingOSCUDPServer(("0.0.0.0", 9999), disp)
server.serve_forever()
def run(self):
global FD_control
from pythonosc import dispatcher
dispatcher = dispatcher.Dispatcher()
dispatcher.map('/svd', complexity2FD)
server = osc_server.BlockingOSCUDPServer((self.addr, self.port), dispatcher)
print("Serving on {}".format(server.server_address))
server.serve_forever()
def __init__(self, broadcast_address):
self.disp = dispatcher.Dispatcher()
self.disp.set_default_handler(print)
self.server = osc_server.BlockingOSCUDPServer(("0.0.0.0", 10023),
self.disp)
self.client = udp_client.SimpleUDPClient(broadcast_address,
10023,
allow_broadcast=True)
self.server.socket = self.client._sock
def listen_osc(self, folder, handler, *args):
"""Listen osc at address, port with handler function forever"""
dispatcher_ = dispatcher.Dispatcher()
dispatcher_.map(folder, handler, *args)
server = osc_server.BlockingOSCUDPServer((self.address, self.port),
dispatcher_)
if self.verbose:
print(f"Serving on {server.server_address}")
server.serve_forever()
def start_server_in_separate_thread(counter):
global server_thread, server_ip, server_port, server
our_dispatcher = dispatcher.Dispatcher()
our_dispatcher.map("/tick", handle_tick)
# add other dispatcher hooks here
server = osc_server.BlockingOSCUDPServer((server_ip, server_port), our_dispatcher)
server_thread = threading.Thread(target=server.serve_forever)
server_thread.start()
def _work(self):
disp = dispatcher.Dispatcher()
disp.map("/*", self._got_osc, needs_reply_address=True)
server = osc_server.BlockingOSCUDPServer(
(self._destination, self._port),
disp,
)
server.timeout = 1
while self._running:
server.handle_request()
def startupInputServer(self, context, envars):
print("Create Python Server Thread...")
# creating a blocking UDP Server
# Each message will be handled sequentially on the same thread.
# the alternative:
# ThreadingOSCUDPServer creates loads of threads
# that are not cleaned up properly
self.inputServer = osc_server.BlockingOSCUDPServer((envars.udp_in, envars.port_in), self.dispatcher)
self.server_thread = threading.Thread(target=self.inputServer.serve_forever)
self.server_thread.start()
print("... server started on ", envars.port_in)
def handle_osc():
global osc_udp_client
osc_udp_client = udp_client.SimpleUDPClient(config["osc"]["sendToHost"], config["osc"]["sendToPort"])
disp = dispatcher.Dispatcher()
disp.map(config["path"] + "*", osc_message_handler)
global osc_udp_server
osc_udp_server = osc_server.BlockingOSCUDPServer(
server_address=(config["osc"]["receiveFromHost"], config["osc"]["receiveFromPort"]),
dispatcher=disp)
osc_udp_server.serve_forever()
def __init__(self, in_port, out_port, ip='127.0.0.1', *args):
super(OSCServer, self).__init__()
# OSC library objects
self.dispatcher = dispatcher.Dispatcher()
self.client = udp_client.SimpleUDPClient(ip, out_port)
# Bindings for server
self.init_bindings(self.osc_attributes)
self.server = osc_server.BlockingOSCUDPServer((ip, in_port), self.dispatcher)
# Server properties
self.debug = False
self.in_port = in_port
self.out_port = out_port
self.ip = ip
def main(self):
self.dispatcher = dispatcher.Dispatcher()
self.osc = osc_server.BlockingOSCUDPServer(
(self.osc_address, self.osc_port), self.dispatcher)
self.dispatcher.map("/channel/*/stage/layer/*/", self.parse_stage)
self.dispatcher.map("/channel/*/framerate", self.parse_framerate)
self.dispatcher.map("/channel/*/mixer/audio/*", self.parse_volume)
self.dispatcher.map("/channel/*/output/consume_time",
self.parse_consume_time)
self.dispatcher.set_default_handler(self.parse_null)
self.osc.serve_forever()
def start_server_in_separate_thread():
global server_thread, server_ip, server_port, server
dis = dispatcher.Dispatcher()
dis.map("/tick", handle_tick)
dis.map("/output_1", mix)
dis.map("/output_2", scoop)
dis.map("/output_3", move)
# add other dispatcher hooks here
server = osc_server.BlockingOSCUDPServer((server_ip, server_port), dis)
server_thread = threading.Thread(target=server.serve_forever)
server_thread.start()
def __init__(self, in_port, out_port, ip, ip_client, *args):
super(OSCServer, self).__init__()
# OSC library objects
self.dispatcher = dispatcher.Dispatcher()
self.client = SimpleUDPClientCustom(ip_client, out_port)
# Bindings for server
self.init_bindings(self.osc_attributes)
self.server = osc_server.BlockingOSCUDPServer((ip, in_port), self.dispatcher)
self.server.allow_reuse_address = True
# Server properties
self.debug = False
self.in_port = in_port
self.out_port = out_port
self.ip = ip
def __init__(self, in_port, out_port, ip='127.0.0.1', verbose=True, *args):
super(OSCServer, self).__init__()
# OSC library objects
self.verbose = verbose
self.dispatcher = dispatcher.Dispatcher()
self.client = udp_client.SimpleUDPClient(ip, out_port)
self.init_bindings(self.osc_attributes)
self.server = osc_server.BlockingOSCUDPServer((ip, in_port),
self.dispatcher)
self.in_port = in_port
self.out_port = out_port
self.ip = ip
def main():
# this must only be modified from a Bokeh session callback
# This is important! Save curdoc() to make sure all threads
# see the same document.
doc = curdoc()
#thingy = Surface3d(x="gyro_x", y="gyro_y", z="gyro_z", data_source=source)
layout = column(children=[], sizing_mode='stretch_both')
doc.add_root(layout)
# mapping of name to ClientInfo
clients = {}
disp = dispatcher.Dispatcher()
disp.map("/filter", partial(schedule_update, doc, clients, layout))
server = osc_server.BlockingOSCUDPServer(("localhost", 10000), disp)
server_thread = threading.Thread(target=server.serve_forever)
server_thread.start()
def __init__(self, address):
self.disp = dispatcher.Dispatcher()
self.disp.set_default_handler(print)
self.server = osc_server.BlockingOSCUDPServer(("0.0.0.0", 10023),
self.disp)
self.client = udp_client.SimpleUDPClient(address, 10023)
self.server.socket = self.client._sock
logging.info(" Testing faders...")
for i in range(1, 17):
logging.debug(f" Testing channel {i}")
self.test_fader(f"/ch/{str(i).zfill(2)}", False)
for i in range(1, 9):
logging.debug(f" Testing DCA {i}")
self.test_fader(f"/dca/{i}", True)
logging.info(" Done!")
logging.info(" X32 Ready!")
def launchUDPServer():
# this is handling the messages received from EEGSonic
parser = argparse.ArgumentParser()
parser.add_argument('--ip', default='127.0.0.1',
help='The ip of the OSC server')
parser.add_argument('--port', type=int, default=7400,
help='the port the OSC server is listening on')
args = parser.parse_args()
dispatcher = Dispatcher()
dispatcher.map('*', relayOSC)
# this is receiving the messages from EEGsonic and forwarding to the front end
server = osc_server.BlockingOSCUDPServer(
(args.ip, args.port), dispatcher)
print(f'Serving on {server.server_address}')
server.serve_forever()
def connect(self):
# https://github.com/attwad/python-osc/issues/41
self._udp_client = udp_client.UDPClient(self._host, self._port)
self._udp_client._sock.bind(('', 0))
osc_server.BlockingOSCUDPServer.allow_reuse_address = True
if sys.platform == 'linux':
self._udp_client._sock.setsockopt(socket.SOL_SOCKET,
socket.SO_REUSEADDR, 1)
_, src_port = self._udp_client._sock.getsockname()
self._udp_server = osc_server.BlockingOSCUDPServer(
(self._host, src_port), self._dispatcher)
Thread(target=self._udp_server.serve_forever,
name='reaper_osc').start()
def __init__(self):
print('Starting...')
self.disp = dispatcher.Dispatcher()
self.disp.map('/cc', self.ccRecieve)
self.disp.map('/noteOn', self.noteOn)
#self.client = udp_client.SimpleUDPClient('192.168.2.142', 57120)
self.client = udp_client.SimpleUDPClient('100.75.0.230', 57120)
self.server = osc_server.BlockingOSCUDPServer(('192.168.56.102', 7121),
self.disp)
#self.server = osc_server.BlockingOSCUDPServer(('192.168.56.102', 7121),
#self.disp)
self.message_listener = MessageListener(self.server)
#self.client.send_message('/noteOn', (1, 60))
self.playing = True
self.recording = False
self.beat = 0.0
self.BPM = 80
self.BPS = self.BPM / 60
self.bar = 0
self.phrase = Stream()
self.reply = None
#self.player = BasicPlayer()
self.player = DataReader()
self.reply = self.player.generateBar()
print('AI ready!')
self.input_note = None
self.input_cc = None
self.message_listener.start()
self.mainLoop()
# clean up...
self.message_listener.shutdown()
self.message_listener.join()
def execute(self, context):
global _report
bcw = bpy.context.window_manager
#For sending
try:
self.client = udp_client.UDPClient(bcw.addosc_udp_out,
bcw.addosc_port_out)
msg = osc_message_builder.OscMessageBuilder(address="/blender")
msg.add_arg("Hello from Blender, simple test.")
msg = msg.build()
self.client.send(msg)
except OSError as err:
_report[1] = err
return {'CANCELLED'}
#Setting up the dispatcher for receiving
try:
self.dispatcher = dispatcher.Dispatcher()
self.dispatcher.set_default_handler(OSC_callback_original)
print("Create Server Thread on Port", bcw.addosc_port_in)
# creating a blocking UDP Server
# Each message will be handled sequentially on the same thread.
# the alternative:
# ThreadingOSCUDPServer creates loads of threads
# that are not cleaned up properly
self.server = osc_server.BlockingOSCUDPServer(
(bcw.addosc_udp_in, bcw.addosc_port_in), self.dispatcher)
self.server_thread = threading.Thread(
target=self.server.serve_forever)
self.server_thread.start()
except OSError as err:
_report[0] = err
return {'CANCELLED'}
#inititate the modal timer thread
context.window_manager.modal_handler_add(self)
self._timer = context.window_manager.event_timer_add(
bcw.addosc_rate / 1000, window=context.window)
context.window_manager.status = "Running"
return {'RUNNING_MODAL'}
def main():
game = GameInstance(1)
dspt = dispatcher.Dispatcher()
mappings = {
"/register_player":game.register_player,
"/remove_player":game.remove_player,
"/register_display":game.register_display_server,
"/start":game.start_session,
"/update_param/player/*":game.update_parameter
}
for k, v in mappings:
dspt.map(k, v)
dspt.set_default_handler(default_h)
server = osc_server.BlockingOSCUDPServer(('', 5005),dspt)
server.serve_forever()
def setup(self):
# ColorTerminal().warn('OscReader-setup')
if self.oscServer != None:
self.destroy()
ColorTerminal().output("Starting OSC Server with host {0} and port {1}".format(self.host, self.port))
dispatcher = Dispatcher()
dispatcher.map('/marker', self.oscMarkerHandler)
dispatcher.map("/rigidbody", self.oscRigidBodyHandler)
try:
self.oscServer = osc_server.BlockingOSCUDPServer((self.host, self.port), dispatcher)
self.oscServer.handle_timeout = self.handleTimeout
self.oscServer.timeout=0
#self.oscServer.serve_forever()
except OSError as err:
ColorTerminal().fail("Could not create OSC server: ", err)
self.oscServer = None
ColorTerminal().success("OSC Server running")
def start(self, input_port):
if self.running:
self.stop()
if not self.parser.isLoaded():
log_data.append(
"No configuration loaded, once you load a configuration the server will start"
)
return
for key, string in self.parser.getUdpClientStrings().items():
if string.split(":")[1] == str(input_port):
log_data.append(
"Cannot start server because the input port {0} is the same as the the output port for prefix '{1}'. Please change the input port."
.format(input_port, key))
return
try:
dispatch = dispatcher.Dispatcher()
for key in self.parser.getSceneMap():
dispatch.map("/scene/" + key, self.respond_to_scene)
for number in self.parser.getMidiMap():
dispatch.map("/midi-scene/" + str(round(number / 127, 2)),
self.respond_to_scene)
dispatch.set_default_handler(self.route_message)
self.server = osc_server.BlockingOSCUDPServer(
("0.0.0.0", input_port), dispatch)
self.server_thread = Thread(target=self.server.serve_forever)
self.server_thread.start()
log_data.append(
"\nServer started, listening on all interfaces on port {0}...\n"
.format(input_port))
self.running = True
except KeyboardInterrupt:
print("Exiting...")
sys.exit(0)
def start_background():
# parser = argparse.ArgumentParser()
# parser.add_argument("--ip",
# default="127.0.0.1", help="The ip to listen on")
# parser.add_argument("--port",
# type=int, default=9999, help="The port to listen on")
# args = parser.parse_args()
ip = '10.0.0.2'
port = 9999
a_dispatcher = dispatcher.Dispatcher()
a_dispatcher.map("/pot/0", update_kick_dist)
a_dispatcher.map("/pot/1", update_kick_decay)
a_dispatcher.map("/pot/2", update_kick_release)
a_dispatcher.map("/pot/4", update_kick_pitch_high)
a_dispatcher.map("/pot/3", update_kick_pitch_low)
a_dispatcher.map("/pot/5", update_shuffle)
# a_dispatcher.map("/pot/0", update_kick_roll)
# a_dispatcher.map("/*", print)
server = osc_server.BlockingOSCUDPServer((ip, port), a_dispatcher)
print("Serving on {}".format(server.server_address))
server.serve_forever()
stroke.main(strokeCharacter)
strokeCharacter = []
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--ip",
default="239.255.0.85", help="The ip (multicast or unicast) to listen on")
parser.add_argument("--port",
type=int, default=10085, help="The port to listen on")
parser.add_argument("--ifaceip",
default="10.10.10.35", help="The ip of the interface to listen on, if multicast")
args = parser.parse_args()
address = (args.ip, args.port)
interface_addr = args.ifaceip
dispatch = dispatcher.Dispatcher()
# log_everything(dispatch)
log_gesture(dispatch)
#log_hand(dispatch)
process_hand(dispatch)
process_open_gesture(dispatch)
#process_heartbeat(dispatch)
# server = osc_server.ThreadingOSCUDPServer(address, dispatch, interface_addr)
server = osc_server.BlockingOSCUDPServer((args.ip, args.port), dispatch, args.ifaceip)
server.serve_forever()
def execute(self, context):
global _report
bcw = bpy.context.window_manager
#For sending
try:
self.client = udp_client.UDPClient(bcw.addosc_udp_out,
bcw.addosc_port_out)
msg = osc_message_builder.OscMessageBuilder(address="/blender")
msg.add_arg("Hello from Blender, simple test.")
msg = msg.build()
self.client.send(msg)
except OSError as err:
_report[1] = err
return {'CANCELLED'}
#Setting up the dispatcher for receiving
try:
self.dispatcher = dispatcher.Dispatcher()
for item in bpy.context.scene.OSC_keys:
#For ID custom properties (with brackets)
if item.id[0:2] == '["' and item.id[-2:] == '"]':
dataTuple = (1, eval(item.data_path), item.id, item.idx,
make_tuple(item.osc_index))
self.dispatcher.map(item.address, OSC_callback_pythonosc,
dataTuple)
#For normal properties
#with index in brackets -: i_num
elif item.id[-1] == ']':
d_p = item.id[:-3]
i_num = int(item.id[-2])
dataTuple = (2, eval(item.data_path), d_p, i_num,
make_tuple(item.osc_index))
self.dispatcher.map(item.address, OSC_callback_pythonosc,
dataTuple)
#without index in brackets
else:
try:
if isinstance(getattr(eval(item.data_path), item.id),
mathutils.Vector):
dataTuple = (3, eval(item.data_path), item.id,
item.idx, make_tuple(item.osc_index))
self.dispatcher.map(item.address,
OSC_callback_pythonosc,
dataTuple)
elif isinstance(getattr(eval(item.data_path), item.id),
mathutils.Quaternion):
dataTuple = (3, eval(item.data_path), item.id,
item.idx, make_tuple(item.osc_index))
self.dispatcher.map(item.address,
OSC_callback_pythonosc,
dataTuple)
except:
print("Improper setup received: object '" +
item.data_path + "' with id'" + item.id +
"' is no recognized dataformat")
self.dispatcher.set_default_handler(OSC_callback_pythonosc_undef)
print("Create Server Thread on Port", bcw.addosc_port_in)
# creating a blocking UDP Server
# Each message will be handled sequentially on the same thread.
# the alternative:
# ThreadingOSCUDPServer creates loads of threads
# that are not cleaned up properly
self.server = osc_server.BlockingOSCUDPServer(
(bcw.addosc_udp_in, bcw.addosc_port_in), self.dispatcher)
self.server_thread = threading.Thread(
target=self.server.serve_forever)
self.server_thread.start()
# register the execute queue method
bpy.app.timers.register(execute_queued_OSC_callbacks)
except OSError as err:
_report[0] = err
return {'CANCELLED'}
#inititate the modal timer thread
context.window_manager.modal_handler_add(self)
self._timer = context.window_manager.event_timer_add(
bcw.addosc_rate / 1000, window=context.window)
context.window_manager.status = "Running"
return {'RUNNING_MODAL'}
