def main():
global api, lastIndex, server
api = cdll.LoadLibrary("libDobotDll.so")
lastIndex = -1
state = dType.ConnectDobot(api, "", 115200)[0]
if state == dType.DobotConnect.DobotConnect_NoError:
dp = dispatcher.Dispatcher()
dp.map("/dobot/gripper/open", dobot_gripper_open)
dp.map("/dobot/gripper/close", dobot_gripper_close)
dp.map("/dobot/gripper/off", dobot_gripper_off)
dp.map("/dobot/shutdown", dobot_shutdown)
dp.map("/dobot/home", dobot_home)
dp.map("/dobot/status", dobot_status)
dp.map("/dobot/ptp", dobot_ptp)
dp.map("/dobot/alarm/clear", clear_alarm)
# These are for wekinator HandGestures project
dp.map("/wek/dobot/drag", wek_dobot_drag_start)
dp.map("/wek/dobot/stop", wek_dobot_drag_stop)
dp.map("/wek/dobot/open", wek_dobot_gripper_open)
dp.map("/wek/dobot/close", wek_dobot_gripper_close)
# For wekinator HandMapping project
dp1 = dispatcher.Dispatcher()
dp1.map("/wek/dobot/pos", weki_dobot_position)
# Clean Command Queued
dType.SetCmdTimeout(api, 1000)
dType.ClearAllAlarmsState(api)
dType.SetQueuedCmdClear(api)
dType.SetQueuedCmdStopExec(api)
dType.SetQueuedCmdStartExec(api)
loop = asyncio.get_event_loop()
server = osc_server.AsyncIOOSCUDPServer((SERVER_IP, SERVER_PORT), dp, loop)
server1 = osc_server.AsyncIOOSCUDPServer((SERVER_IP, SERVER_PORT_POS), dp1, loop)
print("\033[2J\033[H")
print("---------------------------------------------------------")
print(" Dobot OSC controller\n")
print(" Waiting gestures on", SERVER_IP, SERVER_PORT)
print(" Waiting positions on", SERVER_IP, SERVER_PORT_POS)
print("---------------------------------------------------------")
server.serve()
server1.serve()
loop.run_forever()
# Stop to Execute Command Queued
dType.SetQueuedCmdStopExec(api)
# Disconnect Dobot
dType.DisconnectDobot(api)
else:
print("\nFailed connect to Dobot: " + CON_STR[state])
print("May need to run:\nsudo chmod 777 /dev/ttyUSB0")
async def init_main():
"""
https://python-osc.readthedocs.io/en/latest/server.html#async-server
https://web.archive.org/web/20170809181820/http://developer.choosemuse.com/research-tools-example/grabbing-data-from-museio-a-few-simple-examples-of-muse-osc-servers
https://addshore.com/2018/06/python3-using-some-shared-state-in-2-async-methods/
:return:
"""
# with the connection made and inital state set, can start the main loops.
# https://python-osc.readthedocs.io/en/latest/dispatcher.html
# https://python-osc.readthedocs.io/en/latest/server.html#async-server
event_loop_local = asyncio.get_event_loop()
dispatcher = Dispatcher()
dispatcher.map("/muse/elements/experimental/concentration",
concentration_handler)
# creates an OSC server that's Async.
server = osc_server.AsyncIOOSCUDPServer((IP, OSC_PORT), dispatcher,
event_loop_local)
transport, protocol = await server.create_serve_endpoint(
) # Create datagram endpoint and start serving
print("OSC server running.")
await dummy_loop()
transport.close() # Clean up server endpoint
def start(self, port):
ip = "127.0.0.1"
dispat = dispatcher.Dispatcher()
dispat.map("/knob", self.handle_knob)
self.server = osc_server.AsyncIOOSCUDPServer((ip, port), dispat, self.loop)
self.serve(self.server, ip, port)
threading.Thread(target=self.loop.run_forever).start()
async def sendToBoard():
device = await getBLEDevice()
print(device)
server = osc_server.AsyncIOOSCUDPServer(("127.0.0.1", 57121), dispatch, asyncio.get_event_loop())
transport, protocol = await server.create_serve_endpoint()
def exitHandler():
transport.close()
atexit.register(exitHandler)
async with BleakClient(device) as client:
# print(client.get_services)
print("Awaiting supercollider commands...")
# await client.start_notify(notify_characteristic, callback)
isConnected = client.is_connected
while isConnected:
for i in range(num_servos):
if (client.is_connected):
if (prevValues[i] != values[i]):
print("servo" + str(i) + " value: " + str(bytes_to_int(values[i])))
await client.write_gatt_char(write_characteristics[i], values[i], False)
prevValues[i] = values[i]
await asyncio.sleep(0.01)
else:
isConnected = False
print("ServoCallback disconnected, reestablishing connection")
transport.close()
atexit.unregister(exitHandler)
async def init_main():
# Setup and Start OSC Server
server = osc_server.AsyncIOOSCUDPServer((PI_IP, SERVER_PORT), dispatcher,
asyncio.get_event_loop())
transport, protocol = await server.create_serve_endpoint()
await loop() # Enter main loop of program
transport.close() # Clean up serve endpoint
def startServer(self):
#self.loop = asyncio.get_event_loop()
self.server = osc_server.AsyncIOOSCUDPServer((self.ip, self.port),
dispatcher, loop)
self.server.serve()
#self.servThread = ServerThread()
#self.servThread.start()
#self.loop.run_forever()
#asyncio.set_event_loop(loop)
with loop:
loop.run_forever()
async def init():
server = osc_server.AsyncIOOSCUDPServer(
("0.0.0.0", args.receive_port), dispatcher, asyncio.get_event_loop())
transport, protocol = await server.create_serve_endpoint(
) # Create datagram endpoint and start serving
# Indicates that server is ready.
print("Orbiter server ready.")
client.send_message("/xeno/orbiter/begin", [])
await loop() # Enter main loop of program
transport.close() # Clean up serve endpoint
def __init__(self, handler, port=5005, ip="0.0.0.0"):
self.addr = (ip, port)
self.dispatcher = dispatcher.Dispatcher()
# for k, v in handlers.items():
# if k[0] == '/':
# addr = k
# else:
# addr = '/' + k
# self.dispatcher.map(addr, v)
self.dispatcher.set_default_handler(handler)
loop = get_event_loop()
self.server = osc_server.AsyncIOOSCUDPServer(self.addr,
self.dispatcher,
loop)
self.server.serve()
async def start(self, future):
self.dispatcher = dispatcher.Dispatcher()
self.dispatcher.map("/speech", self.speech_handler)
self.dispatcher.map("/mid-speech", self.speech_handler)
self.dispatcher.map("/play-finished", self.finished_handler)
self.server = osc_server.AsyncIOOSCUDPServer(
("0.0.0.0", 3954), self.dispatcher, self.loop)
print("Serving OSC on {}".format("0.0.0.0"))
transport, protocol = await self.server.create_serve_endpoint()
await future
print("Closing transport")
transport.close()
async def main():
parser = argparse.ArgumentParser()
parser.add_argument("--ip", default="0.0.0.0", help="The ip to listen on")
parser.add_argument("--port", type=int, default=37339, help="The port to listen on")
args = parser.parse_args()
plt.ion()
# plt.show()
dispatcher = Dispatcher()
dispatcher.map("/pulse", pulse_handler)
loop = asyncio.get_event_loop()
server = osc_server.AsyncIOOSCUDPServer( (args.ip, args.port), dispatcher, loop)
# server = osc_server.ThreadingOSCUDPServer( (args.ip, args.port), dispatcher)
# server.serve()
transport, protocol = await server.create_serve_endpoint()
await asyncio.sleep(10**30)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--ip", default="0.0.0.0", help="The ip to listen on")
parser.add_argument("--port",
type=int,
default=37337,
help="The port to listen on")
args = parser.parse_args()
loop = asyncio.get_event_loop()
asyncio. async (looper(), loop=loop)
# asyncio.ensure_future(looper(), loop=loop)
dsp = dispatcher.Dispatcher()
# dsp.map("/pulse", print)
dsp.map("/pulse", osc_handler)
server = osc_server.AsyncIOOSCUDPServer((args.ip, args.port), dsp, loop)
server.serve()
loop.run_forever()
async def init_main():
"""
https://python-osc.readthedocs.io/en/latest/server.html#async-server
https://web.archive.org/web/20170809181820/http://developer.choosemuse.com/research-tools-example/grabbing-data-from-museio-a-few-simple-examples-of-muse-osc-servers
https://addshore.com/2018/06/python3-using-some-shared-state-in-2-async-methods/
:return:
"""
# making a super ghetto state to share b/w the two async contexts
# based on solution in https://addshore.com/2018/06/python3-using-some-shared-state-in-2-async-methods/
async_state = type('', (), {})()
async_state.focused = False
async_state.mentally_focused = False
async_state.wearing = False
async_state.hat_running = False
async_state.user_override = False
async_state.last_reading = datetime.datetime.now()
async_state.attention_lvl = 0.0
# Prepare the serial port
# make_connection
ser = serial.Serial(ARD_PORT, baudrate=9600, timeout=1)
connection_made = make_connection(ser, async_state)
if connection_made:
# with the connection made and inital state set, can start the main loops.
# https://python-osc.readthedocs.io/en/latest/dispatcher.html
# https://python-osc.readthedocs.io/en/latest/server.html#async-server
event_loop_local = asyncio.get_event_loop()
dispatcher = Dispatcher()
dispatcher.map("/muse/elements/experimental/concentration", concentration_handler, async_state)
# creates an OSC server that's Async.
server = osc_server.AsyncIOOSCUDPServer((IP, OSC_PORT), dispatcher, event_loop_local)
transport, protocol = await server.create_serve_endpoint() # Create datagram endpoint and start serving
await loop(ser, async_state) # Enter main loop of program.
transport.close() # Clean up serve endpoint
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=int,
default=37337,
help="The port to listen on")
args = parser.parse_args()
dispatcher = dispatcher.Dispatcher()
dispatcher.map("/pulse", print)
dispatcher.map("/volume", print_volume_handler, "Volume")
dispatcher.map("/logvolume", print_compute_handler, "Log volume", math.log)
import asyncio
loop = asyncio.get_event_loop()
server = osc_server.AsyncIOOSCUDPServer((args.ip, args.port), dispatcher,
loop)
# server = osc_server.ThreadingOSCUDPServer( (args.ip, args.port), dispatcher)
# print("Serving on {}".format(server.server_address))
server.serve()
# server.serve_forever()
loop.run_forever()
# server.serve_forever()
pro = subprocess.Popen(command_line, shell=True)
print("ran")
def handlerKill(*msg):
print("kill", msg[1])
pro.terminate()
print("killed")
print("Now running...")
dispatcher = dispatcher.Dispatcher()
dispatcher.map("/run", handlerRun)
dispatcher.map("/kill", handlerKill)
loop = asyncio.get_event_loop()
server = osc_server.AsyncIOOSCUDPServer(server_address, dispatcher, loop)
print("aboutToServe")
server.serve()
print("nowServing")
try:
loop.run_forever()
while True:
time.sleep(1)
except KeyboardInterrupt:
pass
finally:
loop.stop()
print("\nDisconnected")
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()
