def create_dispatcher(self):
self.dispatcher = dispatcher.Dispatcher()
for control in self.controls.items():
self.dispatcher.map('/video/' + control[0], self.udp_update,
control[1])
def setupInputServer(self, context, envars):
self.dispatcher = dispatcher.Dispatcher()
def __init__(self):
self.root = tk.Tk()
self.root.title(APP_NAME)
self.root.config(bg=COLOR_SCHEME['panel_bg'])
hs = self.root.winfo_screenheight()
self.root.geometry('1200x600+0+%d' % (hs / 2))
#self.root.resizable(0, 0)
#self.style = Style()
#self.style.theme_use('clam')
self.cl_ip = CLIENT_ADDR
self.cl_port = CLIENT_PORT
self.sv_ip = SERVER_ADDR
self.sv_port = SERVER_PORT
#self.client = udp_client.SimpleUDPClient(self.cl_ip, self.cl_port)
self.updateClient()
# for TouchOSC app...
self.touchOSCdisp = dispatcher.Dispatcher()
self.touchOSCdisp.map('/*', self.parseOSC)
self.touchOSCServer = osc_server.BlockingOSCUDPServer(
TOUCH_OSC_SERVER, self.touchOSCdisp)
self.touchOSCClient = udp_client.SimpleUDPClient(*TOUCH_OSC_CLIENT)
# setup managers...
self.queue_manager = multiprocessing.Manager()
self.request_queue = self.queue_manager.Queue()
self.network_manager = NetworkManager(self.request_queue)
self.network_manager.start()
self.mainframe = tk.Frame(self.root, bg=COLOR_SCHEME['panel_bg'])
#self.mainframe.pack_propagate(False)
self.mainframe.pack(fill='both', expand=True)
self.mainframe.columnconfigure(0, weight=1)
#self.mainframe.rowconfigure(0, weight=1)
# main control panel...
self.maincontrols = tk.Frame(self.mainframe,
bg=self.mainframe.cget('bg'))
timeFont = font.Font(family='Courier', size=12, weight='bold')
self.timeLabel = tk.Label(self.maincontrols,
text='00:00',
bg='#303030',
fg='orange',
width=10,
relief='sunken',
bd=2,
font='Arial 16',
padx=5,
pady=5)
self.BPM = tk.IntVar(self.maincontrols)
self.bpmBox = tk.Spinbox(self.maincontrols,
from_=20,
to=240,
textvariable=self.BPM,
width=3,
bg=self.maincontrols.cget('bg'),
fg=COLOR_SCHEME['text_light'],
buttonbackground=self.maincontrols.cget('bg'))
self.panicButton = tk.Button(self.maincontrols,
text='all off',
command=self.panic,
bg=self.maincontrols.cget('bg'),
activebackground='orange',
activeforeground='black',
fg=COLOR_SCHEME['text_light'])
# pack main controls...
self.timeLabel.grid(row=0, column=4, rowspan=2, padx=5)
tk.Label(self.maincontrols,
text='Tempo:',
fg=COLOR_SCHEME['text_light'],
bg=self.maincontrols.cget('bg')).grid(row=0,
column=5,
sticky='e')
self.bpmBox.grid(row=0, column=6)
self.panicButton.grid(row=1, column=5, columnspan=2, sticky='ew')
# add clock...
self.clockQueue = multiprocessing.Queue()
mgr = multiprocessing.Manager()
self.clockVar = mgr.dict()
self.clock = Clock(self.client, self.clockVar, self.clockQueue)
self.BPM.trace('w', self.BPMchange)
self.BPM.set(80)
# add instrument button and panels...
#self.instrumentsBox = tk.Frame(self.mainframe, relief='sunken', bd=2, bg=COLOR_SCHEME['note_panel_bg'])
self.instrumentsBox = VScrollFrame(
self.mainframe,
relief='sunken',
bd=2,
)
self.ins_manager = InstrumentManager(self.instrumentsBox, self.client,
self.request_queue,
self.queue_manager, self.clockVar,
self.touchOSCClient)
#self.ins_manager.addInstrument()
# add engine...
#self.engine = Engine(self, self.ins_manager, self.BPM, touchOSCClient=self.touchOSCClient)
self.engine = Engine(self, self.client, self.clockVar, self.clockQueue,
self.ins_manager)
# add controls...
self.controls = PlayerControls(self.maincontrols, self, self.engine)
self.controls.grid(row=0, column=0, rowspan=2)
# add status bar...
self.statusBar = tk.Frame(self.mainframe,
relief='sunken',
bg=COLOR_SCHEME['dark_grey'],
bd=2)
self.statusLabel = tk.Label(self.statusBar,
bg=self.statusBar.cget('bg'),
fg=COLOR_SCHEME['text_light'],
text='Connecting too: {}, Port:{}'.format(
self.cl_ip, self.cl_port))
self.statusLabel.bind('<Button-1>', self.editConnection)
self.statusLabel.pack(side='right')
# place everything...
#self.maincontrols.pack(padx=5, pady=5)
#self.instrumentsBox.pack(fill='both', expand=True, ipadx=4, ipady=4)
#self.statusBar.pack(side='bottom', fill='x')
self.mainframe.grid_rowconfigure(1, weight=1)
self.maincontrols.grid(row=0, column=0)
#self.instrumentsBox.grid(row=1, column=0, sticky='nsew')
self.statusBar.grid(row=2, column=0, sticky='ew')
# add OSC listeners...
self.disp = dispatcher.Dispatcher()
self.disp.map('/pingReply', self.pingReply, self.statusLabel)
self.disp.map('/cc', self.ccRecieve)
self.disp.map('/noteOn', self.noteOn)
self.joystick_moved = False
self.updateServer()
self.listener = MessageListener(self.server)
self.touchOSCListener = MessageListener(self.touchOSCServer)
# start the loops...
self.engine.daemon = True
self.clock.start()
self.engine.start()
self.listener.start()
self.touchOSCListener.start()
self.checkConnection()
self.updateGUI()
self.root.mainloop()
# tidy up on close...
print('Closing threads...')
self.ins_manager.send_message('/panic', 0)
mgr.shutdown()
self.engine.join(timeout=1)
self.clock.join(timeout=1)
self.listener.join(timeout=1)
self.touchOSCListener.join(timeout=1)
self.network_manager.terminate()
self.network_manager.join(timeout=1)
def setUp(self): super().setUp() self.dispatcher = dispatcher.Dispatcher()
plot_manager.plot_time_series(time_series)
def callback_print_test_breath():
global test_breath_cycles, mean_tbc
plot_manager.plot_breath_test(test_breath_cycles, mean_tbc)
def from_main_thread_blocking():
callback = main_thread_queue.get() #blocks until an item is available
callback()
main_thread_queue = queue.Queue()
server_dispatcher = dispatcher.Dispatcher()
server_dispatcher.map("/max/cycle_sample", collect_breath_sample)
server_dispatcher.map("/max/start_cycle", start_cycle)
server_dispatcher.map("/max/model_path", load_model)
if __name__ == "__main__":
client = udp_client.SimpleUDPClient(server_ip, port_max_msp)
# server for receiving OSC messages
s = OSC_server(server_ip, server_port, server_dispatcher)
s.start_server()
print("Server is ready!")
def __init__(self, incoming, outgoing, sparseOutput=None, config={}, device_source='Muse',
software_source='muselsl', debug_outputs=True, verbose=False):
self.incoming = incoming
self.outgoing = outgoing
self.sparseOutput = sparseOutput
self.device_source = device_source
self.software_source = software_source
self.debug_outputs = debug_outputs
self.verbose = verbose
self.eeg_chunk_length = 12
# 1. Initialize inlet
if isinstance(self.incoming, str): # LSL inlet
print('Looking for the {} stream...'.format(incoming))
self._stream = resolve_byprop('type', incoming, timeout=2)
if len(self._stream) == 0:
raise(RuntimeError('Can\'t find {} stream.'.format(incoming)))
print('Aquiring data from the \'{}\' stream...'.format(incoming))
self._inlet = StreamInlet(self._stream[0],
max_chunklen=self.eeg_chunk_length)
self._info_in = self._inlet.info()
else: # OSC port
if USE_LIBLO:
self._osc_server = ServerThread(incoming['port'])
print('OSC server initialized at port {}.'.format(
incoming['port']))
else:
self._dispatcher = dispatcher.Dispatcher()
print('python-osc dispatcher initialized.')
# 2. Initialize outlets
if not isinstance(self.outgoing, tuple):
self.outgoing = [self.outgoing]
self._output_threads = []
for out in self.outgoing:
if isinstance(out, str): # LSL outlet
raise NotImplementedError
elif isinstance(out, dict): # OSC port
if USE_LIBLO:
self._output_threads.append(Address(out['address'],
out['port']))
else:
raise NotImplementedError
# self._client = udp_client.SimpleUDPClient(
# outgoing['address'], outgoing['port'])
print('OSC client initialized at {}:{}.'.format(
out['address'], out['port']))
if (self.sparseOutput !=None):
if not isinstance(self.sparseOutput, tuple):
self.sparseOutput = [self.sparseOutput]
self._sparseOutput_threads = []
for out in self.sparseOutput:
if isinstance(out, str): # LSL outlet
raise NotImplementedError
elif isinstance(out, dict): # OSC port
if USE_LIBLO:
self._sparseOutput_threads.append(Address(out['address'],
out['port']))
else:
raise NotImplementedError
print('OSC sparse output client initialized at {}:{}.'.format(
out['address'], out['port']))
# 3. Initialize internal buffers and variables
self._init_processing(config)
def _get_dispatcher(self):
d = dispatcher.Dispatcher()
d.map("/debug", print)
d.map("/muse/eeg", self._eeg_handler, "EEG")
return d
sleep(msec / 1000.0) #sleep for duration of note
#stop current song if playing set to False by received "/abort" message
if playing == False:
break
client.send_message("/finished", True) #broadcasts osc msg when finished
def killPlay(unused_addr): #sets playing flag to False when "/abort" received
global playing
playing = False
print("Playing stopped")
try:
#set up dispatcher to handle incoming OSC messages
dispatcher = dispatcher.Dispatcher() #initialise dispatcher
#check incoming OSC messages and dispatch handlers for matching ones
#handler for "/name" calls getData with name of ringtone as a parameter
dispatcher.map("/name", getData, "name") #get name of ringtone to play
#handler for "/abort" calls killPlay
dispatcher.map("/abort",
killPlay) #this dispatcher is used to abort playing
#set up server on localhost linked to dispatcher
server = osc_server.ThreadingOSCUDPServer(('127.0.0.1', 8000), dispatcher)
#print configuration data on terminal screen
print("Serving on {}".format(server.server_address))
print("Data broadcast to {} to port {}".format(broadcastAddress, 4559))
#start serving
server.serve_forever()
#allow clean ctrl-C exit
def main():
global hue_list, bridge, SRT_FILENAME, HUE_IP_ADDRESS, MAX_BRIGHTNESS
global DMX_INTERVAL, INTERVAL, TRANSITION_TIME, HUE_IP_ADDRESS, DEBUG, VERBOSE
global subs, srtFile
global ipcon, tfIDs, dmx
f1 = Figlet(font='standard')
print(f1.renderText('LushRoom'))
f2 = Figlet(font='standard')
print(f2.renderText('OSC live record'))
parser = argparse.ArgumentParser()
parser.add_argument("--ip",
default="127.0.0.1",
help="OSC ip address to listen to")
parser.add_argument("--port",
type=int,
default=8000,
help="OSC port to listen to")
parser.add_argument("-s",
"--srt",
default=SRT_FILENAME,
help=".srt file name for lighting events")
parser.add_argument("-b",
"--brightness",
default=MAX_BRIGHTNESS,
help="maximum brightness")
parser.add_argument("-i",
"--interval",
default=INTERVAL,
help="sampling interval for Philips Hue events")
parser.add_argument("-d",
"--dmx_interval",
default=DMX_INTERVAL,
help="sampling interval for DMX events")
parser.add_argument("-t",
"--transition_time",
default=TRANSITION_TIME,
help="transition time between Philips Hue events")
parser.add_argument("--hue",
default=HUE_IP_ADDRESS,
help="Philips Hue bridge IP address")
args = parser.parse_args()
print(args)
MAX_BRIGHTNESS = int(args.brightness)
SRT_FILENAME = args.srt
INTERVAL = float(args.interval)
DMX_INTERVAL = float(args.dmx_interval)
TRANSITION_TIME = float(args.transition_time)
HUE_IP_ADDRESS = args.hue
# VERBOSE = args.verbose
# DEBUG = args.debug
if SRT_FILENAME != "":
print("Start recording the %s subtitles track for light events." %
SRT_FILENAME)
srtFile = SubRipFile(path=SRT_FILENAME)
if PLAY_HUE:
bridge = Bridge(HUE_IP_ADDRESS)
bridge.connect()
bridge.get_api()
lights = bridge.lights
for l in lights:
print(l.name)
for l in lights:
l.on = True
l.brightness = MAX_BRIGHTNESS
light_names = bridge.get_light_objects('name')
print("Light names:", light_names)
if PLAY_HUE:
hue_list = hue_build_lookup_table(lights)
# else:
# hue_list = [[0],['1'],[2],[3],[4],[5],[6],[7],[8],[9]]
print(hue_list)
if PLAY_DMX:
ipcon.connect(HOST, PORT)
# Register Enumerate Callback
ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE, cb_enumerate)
# Trigger Enumerate
ipcon.enumerate()
sleep(2)
if DEBUG:
print(tfIDs)
dmxcount = 0
for tf in tfIDs:
# try:
if True:
# print(len(tf[0]))
if len(
tf[0]
) <= 3: # if the device UID is 3 characters it is a bricklet
if tf[1] in deviceIDs:
if VERBOSE:
print(tf[0], tf[1], getIdentifier(tf))
if tf[1] == 285: # DMX Bricklet
if dmxcount == 0:
print(
"Registering %s as slave DMX device for capturing DMX frames"
% tf[0])
dmx = BrickletDMX(tf[0], ipcon)
dmx.set_dmx_mode(dmx.DMX_MODE_MASTER)
# channels = int((int(MAX_BRIGHTNESS)/255.0)*ones(512,)*255)
# dmx.write_frame([255,255])
sleep(1)
# channels = int((int(MAX_BRIGHTNESS)/255.0)*zeros(512,)*255)
# dmx.write_frame(channels)
dmxcount += 1
disp = dispatcher.Dispatcher()
# print(dir(dispatcher))
for h in range(512):
disp.map("/hue%s" % h, play_record_hue, "%s" % h)
for h in range(512):
disp.map("/dmx%s" % h, play_record_dmx, "%s" % h)
server = osc_server.ThreadingOSCUDPServer((args.ip, args.port), disp)
print("Serving OSC on {}".format(server.server_address))
signal.signal(signal.SIGINT, signal_handler)
server.serve_forever()
def setup(self):
self.dispatcher = dispatcher.Dispatcher()
self.server = osc_server.ThreadingOSCUDPServer(('0.0.0.0', 8000),
self.dispatcher)
self.setup_listeners()
soundObjects = {}
# current sound data
currentSound = None
# handle to manage the sound player
soundPlayerHandle = None
# current video path
videoSource = None
# handle to manage the child process (the video player)
videoProcessHandle = None
# path to the video player to be invoked to play video files
VIDEO_PLAYER = "/bin/mpv"
oscDispatcher = osc_dispatcher.Dispatcher()
# ip to listen to
neoIP = "127.0.0.1"
port = 9999
oscServer = osc_server.ThreadingOSCUDPServer((neoIP, port), oscDispatcher)
def setup():
global oscDispatcher
global soundObjects
global videoProcessHandle
# map osc labels to methods
oscDispatcher.map("/francais", setSource)
oscDispatcher.map("/anglais", setSource)
oscDispatcher.map("/medieval", changeMusic)
def __init__(self, port):
self.dispatcher = dispatcher.Dispatcher()
self.server = osc_server.ThreadingOSCUDPServer(("0.0.0.0", port),
self.dispatcher)
def createServer(port):
disp = dispatcher.Dispatcher()
print("Starting server on: {0}:{1}".format(socket.gethostbyname(socket.gethostname()),port))
disp.map( "/quit", onOSC_quit )
server=OSCServer(port,disp)
return server
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("-send-ip", default="127.0.0.1", help="The IP to send OSC to")
parser.add_argument("-send-port", type=int, default=57120, help="The port to send OSC to")
parser.add_argument("-rcv-ip", default="127.0.0.1", help="The OSC IP to listen to")
parser.add_argument("-rcv-port", type=int, default=9191, help="The OSC port to listen to")
parser.add_argument("-ws-port", type=int, default=8080, help="The websockets port listening for connection from a browser")
parser.add_argument("-origin", default="https://anatomiesofintelligence.github.io", help="Allowed client URL")
parser.add_argument("-echo", type=bool, default=False, help="Enable server echo")
clargs = parser.parse_args()
WSHandler.server_out = (clargs.send_ip, clargs.send_port)
WSHandler.server_in = (clargs.rcv_ip, clargs.rcv_port)
WSHandler.allowed_origins.append(clargs.origin)
WSHandler.echo = clargs.echo
app = make_app()
app.listen(clargs.ws_port)
print("Waiting for websockets connection on port {} .... ".format(clargs.ws_port))
WSHandler.osc_client = udp_client.SimpleUDPClient(WSHandler.server_out[0], WSHandler.server_out[1])
print('Sending UDP/OSC messages to {}: {} ...'.format(WSHandler.server_out[0], WSHandler.server_out[1]))
WSHandler.osc_dispatcher = dispatcher.Dispatcher()
WSHandler.osc_dispatcher.set_default_handler(WSHandler.osc_message)
WSHandler.osc_serv = osc_server.AsyncIOOSCUDPServer(WSHandler.server_in, WSHandler.osc_dispatcher, asyncio.get_event_loop())
WSHandler.osc_serv.serve()
print("Listening for OSC messages on {}: {} ...".format(WSHandler.server_in[0], WSHandler.server_in[1]))
tornado.ioloop.IOLoop.instance().start()
print("\t+ abort code running")
if thread is not None:
thread.kill()
thread.join()
if not thread.isAlive():
print('thread killed')
else:
print("no thread to kill")
# Clean message buffer
message = ""
except Exception as e:
print('Error, Msg: %s, %s' % (e, traceback.format_exc()))
# Set up address and port.
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=5001,
help="The port to listen on")
args = parser.parse_args()
dispatch = dispatcher.Dispatcher()
dispatch.map(address, callback)
server = osc_server.ThreadingOSCUDPServer((args.ip, args.port), dispatch)
print("Serving on {}".format(server.server_address))
server.serve_forever()
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=1000, # make sure you change the port every time you wanna run the code
# for example next one would be 5050 :)
help="The port to listen on")
parser.add_argument("--serial",
default="",
help="Arduino serial port")
args = parser.parse_args()
dispatcher.Dispatcher()
dispatcher.Dispatcher().map("/debug", print)
dispatcher.Dispatcher().map("/muse/notch_filtered_eeg", eeg_handler, "EEG")
dispatcher.Dispatcher().map("/muse/elements/jaw_clench", jawClench, "EEG")
######################################################################### dispatcher.map("/muse/elements/blink", blink, "EEG")
server = osc_server.ThreadingOSCUDPServer(
(args.ip, args.port), dispatcher)
print("Serving on {}".format(server.server_address))
server.serve_forever()
#p1 = Process(target=Drone)
#p2 = Process(target=Muse)
#p3 = Process(target=Test)
# p1.start()
# p2.start()
def __init__(self):
self.dispatcher = dispatcher.Dispatcher()
self.server = osc_server.ThreadingOSCUDPServer(ip, port), dispatcher)
def __init__(self):
r_times = []
# note lookup
# self.lib = seq.Libraries("squiggles")
# sequencer to use # note, no support for multiple sequencers yet
#self.seq = seq.Sequencer(self.lib)
#self.seq.mutate(1.0)
self.robots = []
self.mutation_probability = 0.04
self.bpm_activation_level = 0.0
self.leakiness = 0.99
self.bpm = 50
self.bpm_max = 200
self.bpm_min = 50
self.density_r = 0.0
self.density_l = 0.0
parser = argparse.ArgumentParser()
robotTestIP = "192.168.43.116"
robotTestIP = "127.0.0.1"
robotTestIP = "192.168.43.135"
parser.add_argument("--ip",
default=robotTestIP,
help="The ip to listen on")
parser.add_argument("--port",
type=int,
default=9000,
help="The port to listen on")
broadcastIp = "255.255.255.255"
parser.add_argument("--bcip",
default=broadcastIp,
help="The ip to broadcast on")
parser.add_argument("--bcport", type=int, default=9001)
args = parser.parse_args()
self.client = udp_client.SimpleUDPClient(args.bcip, args.bcport, True)
self.counter = 0.0
dispatcher = DPatcher.Dispatcher()
#dispatcher.map("/beat", beat_handler, "beat")
dispatcher.map("/beat", self.broadcast, "rhythm")
dispatcher.map("/bpm", self.setbpm, "bpm")
dispatcher.map("/emg", self.broadcastemg, "emg")
self.emg_signal_l = [] # array of 8 values
self.emg_signal_r = []
self.emg_right_buffer = []
self.emg_left_buffer = []
self.acc_l = 0.0
self.acc_r = 0.0
self.acc_left_buffer = []
self.acc_right_buffer = []
self.acc_l_max = 0.0
self.acc_r_max = 0.0
#dispatcher.map("/volume", print_volume_handler, "Volume")
#dispatcher.map("/logvolume", print_compute_handler, "Log volume", math.log)
self.server = osc_server.ThreadingOSCUDPServer((args.ip, args.port),
dispatcher)
print("Serving on {}".format(self.server.server_address))
self.server.serve_forever()
c_parser = argparse.ArgumentParser()
c_parser.add_argument("--ip",
default="192.168.43.135",
help="The ip of the OSC server")
c_parser.add_argument("--port",
type=int,
default=9001,
help="The port the OSC server is listening on")
c_args = parser.parse_args()
self.client = udp_client.SimpleUDPClient(c_args.ip, c_args.port)
def __init__(self):
self.name = 'eos'
super().__init__()
self.client = udp_client.SimpleUDPClient(
self.config['console']['ip'],
int(self.config['console']['rx-port']))
self.data = {'group': {}, 'preset': {}}
self.set_eos_user(int(self.config['console']['user']))
def data_reply_handler(address, *args):
"""Deals with groups and presets messages.
These can include counts, data dumps, and empty returns
indicating the group or preset has been deleted.
/eos/out/get/group/count=3
/eos/out/get/group/1/list/0/3=74738347 3829383 LABEL
"""
def delete_num_from_data(eos_type, num):
"""Delete a given Eos item from the internal data dict."""
for k, v in self.data[eos_type].items():
if v == num:
del self.data[eos_type][k]
break
address = address.split('/')
eos_type = address[4]
# Empty arguments and an address length of 6 indicates that the
# request address has been returned empty, so we can assume it
# has been deleted on the console and therefore remove it from
# our internal dict.
if len(address) == 6 and not args:
num = address[5]
delete_num_from_data(eos_type, num)
# Keyword 5 being count indicates we are receiving the count
# number for a data type in the arguments. We then request all
# data in the list by sending OSC requests for every index.
elif address[5] == 'count':
self.log('Found {0} {1}'.format(args[0], eos_type))
for i in range(0, args[0]):
msg = '/eos/get/{0}/index/{1}'.format(eos_type, str(i))
self.send_osc_message(msg, 0)
# Keyword 6 being list indicates we have received an information
# dump in the arguments, in this case containing the label.
elif address[6] == 'list':
num = address[5]
label = args[2].upper()
# We don't know whether this is a new group/preset or a
# change of name of an existing one, so we need to check if
# there is already a group/preset with this number in the
# dictionary, and if there is, delete it and add this one.
if num in self.data[eos_type].values():
delete_num_from_data(eos_type, num)
self.data[eos_type][label] = num
def subscription_handler(address, *args):
"""Deals with all Eos automatic notifications."""
address = address.split('/')
# All currently supported notifications have their Eos type
# in keyword 4, so we can just dump everything else.
eos_type = address[4]
if eos_type in self.data.keys():
num = args[1]
self.send_osc_message(
'/eos/get/{0}/{1}'.format(eos_type, str(num)), 0)
router = dispatcher.Dispatcher()
router.map('/eos/out/get/group/*', data_reply_handler)
router.map('/eos/out/get/preset/*', data_reply_handler)
router.map('/eos/out/notify/*', subscription_handler)
# Listen for OSC packets in a new thread
server = osc_server.ThreadingOSCUDPServer(
(self.config['server']['listen-ip'],
int(self.config['console']['tx-port'])), router)
server_thread = threading.Thread(target=server.serve_forever)
try:
server_thread.start()
except (KeyboardInterrupt, SystemExit):
server.shutdown()
# Subscribe to Eos updates so we can update the group and preset lists
# automatically
self.send_osc_message('/eos/subscribe', 1)
self.generate_label_dict()
def __init__(self, ip, port):
self.dispatcher = dispatcher.Dispatcher()
self.dispatcher.map("/clip", self.print_clip_handler, "")
self.server = osc_server.ThreadingOSCUDPServer((ip, port), self.dispatcher)
import os
ip_address = os.popen(
'ip addr show wlp1s0 | grep "\<inet\>" | awk \'{ print $2 }\' | awk -F "/" \'{ print $1 }\''
).read().strip()
if "win" in platform:
try:
import netifaces
except:
print(
"netifaces module missing - try to install it using pip3 install netifaces"
)
netifaces.ifaddresses(netifaces.gateways()['default'][netifaces.AF_INET]
[1])[netifaces.AF_INET][0]['addr']
port = 9000 ## Choose any
def on_message_received(*args): ## Our callback
print(args) ## In this case only printing the arguments
dispatcher = dispatcher.Dispatcher(
) ## Create a dispatcher - you can create more than one for different address patterns
dispatcher.map(osc_address_pattern, on_message_received)
server = osc_server.ThreadingOSCUDPServer(
(ip_address, port),
dispatcher) ## Create and start an OSC server with the attached dispatcher
print("Server listening on %s:%d for address pattern %s" %
(ip_address, port, osc_address_pattern))
print("Start an OSC device or your phone OSC stream.")
server.serve_forever()
def init_server(self, handle):
self.handler = dispatcher.Dispatcher()
self.handler.map("/machine1_server", handle)
self.server = osc_server.ThreadingOSCUDPServer((self.host, self.port),
self.handler)
def __init__(self, *args, **kw):
super(OSCServer, self).__init__(*args, **kw)
self.dispatcher = dispatcher.Dispatcher()
def __init__(self, ip, port):
self.dispatcher = dispatcher.Dispatcher()
self.dispatcher.map("/reply", self.reply_handler, "")
self.server = osc_server.ThreadingOSCUDPServer((ip, port),
self.dispatcher)
def main(argv):
args = process_arguments(argv)
# Set the NGIMU to send to this machine's IP address
client = udp_client.SimpleUDPClient(args.ip, args.port)
client.send_message('/wifi/send/ip', get_address())
client.send_message('/wifi/send/port', args.receive_port)
#CSV file setup
global flag, outfile, writer, prevTime, totalTimeBtwn, timeBtwnCnt
totalTimeBtwn = 0 #Sums up the time between each message being recorded
timeBtwnCnt = 0 #Counts how many times a message has been recorded
outfile = open('imuData' + csvNumber + '.csv',
'w') #CSV for storing data recieved from the imu
writer = csv.writer(outfile)
flag = False #Flag for a button press on the imu, used to start and stop recording data
def sensorsHandler(t, add, gx, gy, gz, ax, ay, az, mx, my, mz, b):
global flag, prevTime, totalTimeBtwn, timeBtwnCnt
if (flag):
#Used to calculate average frequency of messages being received
if (timeBtwnCnt == 0):
prevTime = t
timeBtwnCnt += 1
else:
timeBtwn = t - prevTime
totalTimeBtwn += timeBtwn
timeBtwnCnt += 1
prevTime = t
#Record data to CSV
writer.writerow([t, math.sqrt(ax**2 + ay**2 + az**2)])
def setFLag(add, t):
global flag
flag = not flag
print('Flag', flag)
dispatch = dispatcher.Dispatcher()
dispatch.map('/sensors', sensorsHandler)
dispatch.map('/button', setFLag)
# Set up receiver
receive_address = get_address(), args.receive_port
server = osc_server.ThreadingOSCUDPServer(receive_address, dispatch)
print("Serving on {}".format(server.server_address))
print("\nUse ctrl-C to quit.")
print("\nTap button on NGIMU to begin data logging")
# Start OSCServer
server_thread = threading.Thread(target=server.serve_forever)
prevTime = time.time()
server_thread.start()
# Loop while threads are running
try:
while 1:
time.sleep(1)
except KeyboardInterrupt:
f = open('imuFreq' + csvNumber + '.csv', 'w')
w = csv.writer(f)
w.writerow([totalTimeBtwn / timeBtwnCnt])
server.shutdown()
server_thread.join()
return 0
def Muse():
print('hello')
# Array to store OSC data for further processing
TempCH1 = []
TempCH2 = []
TempCH3 = []
TempCH4 = []
# Global Variable
is_jaw_clench = False
def counter(x):
counter.calls += 1
return x + 1
def LookLeft():
upward_spike_ch3 = any(
a > 880 for a in TempCH3[(len(TempCH3) - 5):(len(TempCH3) - 1)])
downward_spike_ch2 = any(
b < 830 for b in TempCH2[(len(TempCH2) - 5):(len(TempCH2) - 1)])
within_range_ch1 = any(
(740 > c or c > 920)
for c in TempCH1[(len(TempCH1) - 30):(len(TempCH1) - 3)])
if downward_spike_ch2 and upward_spike_ch3 and not within_range_ch1:
upward_spike_ch2 = any(d > 870
for d in TempCH2[(len(TempCH2) -
30):(len(TempCH2) - 3)])
downward_spike_ch3 = any(e < 820
for e in TempCH3[(len(TempCH3) -
30):(len(TempCH3) - 3)])
downward_spike_ch4 = any(f < 830
for f in TempCH4[(len(TempCH4) -
30):(len(TempCH3) - 3)])
if downward_spike_ch3 and upward_spike_ch2 and downward_spike_ch4:
print("look Left")
print("_____")
return True
return False
def LookRight():
downward_spike_ch3 = any(
a < 810 for a in TempCH3[(len(TempCH3) - 5):(len(TempCH3) - 1)])
downward_spike_ch4 = any(
b < 810 for b in TempCH4[(len(TempCH4) - 5):(len(TempCH4) - 1)])
within_range_ch1 = any(
(780 > c or c > 880)
for c in TempCH1[(len(TempCH1) - 30):(len(TempCH1) - 3)])
if downward_spike_ch3 and downward_spike_ch4 and within_range_ch1:
upward_spike_ch3 = any(d > 870
for d in TempCH3[(len(TempCH3) -
30):(len(TempCH3) - 3)])
downward_spike_ch2 = any(
(740 < e < 830)
for e in TempCH2[(len(TempCH2) - 30):(len(TempCH2) - 3)])
if upward_spike_ch3 and downward_spike_ch2:
print("look Right")
return True
return False
"""
def blink(unused_addr, args, ch5):
if ch5 > 0.2:
print("Blinked rigorously")
return True
return False
"""
def jawClench(unused_addr, args, ch6):
global is_jaw_clench
if ch6 > 0.2:
print("clench")
is_jaw_clench = True
return True
is_jaw_clench = False
return False
# the eeg_handler function imports the OSC values with a frequence of
# 256 readings per 1 second (256/1sec = every 3.90625 milliseconds)
def eeg_handler(unused_addr, args, ch1, ch2, ch3, ch4):
counter.calls += 1 # calling the counter function
if counter.calls > 10:
# print("EEG (uV) per channel: ", ch1, ch2, ch3, ch4)
# print("counter works!!", counter.calls)
TempCH1.append(ch1)
TempCH2.append(ch2)
TempCH3.append(ch3)
TempCH4.append(ch4)
LookLeft()
LookRight()
counter.calls = 0 # resetting the counter so that it counts back to 10 every time
counter.calls = 0
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=
1000, # make sure you change the port every time you wanna run the code
# for example next one would be 5050 :)
help="The port to listen on")
parser.add_argument("--serial", default="", help="Arduino serial port")
args = parser.parse_args()
dispatcher.Dispatcher()
dispatcher.Dispatcher().map("/debug", print)
dispatcher.Dispatcher().map("/muse/notch_filtered_eeg", eeg_handler, "EEG")
dispatcher.Dispatcher().map("/muse/elements/jaw_clench", jawClench, "EEG")
######################################################################### dispatcher.map("/muse/elements/blink", blink, "EEG")
server = osc_server.ThreadingOSCUDPServer((args.ip, args.port), dispatcher)
print("Serving on {}".format(server.server_address))
server.serve_forever()
def interaction_loop():
"""Interaction loop for the box, reads serial,
makes predictions, outputs servo and sound."""
userloc = np.random.rand() # Fake data
if userloc is not None:
if args.verbose:
print("Input:", userloc)
osc_predictor.send_message(INTERFACE_MESSAGE_ADDRESS, userloc)
osc_synth.send_message(INTERFACE_MESSAGE_ADDRESS, userloc)
# Set up OSC client and server
osc_predictor = udp_client.SimpleUDPClient(args.predictorip,
args.predictorport)
osc_synth = udp_client.SimpleUDPClient(args.synthip, args.synthport)
disp = dispatcher.Dispatcher()
disp.map(PREDICTION_MESSAGE_ADDRESS, handle_prediction_message)
server = osc_server.ThreadingOSCUDPServer((args.serverip, args.serverport),
disp)
server_thread = Thread(target=server.serve_forever,
name="server_thread",
daemon=True)
print("Interface server started.")
print("Serving on {}".format(server.server_address))
thread_running = False
print("starting up.")
if args.verbose:
print("Verbose mode on.")
def start(self, clients):
"""
Start OSC server to receive messages for all mapped functions regarding the provided
clients. In the current implementation running the OSC server blocks further application
execution, , keeping the application alive until the server is released.
Parameters
----------
clients : list of SubProcess
clients that receive a function mapping (see implementation for individual functions)
so they will be remote controllable
"""
def add_mapping(command, function_name, is_reversible=True):
"""
Add mapping from an OSC target to a function. The function will be invoked with all
additionally provided parameters as soon as the matching OSC command is received.
Parameters
----------
command : str
OSC target command which will be used in combination with the client name to invoke
the mapped function
function_name : str
name of the clients function that will be invoked later
is_reversible : bool, optional
if OSC target will be mapped twice, so the order of the command and the client name
does not matter
"""
# check if client has the named function
if not (hasattr(client, function_name)
and callable(getattr(client, function_name))):
return
# add mapping
dispatch.map(
f"{client_name}/{command}",
OscRemote.handle_function,
client,
function_name,
self._logger,
)
if is_reversible:
dispatch.map(
f"{command}/{client_name}",
OscRemote.handle_function,
client,
function_name,
self._logger,
)
# generate mapping for all clients
dispatch = dispatcher.Dispatcher()
for client in clients:
if not client:
continue
# prepare simplified client name as OSC target
client_name = tools.transform_into_osc_target(client.name)
# see `JackClient` if not otherwise specified
add_mapping("mute", "set_output_mute")
add_mapping("volume", "set_output_volume_db")
add_mapping("volume_relative", "set_output_volume_relative_db")
add_mapping("volume_port_relative",
"set_output_volume_port_relative_db")
add_mapping("delay", "set_input_delay_ms")
add_mapping("crossfade",
"set_client_crossfade") # see `JackRenderer`
add_mapping("passthrough",
"set_client_passthrough") # see `JackRenderer`
add_mapping("order", "set_renderer_sh_order") # see `JackRenderer`
add_mapping("zero", "set_zero_position") # see `HeadTracker`
add_mapping("azimuth", "set_azimuth_position") # see `HeadTracker`
add_mapping("stop", "stop") # see `JackPlayer`
add_mapping("play", "play") # see `JackPlayer`
# TODO: implement `JackPlayer` restarting if playback was finished
# player = _setup_player(
# pre_renderer
# if (pre_renderer and pre_renderer.is_alive())
# else renderer,
# player,
# )
# add mapping to terminate
dispatch.map("/quit", OscRemote.handle_terminate, self)
dispatch.map("/exit", OscRemote.handle_terminate, self)
# TODO: This line fails in case multiple ReTiSAR instances are run, due an OSC server
# already running (the same port being already bound). In the second instance, either try
# to reference the already existing OSC server or create a new server with an available
# port number!?
# start OSC server
self._server = osc_server.ThreadingOSCUDPServer(
("127.0.0.1", self._port), dispatch)
log_str = f"listening to OSC messages at {self._server.server_address} ..."
self._logger.info(log_str) if self._logger else print(log_str)
# run OSC server and block further execution, keeping the application alive until the
# server is released
self._server.serve_forever()
def print_volume_handler(unused_addr, args, volume):
print("[{0}] ~ {1}".format(args[0], volume))
def print_compute_handler(unused_addr, args, volume):
try:
print("[{0}] ~ {1}".format(args[0], args[1](volume)))
except ValueError:
pass
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--ip",
default="127.0.0.1",
help="The ip to listen on")
parser.add_argument("--port",
type=float,
default=12000,
help="The port to listen on")
args = parser.parse_args()
dispatcher = dispatcher.Dispatcher()
dispatcher.map("/Scratch_detected", print)
dispatcher.map("/volume", print_volume_handler, "Volume")
dispatcher.map("/logvolume", print_compute_handler, "Log volume", math.log)
server = osc_server.ThreadingOSCUDPServer((args.ip, args.port), dispatcher)
print("Serving on {}".format(server.server_address))
server.serve_forever()
def oscserver():
osc_disp = dispatcher.Dispatcher()
# osc_disp.map(".*", osc_handler)
osc_disp.map(".*", osc_Ldata)
server = osc_server.ThreadingOSCUDPServer(("0.0.0.0", 8888), osc_disp)
server.serve_forever()
