class TwoWayClient(object): def __init__(self): self.socketIO = SocketIO(host, port) def on_socket_open(*args): print("on_socket_open: ", args[0]) self.socketIO.emit('agent_alive', { 'task_group_id': 'test_group', 'agent_id': '[World]' }) def on_disconnect(*args): print("Server disconnected", args[0]) def on_new_messgae(*args): print(args[0]) self.socketIO.on('socket_open', on_socket_open) self.socketIO.on('disconnect', on_disconnect) # This works self.socketIO.on('new_message', on_new_messgae) self.receive_events_thread = Thread(target=self._receive_events_thread) self.receive_events_thread.daemon = True self.receive_events_thread.start() while True: some_input = input("Hit ENTER to send message:") self.socketIO.emit('new_message', { 'task_group_id': 'test_group', 'receiver_agent_id': 'Worker' }) def _receive_events_thread(self): self.socketIO.wait()
class TwoWayClient(object): def __init__(self): self.socketIO = SocketIO(host, port) def on_connect(): print("Server connected") def on_disconnect(*args): print("Server disconnected") def on_reconnect(): print("Server reconnected") def on_time(*args): print(args[0]) self.socketIO.on('connect', on_connect) # This is not working self.socketIO.on('disconnect', on_disconnect) # This works self.socketIO.on('reconnect', on_reconnect) # This is not working self.socketIO.on('time', on_time) self.receive_events_thread = Thread(target=self._receive_events_thread) self.receive_events_thread.daemon = True self.receive_events_thread.start() while True: some_input = input("Please input: ") self.socketIO.emit('custom', some_input) def _receive_events_thread(self): self.socketIO.wait()
def transmit(): while True: time.sleep(1) # If there's something to transmit, make a connection and sent it out if (len(queue) > 0): # Attempt to connect, transmit all in queue if success print("Attempting connection...") try: sio = SocketIO(sys.argv[1], verify=False, wait_for_connection=False, cert=('client.crt', 'client.key')) sio.wait(seconds=1) print("Connected") #sio.on('disconnect', on_disconnect) sio.on('response', on_response) queue2 = queue[:] # Copy the list to resolve a bug in how the for loop works for id in queue2: print("Transmitting " + str(id)) sio.emit('attend', {'ID': id}) sio.wait(seconds=1) #sio.disconnect() except ConnectionError: print('Server unreachable. Retrying shortly')
def __init__( self, node, url, channel="", field="", sendinit=None, json=False, wrap=False, interval=1, ): o = urlparse(url) socketIO = SIO(o.scheme + "://" + o.netloc, o.port) if sendinit: socketIO.emit(sendinit) def _sio(data, field=field, json=json, wrap=wrap, interval=interval): if json: data = JSON.loads(data) if field: data = data[field] if wrap: data = [data] socketIO.emit(data) socketIO.wait(seconds=interval) return data super().__init__(foo=_sio, name="SocketIO", inputs=1) node >> self
def AsyncSocketIO(url, channel='', field='', sendinit=None, json=False, wrap=False, interval=1): o = urlparse(url) socketIO = SIO(o.scheme + '://' + o.netloc, o.port) if sendinit: socketIO.emit(sendinit) async def _sio(url, channel, field='', json=False, wrap=False, interval=1): while True: _data = [] socketIO.on(channel, lambda data: _data.append(data)) socketIO.wait(seconds=interval) for msg in _data: # FIXME clear _data if json: msg = json.loads(msg) if field: msg = msg[field] if wrap: msg = [msg] yield msg return _wrap(_sio, dict(url=url, channel=channel, field=field, json=json, wrap=wrap, interval=interval), name='SocketIO')
class SIOHelper(GenBase): def __init__(self, psp, url, send=None, channel='', records=False): self.validate(url, 'sio') self.__type = 'sio' self.url = url.replace('sio://', '') self.send = send self.channel = channel self.records = records self._data = [] o = urlparse(self.url) self.socketIO = SocketIO(o.scheme + '://' + o.netloc, o.port) self.socketIO.on(self.channel, lambda data: self._data.append(data)) self.url = o.path super(SIOHelper, self).__init__(psp) async def getData(self): if self.send: self.socketIO.emit(*self.send) t = threading.Thread(target=self.socketIO.wait) t.start() while 1: if self._data: c = 0 for item in self._data: c += 1 yield item self._data = self._data[:c] else: await asyncio.sleep(1)
def start_process(self): """main process start from here. """ self.jwt_token = self.get_auth_code() # print("jwt token is: {}\n".format(self.jwt_token)) params1 = self.util_obj.socket_connection['params1'] params1["token"] = self.jwt_token # socketIO = SocketIO('192.168.0.60', 8080, params=params1) socketIO = SocketIO(self.util_obj.socket_connection['ip'], self.util_obj.socket_connection['port'], params=params1) socketIO.emit('server.version', {}) socketIO.on('server.version', self.get_server_version) pLocationNamespace = socketIO.define(self.LocationNamespace, '/location') filterData = self.util_obj.filterData pLocationNamespace.emit('location:monitor:send:filter', filterData) pLocationNamespace.on('location:monitor:receive', self.on_aaa_response) try: socketIO.wait() # engineSocket.wait() except ConnectionError as ex: print("got connection error %s" % ex)
class TwoWayClient(object): def __init__(self): self.socketIO = SocketIO(host, port) def on_socket_open(*args): print("on_socket_open: ", args[0]) self.socketIO.emit('agent_alive', {'task_group_id': 'test_group', 'agent_id': '[World]'}) def on_disconnect(*args): print("Server disconnected", args[0]) def on_new_messgae(*args): print(args[0]) self.socketIO.on('socket_open', on_socket_open) self.socketIO.on('disconnect', on_disconnect) # This works self.socketIO.on('new_message', on_new_messgae) self.receive_events_thread = Thread(target=self._receive_events_thread) self.receive_events_thread.daemon = True self.receive_events_thread.start() while True: some_input = input("Hit ENTER to send message:") self.socketIO.emit('new_message', {'task_group_id': 'test_group', 'receiver_agent_id': 'Worker'}) def _receive_events_thread(self): self.socketIO.wait()
class socket: def __init__(self, id): self.id = id self.socketIO = None self.token = None self.missatge_doctor = None self.esperar = True self.createsocket(id) def desconectar(self, id): self.socketIO.emit('disconnect', {'id': id}) def createsocket(self, id): print id self.socketIO = SocketIO('https://ptin2018.herokuapp.com', params={"id": id}) print "Socket creado" self.socketIO.wait(seconds=3) def receive_general(self, *args): print "Recibido" print args[0] self.token = args[0] def response(self, *args): print "response" print args def response_doctor(self, *args): print "response doctor" print args self.missatge_doctor = args self.esperar = False def envia_confirmacio(self): self.socketIO.wait(seconds=1) self.socketIO.emit('generalAuthentication', { 'requester': self.id, 'token': self.token }) self.socketIO.on("generalResponse", self.response) self.socketIO.wait(seconds=1) def esperar_doctor(self): self.socketIO.on('pacientLocation', self.response_doctor) while self.esperar: self.socketIO.wait(seconds=3) self.esperar = True return self.missatge_doctor def envia_general(self, lat, lon): self.socketIO.emit('alarm', { 'type': 2, 'latitude': lat, 'longitude': lon }) print self.socketIO self.socketIO.on("generalAuthentication", self.receive_general) self.socketIO.wait(seconds=1)
class SocketIoHandler: SOCKET_IO_URL = 'http://localhost' SOCKET_IO_PORT = 3000 def __init__(self): self.socketIO = SocketIO(self.SOCKET_IO_URL, self.SOCKET_IO_PORT) def publish(self, topic, message): self.socketIO.emit(topic, message)
class FrontendConnection: def __init__(self, host, port): self.host = host self.port = port self.socket = SocketIO(host, port, wait_for_connection=False) #self.receiveStatus() def on_posicion_response(self, *args): # print('Posicion enviada al frontend:', args[0], args[1]) pass def on_send_status_response(self, *args): # print('Estado enviado al frontend:', args[0], args[1]) pass def on_reconocimiento_response(self, response): if response == "ok": # print('Reconocimiento ok') pass else: # print("El servidor no te reconoce") exit() def on_change_attributtes_response(self, *args): # print('Cambiados atributos:', args[0], args[1]) pass def send(self, topic, data, callback): self.socket.emit(topic, data, callback) def recognizeAgent(self, agent_info): self.send("agent/recognition", agent_info, self.on_reconocimiento_response) def repositionAgent(self, agent_id, posicion): self.send("agent/position", { "position": posicion, "agent_id": agent_id }, self.on_posicion_response) def sendStatus(self, agent_id, status): self.send("agent/status", { "status": status, "agent_id": agent_id }, self.on_send_status_response) def changeAttributtes(self, agent_id, attributtes): self.send("agent/attributes", { "agent_id": agent_id, "attributes": attributtes }, self.on_change_attributtes_response) def wait(self, segs): self.socket.wait(segs)
def envoyerValeurDirect(jsonDonnee): global jsonValeur jsonValeur = jsonDonnee print(jsonValeur) connection = SocketIO('vps202433.vps.ovh.ca', 8080, LoggingNamespace) #connection = SocketIO('vps202845.vps.ovh.ca', 8080, LoggingNamespace) connection.on('salutation', lors_connection) connection.on('donnee_recu', on_send) connection.emit('emission-donnees-bouee', jsonValeur) #envoie du json print("sent") connection.disconnect()
def envoyerDonneesAuServeur(): global data donneeNonFormatee = data.decode() #donneeFormatee = json.dumps(donneeNonFormatee) print(donneeNonFormatee) connection = SocketIO('vps202433.vps.ovh.ca', 8080, LoggingNamespace) #connection = SocketIO('vps202845.vps.ovh.ca', 8080, LoggingNamespace) connection.on('salutation', lors_connection) connection.on('donnee_recu',on_send) connection.emit('deverser-donnees-bouee', donneeNonFormatee) #envoie du json print("sent") connection.disconnect()
def connect_socket_io(dtable_server_url, dtable_uuid, jwt_token): host, port = parse_dtable_server_url(dtable_server_url) params = {'dtable_uuid': dtable_uuid} socketIO = SocketIO(host, port, params=params) socketIO.on('connect', on_connect) socketIO.on('reconnect', on_reconnect) socketIO.on('disconnect', on_disconnect) socketIO.emit(JOIN_ROOM, dtable_uuid, jwt_token) print('[ Seatable Socket IO Connected]') socketIO.on(UPDATE_DTABLE, on_update_dtable) socketIO.on(NEW_NOTIFICATION, on_new_notification) return socketIO
def SocketIO(node, url, channel='', field='', sendinit=None, json=False, wrap=False, interval=1): '''Connect to socketIO server and send updates Args: node (Node): input stream url (str): url to connect to channel (str): socketio channel to connect through field (str): field to index result by sendinit (list): data to send on socketio connection open json (bool): load websocket data as json wrap (bool): wrap result in a list interval (int): socketio wai interval ''' o = urlparse(url) socketIO = SIO(o.scheme + '://' + o.netloc, o.port) if sendinit: socketIO.emit(sendinit) def _sio(data, field=field, json=json, wrap=wrap, interval=interval): if json: data = JSON.loads(data) if field: data = data[field] if wrap: data = [data] socketIO.emit(data) socketIO.wait(seconds=interval) return data ret = Node(foo=_sio, name='SocketIO', inputs=1, graphvizshape=_OUTPUT_GRAPHVIZSHAPE) node >> ret return ret
def socketio( url, callback, channel="", field="", sendinit=None, json=False, wrap=False, interval=1, ): """Connect to socketIO server and pipe results through the callback Args: url (str): url to connect to callback (callable): function to call on websocket data channel (str): socketio channel to connect through field (str): field to index result by sendinit (list): data to send on socketio connection open json (bool): load websocket data as json wrap (bool): wrap result in a list interval (int): socketio wai interval """ from socketIO_client_nexus import SocketIO as SIO o = urlparse(url) socketIO = SIO(o.scheme + "://" + o.netloc, o.port) if sendinit: socketIO.emit(sendinit) while True: _data = [] socketIO.on(channel, lambda data: _data.append(data)) socketIO.wait(seconds=interval) for msg in _data: if json: msg = json.loads(msg) if field: msg = msg[field] if wrap: msg = [msg] callback(msg)
def __init__( self, url, channel="", field="", sendinit=None, json=False, wrap=False, interval=1, ): o = urlparse(url) socketIO = SIO(o.scheme + "://" + o.netloc, o.port) if sendinit: socketIO.emit(sendinit) async def _sio( url=url, channel=channel, field=field, json=json, wrap=wrap, interval=interval, ): while True: _data = [] socketIO.on(channel, lambda data: _data.append(data)) socketIO.wait(seconds=interval) for msg in _data: # FIXME clear _data if json: msg = JSON.loads(msg) if field: msg = msg[field] if wrap: msg = [msg] yield msg super().__init__(foo=_sio) self._name = "SocketIO"
def socketio(url, callback, channel='', field='', sendinit=None, json=False, wrap=False, interval=1): o = urlparse(url) socketIO = SIO(o.scheme + '://' + o.netloc, o.port) if sendinit: socketIO.emit(sendinit) while True: _data = [] socketIO.on(channel, lambda data: _data.append(data)) socketIO.wait(seconds=interval) for msg in _data: if json: msg = json.loads(msg) if field: msg = msg[field] if wrap: msg = [msg] callback(msg)
def main(): attempts = 0 while attempts < 3: try: socketIO = SocketIO(FMF_SERVER, 8080, Namespace, verify=False, wait_for_connection=False) socketIO.emit('authenticate', { "app_id": APP_ID, "device_id": DEVICE_ID }) socketIO.wait() except ConnectionError: attempts += 1 time.sleep(30) print "Can't connect to server, trying again..."
def connect(self): io = SocketIO(self.server, self.port) iron_namespace = io.define(IRONNamespace, '/iron') flash_namespace = io.define(FLASHNamespace, '/flash') mega_namespace = io.define(MEGANamespace, '/mega') io.emit('login', {'app_client_secret_id': os.environ.get('SOCKBOT_APPCLIENT_SECRET'), 'name': 'AUTOBOT'}, callback_login) #login update socketid io.wait_for_callbacks(seconds=1) #io.wait() return dict(io=io,iron_namespace=iron_namespace, flash_namespace=flash_namespace, mega_namespace=mega_namespace)
class Client(object): def __init__(self): self.socketio = SocketIO("http://twitchplaysnintendoswitch.com:8110") self.socketio.on("disableInternet", self.on_disable_internet) self.socketio.on("enableInternet", self.on_enable_internet) self.socketio.on("getInternetStatus", self.on_get_internet_status) self.socketio.on("disconnect", self.on_disconnect) self.socketio.emit("join", "proxy") self.receive_events_thread = Thread(target=self._receive_events_thread) self.receive_events_thread.daemon = True self.receive_events_thread.start() self.start = time.process_time() self.end = time.process_time() self.status = False def _receive_events_thread(self): self.socketio.wait() def on_event(self, event): #print(event) pass def on_disconnect(self): print("disconnected") os.system("killall python3") def on_disable_internet(*args): print("disabling proxy!") client.status = False sudoPassword = "******" command = "service squid stop" p = os.system("echo %s|sudo -S %s" % (sudoPassword, command)) def on_enable_internet(*args): print("enabling proxy!") client.status = True sudoPassword = "******" command = "service squid restart" p = os.system("echo %s|sudo -S %s" % (sudoPassword, command)) def on_get_internet_status(*args): print("checking status!") self.socketio.emit("internetStatus", client.status) def loop(self): self.end = time.process_time() diffInMilliSeconds = (self.end - self.start) * 1000 if (diffInMilliSeconds > 1000 * 60 * 5): self.socketio.emit("join", "proxy") self.start = time.process_time()
from socketIO_client_nexus import SocketIO import json socketIO = SocketIO('localhost', 3000) def welcome(): print('welcome received') socketIO.on('welcome', welcome) message = { 'name': 'hoang', 'ids': ['54fjadb70f9756', '39f1ax451f6567'], 'relation': 'nguoi la', 'date': '06/05/2018' } socketIO.emit('client-event', json.loads(json.dumps(message))) socketIO.wait()
pulse_duration = pulse_end - pulse_start distance = round(17150 * pulse_duration, 2) return distance # get_measurement() # while (True): # distance = get_measurement() # print('Distance is:', distance) # time.sleep(.05) thread = Thread(target=continuous_loop) thread.setDaemon(True) thread.start() socket.on('connect', on_connect) socket.on('disconnect', on_disconnect) socket.on('reconnect', on_reconnect) socket.on('command', on_command) socket.on('socket_id', on_socket_id) socket.emit('connect_rover') socket.wait()
class NodeProvider(object): def __init__(self, hostname, port, username, password, cb1, cb2): self.hostname = hostname self.port = port self.username = username self.password = password self.auth_token = None self.socketIO = None self.next_msg_id = 0 self.msg_id_to_callback = {} self._after_connect = cb1 self._after_error = cb2 self.closed = False def login(self): login_url = self.hostname + ':' + str(self.port) + '/login' values = { 'username': self.username, 'password': self.password } data = urllib.parse.urlencode(values).encode('ascii') request = urllib.request.Request(login_url, data) print('Connecting to ' + login_url) attempts = 0 attempt_limit = 4 while True: try: with urllib.request.urlopen(request,timeout=5) as response: content = response.read() content_obj = json.loads(content.decode('ascii')) if 'token' in content_obj: self.auth_token = content_obj['token'] self.configure_socket() break else: raise Exception('Authentication failed no token in response') except urllib.error.URLError as e: attempts += 1 if attempts == attempt_limit: print('Informing caller of error') self.after_error(e) break print('Sleeping!') print(e) time.sleep(10) except Exception as e: print(e) self.after_error(e) break def configure_socket(self): if self.hostname.startswith('https'): needs_sslv4 = True else: needs_sslv4 = False print('Creating WebSocket connection') self.socketIO = SocketIO(self.hostname, self.port, LoggingNamespace,False,transports=['xhr-polling'],needs_sslv4=needs_sslv4) time.sleep(3) self.socketIO.on('authenticated', self._socket_authenticated) self.socketIO.emit('authenticate', {'token': self.auth_token}) self.socketIO.on('__response__', self._process_response) self.socketIO.on('reconnect', self._socket_authenticated) self.socketIO.on('connect', self._socket_authenticated) self.socketIO.on('disconnect', self._disconnected) self.socketIO.on('open', self._socket_authenticated) try: self.socketIO.wait() except Exception as e: raise e self.after_error(e) def _disconnected(self): if self.closed: return print('Disconnected') self.closed = True def _process_response(self, data): if 'bioinfJobId' in data: msg_id = data['bioinfJobId'] if msg_id in self.msg_id_to_callback: error = None json = None if 'error' in data: error = data['error'] elif 'json' in data and 'error' in data['json']: error = data['json']['error'] else: error = None if 'json' in data: json = data['json'] self.msg_id_to_callback[msg_id](error, json) self.msg_id_to_callback.pop(msg_id) #Important - otherwise we leak file descriptors # TODO: Check that this still closes file handles on Linux if hasattr(data, 'close'): data.close() else: print('Warning message not found ' + msg_id) def handle_fetch(self, error, data): print(data) def _authenticate_socket(self): print('Authenticating') self.socketIO.emit('authenticate', {token: self.auth_token}) def _socket_authenticated(self): self.after_connect() def after_connect(self): self._after_connect() def set_after_connect(self, cb): self._after_connect = cb def after_error(self, error): self._after_error(error) def get_by_named_query(self, query_id, data, cb): json = {"queryId": query_id, 'parameters': self._serialise(data)} def _cb(error, json): cb(error, data['objects']) self.run_query('_remote_provider_._data_request_objects_namedquery', json, cb) def upload_file(self, filename, cb): f = open(filename, 'rb') chunk_size = 1024 * 60000 scope_obj = {'file_identifier': None} def upload_chunk(): byte_buf = f.read(chunk_size) eof = len(byte_buf) != chunk_size def _cb(error, upload_id): if error is not None: f.close() cb(error, None) scope_obj['file_identifier'] = upload_id if not eof: upload_chunk() else: f.close() cb(None, scope_obj['file_identifier']) self.upload_bytes_as_file(byte_buf, scope_obj['file_identifier'], _cb) upload_chunk() def upload_bytes_as_file(self, contents, file_identifer, cb): contents_b64 = base64.b64encode(contents).decode('ascii') json = {'contents': contents_b64, 'file_identifier': file_identifer} def _cb(error, json): cb(error, json['upload_id']) self.run_query('_remote_provider_._data_request_upload_file', json, _cb) def _convert_dictionaries(self, obj): for key in obj.keys(): if type(obj[key]) == dict: obj[key] = self._convert_dictionaries(obj[key]) return _hx_AnonObject(obj) def _serialise(self, params): a = self._convert_dictionaries(params) param_str = haxe_Serializer.run([a]) return param_str def run_query(self, api_command, json, cb): msg_id = self.increment_next_id() json['msgId'] = msg_id self.register_callback(msg_id, cb) self.socketIO.emit(api_command, json) def register_callback(self, msg_id, cb): self.msg_id_to_callback[msg_id] = cb def increment_next_id(self): i = self.next_msg_id self.next_msg_id += 1 return str(i)
def on_disconnect(): print('disconnect') def on_reconnect(): print('reconnect') def on_say(words): print('on_say', words) call(['espeak "' + words + '"'], shell=True) def on_play(file): print('on_play', file) pygame.mixer.music.load("%s/%s" % (sfx_path, file)) pygame.mixer.music.play() socketIO = SocketIO(config.websocket["url"], config.websocket["port"], LoggingNamespace) socketIO.on('connect', on_connect) socketIO.on('disconnect', on_disconnect) socketIO.on('reconnect', on_reconnect) # Listen socketIO.on('say', on_say) socketIO.on('play', on_play) socketIO.emit('jambot') socketIO.wait()
import json import time import random import math sock_client = SocketIO('localhost', 3000, LoggingNamespace) i = 0 while True: arr = [10,20,30,40,50] x_1, x_2, x_3 = arr[i], arr[4-i], 50 y_1, y_2, y_3 = arr[i], arr[4-i], 30 hand1_x_1, hand1_y_1 = x_1 - 5, y_1 + 5 hand2_x_1, hand2_y_1 = x_1 + 30, y_1 + 5 hand1_x_2, hand1_y_2 = x_2 - 5, y_2 + 5 hand2_x_2, hand2_y_2 = x_2 + 30, y_2 + 5 sock_client.emit('messages', json.dumps([ {'person_id': 'Billy', 'x': x_1, 'y': y_1, 'hand1_x': hand1_x_1, 'hand1_y': hand1_y_1, 'hand2_x': hand2_x_1, 'hand2_y': hand2_y_1}, {'person_id': 'Tommy', 'x': x_2, 'y': y_2, 'hand1_x': hand1_x_2, 'hand1_y': hand1_y_2, 'hand2_x': hand2_x_2, 'hand2_y': hand2_y_2}, {'person_id': 'Eric', 'x': x_3, 'y': y_3} ])) i += 1 if i > 4: i = 0 time.sleep(1)
def on_connect(self): print('[Connected]') def on_reconnect(self): print('[Reconnected]') def on_disconnect(self): print('[Disconnected]') socketIO = SocketIO(WS_HOST, WS_PORT, LoggingNamespace) socketIO.on('chiotte_response', on_chiotte_response) distance_in_mm_old = 0 while running: distance_in_mm = tof.get_distance() if (distance_in_mm != distance_in_mm_old and 100 <= distance_in_mm <= 230): distance_in_mm_old = distance_in_mm data = json.dumps({ "id": ID, "gender": POOP_LOCATION, "pq": distance_in_mm }) print(data) socketIO.emit('chiotte', data) time.sleep(0.5)
def on_Response_C(*args): print('I got a reponse from server for event_C', args) def FuncA(): print('FuncA: Now I got a message from server.') socketIO = SocketIO('localhost', 3000, LoggingNamespace) socketIO.on('connect', on_connect) socketIO.on('disconnect', on_disconnect) socketIO.on('reconnect', on_reconnect) socketIO.on('event_A', FuncA) # Listen socketIO.on('Response_B', on_Response_B) socketIO.emit('event_B') socketIO.emit('event_B') socketIO.wait(seconds=1) # Stop listening socketIO.off('Response_B') socketIO.emit('event_B') socketIO.wait(seconds=1) # Listen only once socketIO.once('Response_C', on_Response_C) socketIO.emit('event_C') # Activate aaa_response socketIO.emit('event_C') # Ignore socketIO.wait(seconds=1)
(0, 255, 0), int(5 * bp.c)) # last_num_people = len(kpts[:, 0, 0]) package = list() for i in range(len(heads)): per_dict = dict() per_dict['person_id'] = heads[i].p_id per_dict['x'] = 100 - (100 * (heads[i].x_buf[-1] / 1280)) per_dict['y'] = 50 * (heads[i].y_buf[-1] / 720) + 10 if left_hands[i].x_buf[-1] > 0: per_dict['hand1_x'] = 110 - (120 * (left_hands[i].x_buf[-1] / 1280)) per_dict['hand1_y'] = 100 * (left_hands[i].y_buf[-1] / 720) + 40 if right_hands[i].x_buf[-1] > 0: per_dict['hand2_x'] = 110 - (120 * (right_hands[i].x_buf[-1] / 1280)) per_dict['hand2_y'] = 100 * (right_hands[i].y_buf[-1] / 720) + 40 package.append(per_dict) print package # Send to server sock_client.emit('messages', json.dumps(package)) # Display the image cv2.imshow("output", output_image) cv2.waitKey(2)
class Client(object): def __init__(self): self.socketio = SocketIO("http://twitchplaysnintendoswitch.com:8110") # self.socketio.on("controllerState1", self.on_controller_state1) # self.socketio.on("controllerState2", self.on_controller_state2) # self.socketio.on("controllerState3", self.on_controller_state3) self.socketio.on("controllerState5", self.on_controller_state1) self.socketio.on("turnTimesLeft", self.on_turn_times_left) self.socketio.emit("join", "wiiu3dscontroller") self.receive_events_thread = Thread(target=self._receive_events_thread) self.receive_events_thread.daemon = True self.receive_events_thread.start() self.start = time.clock() self.end = time.clock() self.botstart = time.clock() self.botend = time.clock() self.controllerStart = time.clock() self.controllerEnd = time.clock() self.lockon = False self.yeaVotes = 0 self.nayVotes = 0 self.voting = False self.currentPlayers = [] self.laglessEnabled = True self.currentGame = "none" self.oldArgs2 = "800000000000000 128 128 128 128" def _receive_events_thread(self): self.socketio.wait() def on_event(self, event): #print(event) pass def on_controller_command(*args): nextCommands.append(args) def on_turn_times_left(*args): try: client.currentPlayers = args[1]["usernames"] except: pass def on_controller_state(*args): if(not client.laglessEnabled): return state = args[1] cNum = args[2] print("controller state" + str(cNum) + ":", state) client.oldArgs2 = state controller = None if(cNum == 0): controller = controller1 elif(cNum == 1): controller = controller2 elif(cNum == 2): return cNum = 1 controller = controller2 elif(cNum == 3): return cNum = 1 controller = controller2 elif(cNum == 4): return cNum = 1 controller = controller2 controller.reset() inputs = state.split() cPlayer = "" try: cPlayer = client.currentPlayers[cNum] except: pass btns = inputs[0] LX = inputs[1] LY = inputs[2] RX = inputs[3] RY = inputs[4] controller.dpad = int(btns[0]) if (btns[1] == "1"): controller.lstick = 1; if (btns[2] == "1"): controller.l = 1; if (btns[3] == "1"): controller.zl = 1; if (btns[4] == "1"): controller.minus = 1; if (btns[5] == "1"): try: if (cPlayer.lower() in modlist): controller.capture = 1 else: controller.capture = 0 except: controller.capture = 0 if (btns[6] == "1"): controller.a = 1; if (btns[7] == "1"): controller.b = 1; if (btns[8] == "1"): controller.x = 1; if (btns[9] == "1"): controller.y = 1; if (btns[10] == "1"): controller.rstick = 1; if (btns[11] == "1"): controller.r = 1; if (btns[12] == "1"): controller.zr = 1; if (btns[13] == "1"): try: if (cPlayer.lower() in pluslist): controller.plus = 1 else: controller.plus = 0 except: controller.plus = 0 if (btns[14] == "1"): try: if (cPlayer.lower() in modlist): controller.home = 1 else: controller.home = 0 except: controller.home = 0 try: controller.LX = int(LX) controller.LY = 255-int(LY) controller.RX = int(RX) controller.RY = 255-int(RY) except: pass duration = 0.001 reset = 0 if(cNum == 0): send_and_reset(duration, reset) elif(cNum == 1): send_and_reset2(duration, reset) elif(cNum == 2): send_and_reset3(duration, reset) elif(cNum == 3): send_and_reset4(duration, reset) # player 1: def on_controller_state1(*args): client.on_controller_state(args[1], 0) def handleChat(self, username, message): print(message) # handle chat messages here def decreaseQueue(self): # handle queue from handlechat pass def loop(self): # control switch here: # every 5 minutes: self.botend = time.clock() diffInMilliSeconds = (self.botend - self.botstart)*1000 if(diffInMilliSeconds > 1000*60*5): self.socketio.emit("join", "wiiu3dscontroller") self.botstart = time.clock() # msg = "Join the discord server! https://discord.gg/ARTbddH\ # hate the stream delay? go here! https://twitchplaysnintendoswitch.com" # twitchBot.chat(msg) # every 6 seconds, probably doesn't need to do this so often: self.controllerEnd = time.clock() diffInMilliSeconds2 = (self.controllerEnd - self.controllerStart)*1000 if(diffInMilliSeconds2 > 6000): self.socketio.emit("join", "wiiu3dscontroller") self.controllerStart = time.clock() response = twitchBot.stayConnected() if(response != "none"): # prevent crash try: username = re.search(r"\w+", response).group(0) # return the entire match username = username.lower() message = CHAT_MSG.sub("", response) message = message.strip() message = message.lower() self.handleChat(username, message) except: pass self.decreaseQueue() def _receive_events_thread(self): self.socketio.wait()
total = 0 def on_mission_download(var): global total global checker print("DOWNLOAD MISSION COMMAND BY USER", var) save_mission() total = calculate_dist() checker = True try: #socket = SocketIO('http://192.168.1.119', 3000, wait_for_connection=False) socket = SocketIO('https://nicwebpage.herokuapp.com', verify=False) socket.emit("joinPi") except ConnectionError: print('The server is down. Try again later.') def on_initiate_flight(var): socket.emit("success", "flight_success") print("FLIGHT INITIATED BY USER") arm_and_takeoff(5) vehicle.mode = VehicleMode("AUTO") # Get all vehicle attributes (state) print("\nGet all vehicle attribute values:")