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