def open(self): cls = self.__class__ parameters = { "fragment_timeout": cls.fragment_timeout, "delay_between_messages": cls.delay_between_messages, "max_message_size": cls.max_message_size, "unregister_timeout": cls.unregister_timeout, "bson_only_mode": cls.bson_only_mode } try: self.protocol = RosbridgeProtocol(cls.client_id_seed, parameters=parameters) self.protocol.outgoing = self.send_message self.set_nodelay(True) self.authenticated = False cls.client_id_seed += 1 cls.clients_connected += 1 if cls.client_count_pub: cls.client_count_pub.publish(cls.clients_connected) except Exception as exc: rospy.logerr("Unable to accept incoming connection. Reason: %s", str(exc)) rospy.loginfo("Client connected. %d clients total.", cls.clients_connected) if cls.authenticate: rospy.loginfo("Awaiting proper authentication...")
def open(self): cls = self.__class__ parameters = { "fragment_timeout": cls.fragment_timeout, "delay_between_messages": cls.delay_between_messages, "max_message_size": cls.max_message_size, "unregister_timeout": cls.unregister_timeout, "bson_only_mode": cls.bson_only_mode } try: self.protocol = RosbridgeProtocol(cls.client_id_seed, parameters=parameters) self.protocol.outgoing = self.send_message self.set_nodelay(True) self.authenticated = False self._write_lock = threading.RLock() cls.client_id_seed += 1 cls.clients_connected += 1 self.client_id = uuid.uuid4() if cls.client_manager: cls.client_manager.add_client(self.client_id, self.request.remote_ip) except Exception as exc: rospy.logerr("Unable to accept incoming connection. Reason: %s", str(exc)) rospy.loginfo("Client connected. %d clients total.", cls.clients_connected) if cls.authenticate: rospy.loginfo("Awaiting proper authentication...")
def onOpen(self): cls = self.__class__ parameters = { "fragment_timeout": cls.fragment_timeout, "delay_between_messages": cls.delay_between_messages, "max_message_size": cls.max_message_size, "unregister_timeout": cls.unregister_timeout, "bson_only_mode": cls.bson_only_mode } try: self.protocol = RosbridgeProtocol(cls.client_id_seed, parameters=parameters) producer = OutgoingValve(self) self.transport.registerProducer(producer, True) producer.resumeProducing() self.protocol.outgoing = producer.relay self.authenticated = False cls.client_id_seed += 1 cls.clients_connected += 1 self.client_id = uuid.uuid4() self.peer = self.transport.getPeer().host if cls.client_manager: cls.client_manager.add_client(self.client_id, self.peer) except Exception as exc: rospy.logerr("Unable to accept incoming connection. Reason: %s", str(exc)) rospy.loginfo("Client connected. %d clients total.", cls.clients_connected) if cls.authenticate: rospy.loginfo("Awaiting proper authentication...")
def setup(self): cls = self.__class__ parameters = { "port": cls.port, "host": cls.host, "incoming_buffer": cls.incoming_buffer, "socket_timeout": cls.socket_timeout, "retry_startup_delay": cls.retry_startup_delay, "service_request_timeout": cls.service_request_timeout, "check_response_delay": cls.check_response_delay, "wait_for_busy_service_provider": cls.wait_for_busy_service_provider, "max_service_requests": cls.max_service_requests, "fragment_timeout": cls.fragment_timeout, "delay_between_messages": cls.delay_between_messages, "max_message_size": cls.max_message_size } try: self.protocol = RosbridgeProtocol(cls.client_id_seed, parameters=parameters) self.protocol.outgoing = self.send_message cls.client_id_seed += 1 cls.clients_connected += 1 self.protocol.log( "info", "connected. " + str(cls.clients_connected) + " client total.") except Exception as exc: rospy.logerr("Unable to accept incoming connection. Reason: %s", str(exc))
def test_setparam_service(self): from rosbridge_library.rosbridge_protocol import RosbridgeProtocol param = Param("/test_param") test_protocol=RosbridgeProtocol(88) def outgoing(message): print("ROSBRidge Outgoing: {}".format(message)) test_protocol.outgoing=outgoing test_protocol.incoming(param.set_command(885))
def test_sync(self): with open('compressedDepth_sample_msg.txt', 'r') as outfile: sample_depth = outfile.read() with open('compressedRGB_sample_msg.txt', 'r') as outfile: sample_rgb = outfile.read() from rosbridge_library.rosbridge_protocol import RosbridgeProtocol test_protocol = RosbridgeProtocol(88) test_protocol.incoming(sample_depth) test_protocol.incoming(sample_rgb)
def __init__(self, url): self.url = url parameters = { "fragment_timeout": 600, "delay_between_messages": 0, "max_message_size": None, "unregister_timeout": 10, "bson_only_mode": False } self.ws = None self.protocol = RosbridgeProtocol("main", parameters=parameters) self.protocol.outgoing = self.send
def test_advertise_service(self): from rosbridge_library.rosbridge_protocol import RosbridgeProtocol test_protocol=RosbridgeProtocol(88) def outgoing(message): print("ROSBRidge Outgoing: {}".format(message)) test_protocol.incoming('{"op": "service_response", "service": "/test_service", "values": {"value": "88"}, "result": true, "id": "service_request:/test_service:1"}') test_protocol.outgoing=outgoing service = Service("/test_service",type="rosapi/GetParam") test_protocol.incoming(service.advertise_command())
def onOpen(self): global client_id_seed, clients_connected, authenticate, login try: self.protocol = RosbridgeProtocol(client_id_seed) self.protocol.outgoing = self.send_message self.authenticated = True client_id_seed = client_id_seed + 1 clients_connected = clients_connected + 1 except Exception as exc: rospy.logerr("Unable to accept incoming connection. Reason: %s", str(exc)) rospy.loginfo("Client connected. %d clients total.", clients_connected) print("ROBOTCLIENT: Start websocket connection to server.") self.Message = 'REGISTRATION:ROBOT|' + login self.sendMessage(self.Message.encode('utf8'))
def test_rosbridge_false_subscription(self): from std_msgs.msg import String pub = rospy.Publisher("/test", String, queue_size=10,latch=True) pub.publish("dada") from rosbridge_library.rosbridge_protocol import RosbridgeProtocol test_protocol=RosbridgeProtocol(88) def outgoing(message): print("ROSBRidge Outgoing: {}".format(message)) test_protocol.outgoing=outgoing topic=Topic("/test","sensor_msgs/Image") test_protocol.incoming(topic.advertise_command())
def __init__(self, id): self._protocol = RosbridgeProtocol(id) self._protocol.outgoing = self.rosbridge_outgoing #Store whether to compress/decompress topics self.incoming_topics_compression_state = {} self.outgoing_topics_compression_state = {} #Store whether to serialize/deserialize topics self.topics_serialization_state = {} #Store whether to remap topics/services self.topics_remap_state = {} self.services_remap_state = {} self.inv_services_remap_state = {}
def open(self): global client_id_seed, clients_connected, authenticate try: self.protocol = RosbridgeProtocol(client_id_seed) self.protocol.outgoing = self.send_message self.authenticated = False client_id_seed = client_id_seed + 1 clients_connected = clients_connected + 1 except Exception as exc: rospy.logerr("Unable to accept incoming connection. Reason: %s", str(exc)) rospy.loginfo("Client connected. %d clients total.", clients_connected) if authenticate: rospy.loginfo("Awaiting proper authentication...")
def open(self): cls = self.__class__ try: self.protocol = RosbridgeProtocol(cls.client_id_seed) self.protocol.outgoing = self.send_message self.set_nodelay(True) self.authenticated = False cls.client_id_seed += 1 cls.clients_connected += 1 except Exception as exc: rospy.logerr("Unable to accept incoming connection. Reason: %s", str(exc)) rospy.loginfo("Client connected. %d clients total.", cls.clients_connected) if cls.authenticate: rospy.loginfo("Awaiting proper authentication...")
def test_rosbridgeprotocol(self): from rosbridge_library.rosbridge_protocol import RosbridgeProtocol test_protocol=RosbridgeProtocol(88) def outgoing(message): print("ROSBRidge Outgoing: {}".format(message)) test_protocol.outgoing=outgoing with open('sample_config.json', 'r') as outfile: sample_config = outfile.read() parser = ConfigParser(sample_config) commands = parser.parse() test_protocol.incoming(commands[1])
def test_scan_topic(self): with open('sample_scan.txt', 'r') as outfile: sample_scan = outfile.read() from rosbridge_library.rosbridge_protocol import RosbridgeProtocol test_protocol = RosbridgeProtocol(88) def outgoing(message): print("ROSBRidge Outgoing: {}".format(message)) test_protocol.outgoing = outgoing topic = Topic("/scan", "sensor_msgs/LaserScan", latch=False) test_protocol.incoming(topic.advertise_command()) test_protocol.incoming(sample_scan)
def setup(self): cls = self.__class__ parameters = { "fragment_timeout": cls.fragment_timeout, "delay_between_messages": cls.delay_between_messages, "max_message_size": cls.max_message_size } try: self.protocol = RosbridgeProtocol(cls.client_id_seed, parameters=parameters) self.protocol.outgoing = self.send_message cls.client_id_seed += 1 cls.clients_connected += 1 self.protocol.log("info", "connected. " + str(cls.clients_connected) + " client total.") except Exception as exc: rospy.logerr("Unable to accept incoming connection. Reason: %s", str(exc))
def startProtocol(self): cls = self.__class__ parameters = { "fragment_timeout": cls.fragment_timeout, "delay_between_messages": cls.delay_between_messages, "max_message_size": cls.max_message_size } try: self.protocol = RosbridgeProtocol(cls.client_id_seed, parameters=parameters) self.protocol.outgoing = self.send_message self.authenticated = False cls.client_id_seed += 1 cls.clients_connected += 1 except Exception as exc: rospy.logerr("Unable to accept incoming connection. Reason: %s", str(exc)) rospy.loginfo("Client connected. %d clients total.", cls.clients_connected) if cls.authenticate: rospy.loginfo("Awaiting proper authentication...")
def test_service_handler(self): from rosbridge_library.rosbridge_protocol import RosbridgeProtocol test_protocol=RosbridgeProtocol(88) service_handler=ServiceHandler(test_protocol) def outgoing(message): service_handler.callback(message) print("ROSBRidge Outgoing: {}".format(message)) test_protocol.outgoing=outgoing if not rospy.has_param("/test_param"): rospy.set_param('/test_param', 88) param = Param("/test_param") result = yield service_handler.execute(param.get_command()) print("result is {}".format(result))
def main(args=None): server_url = os.environ.get('ROWMA_SERVER_URL', 'https://rowma.moriokalab.com') sio.connect(server_url) signal.signal(signal.SIGINT, signal_handler) signal.pause() client_id_seed = 0 protocol = RosbridgeProtocol(client_id_seed, rowma) protocol.outgoing = outgoing_func rclpy.spin(rowma) # Destroy the node explicitly # (optional - otherwise it will be done automatically # when the garbage collector destroys the node object) rowma.destroy_node() rclpy.shutdown()
def open(self): cls = self.__class__ try: from rosbridge_library.rosbridge_protocol import RosbridgeProtocol self.protocol = RosbridgeProtocol(cls.client_id_seed) self.protocol.outgoing = self.send_message self.set_nodelay(True) assert hasattr(cls, 'client_id_seed') assert hasattr(cls, 'clients_connected') except Exception as exc: rospy.logerr( 'Unable to accept incoming connection. Reason: %s', str(exc)) self.close(code=PROTO_OPEN_FAILED, reason=str(exc)) return cls.client_id_seed += 1 cls.clients_connected += 1 rospy.loginfo('Client connected. %d clients total.', cls.clients_connected)
def open(self): print("[BRIDGE]: open") rospy.logwarn_once( 'The Tornado Rosbridge WebSocket implementation is deprecated.' ' See rosbridge_server.autobahn_websocket' ' and rosbridge_websocket.py') cls = self.__class__ parameters = { "fragment_timeout": cls.fragment_timeout, "delay_between_messages": cls.delay_between_messages, "max_message_size": cls.max_message_size, "unregister_timeout": cls.unregister_timeout, "bson_only_mode": cls.bson_only_mode } try: self.protocol = RosbridgeProtocol(cls.client_id_seed, parameters=parameters) self.protocol.outgoing = self.send_message self.set_nodelay(True) self.authenticated = False self._write_lock = threading.RLock() cls.client_id_seed += 1 cls.clients_connected += 1 self.client_id = uuid.uuid4() self.io_loop = IOLoop.current() cls.clients[self.client_id] = (self.io_loop, self.close) if cls.client_manager: cls.client_manager.add_client(self.client_id, self.request.remote_ip) except Exception as exc: rospy.logerr("Unable to accept incoming connection. Reason: %s", str(exc)) rospy.loginfo("Client connected. %d clients total.", cls.clients_connected) if cls.authenticate: rospy.loginfo("Awaiting proper authentication...")
def init(self): self.ros_protocol = RosbridgeProtocol(0) self.producer = OutgoingValve(self) self.ros_protocol.outgoing = self.producer.relay