def __init__(self): #this line has the error, look at basic example and update what the quoted text is to match this package super().__init__('minimal_client_async') self.cli = self.create_client(AddTwoInts, 'hero_get_command') while not self.cli.wait_for_service(timeout_sec=1.0): self.get_logger().info('service not available, waiting again...') self.req = AddTwoInts.Request()
def main(args=None): rclpy.init(args=args) node = rclpy.create_node('add_two_ints_client') cli = node.create_client(AddTwoInts, 'add_two_ints') req = AddTwoInts.Request() req.a = 2 req.b = 3 while not cli.wait_for_service(timeout_sec=1.0): print('service not available, waiting again...') future = cli.call_async(req) while rclpy.ok(): rclpy.spin_once(node) if future.done(): if future.result() is not None: node.get_logger().info('Result of add_two_ints: %d' % future.result().sum) else: node.get_logger().error('Exception while calling service: %r' % future.exception()) break node.destroy_node() rclpy.shutdown()
def main(args=None): rclpy.init(args=args) node = rclpy.create_node('minimal_client_async') cli = node.create_client(AddTwoInts, 'add_two_ints') req = AddTwoInts.Request() req.a = 41 req.b = 1 while not cli.wait_for_service(timeout_sec=1.0): node.get_logger().info('service not available, waiting again...') cli.call(req) while rclpy.ok(): # TODO(mikaelarguedas) This is not the final API, and this does not scale # for multiple pending requests. This will change once an executor model is implemented # In the future the response will not be stored in cli.response if cli.response is not None: node.get_logger().info('Result of add_two_ints: for %d + %d = %d' % (req.a, req.b, cli.response.sum)) break rclpy.spin_once(node) node.destroy_node() rclpy.shutdown()
def main(args=None): rclpy.init(args=args) node = rclpy.create_node('minimal_client_async') cli = node.create_client(AddTwoInts, 'add_two_ints') req = AddTwoInts.Request() req.a = 41 req.b = 1 # TODO(mikaelarguedas) remove this once wait for service implemented # wait for connection to be established # (no wait for service in Python yet) time.sleep(1) cli.call(req) while rclpy.ok(): # TODO(mikaelarguedas) This is not the final API, and this does not scale # for multiple pending requests. This will change once an executor model is implemented # In the future the response will not be stored in cli.response if cli.response is not None: print('Result of add_two_ints: for %d + %d = %d' % (req.a, req.b, cli.response.sum)) break rclpy.spin_once(node) node.destroy_node() rclpy.shutdown()
async def add_two_ints_callback(self, request, response): response.sum = request.a + request.b self.get_logger().info('Incoming request\na: %d b: %d' % (request.a, request.b)) self.cli = self.create_client(AddTwoInts, 'wait', callback_group=self.cb_group) req = AddTwoInts.Request() req.a = 10 self.future = self.cli.call_async(req) self.flag_stoptask = False while not self.flag_stoptask and not self.future.done(): pass # _count = 0 # asyncio.set_event_loop(self.loop) # while not self.future.done() or self.flag_stoptask: # try: # #await asyncio.wait_for(asyncio.shield(self.future), timeout=1.0) # pass # except asyncio.TimeoutError: # print(f'timeout: {_count}') if self.flag_stoptask: print('stop!') response.sum = 404 else: print('complete!') response.sum = 1 return response
def main(args=None): rclpy.init(args=args) node = rclpy.create_node('minimal_client_async') cli = node.create_client(AddTwoInts, 'add_two_ints') req = AddTwoInts.Request() req.a = 41 req.b = 1 while not cli.wait_for_service(timeout_sec=1.0): node.get_logger().info('service not available, waiting again...') future = cli.call_async(req) while rclpy.ok(): rclpy.spin_once(node) if future.done(): if future.result() is not None: node.get_logger().info( 'Result of add_two_ints: for %d + %d = %d' % (req.a, req.b, future.result().sum)) else: node.get_logger().info('Service call failed %r' % (future.exception(), )) break node.destroy_node() rclpy.shutdown()
def __init__(self, node): self.cli = node.create_client(AddTwoInts, 'add_two_ints') # TODO(mikaelarguedas) remove this once wait for service implemented # wait for connection to be established # (no wait for service in Python yet) time.sleep(1) self.req = AddTwoInts.Request()
def main(args=None): rclpy.init(args=args) node = Node("add_two_ints_no_oop") client = node.create_client(AddTwoInts, "add_two_ints") while not client.wait_for_service(1.0): node.get_logger().warn("Waiting for Server Add Two Ints...") request = AddTwoInts.Request() request.a = 3 request.b = 8 future = client.call_async(request) rclpy.spin_until_future_complete(node, future) try: response = future.result() node.get_logger().info( str(request.a) + " + " + str(request.b) + " = " + str(response.sum)) except Exception as e: node.get_logger().error("Service call failed %r" % (e, )) rclpy.shutdown()
def __init__(self): super().__init__('minimal_client') self.client = self.create_client(AddTwoInts, 'add_two_ints') while not self.client.wait_for_service(timeout_sec=1.0): self.get_logger().info('service not available. waiting again...') self.req = AddTwoInts.Request()
def __init__(self): super().__init__('minimal_client') # add_two_intsサービスのクライアント作成 self.cli = self.create_client(AddTwoInts, 'add_two_ints') # add_two_intsサービスの起動待機 while not self.cli.wait_for_service(timeout_sec=1.0): self.get_logger().info('waiting...') # add_two_intsサービスの引数 self.request = AddTwoInts.request()
def __init__(self): super().__init__('addition_client') self.client = self.create_client(AddTwoInts, 'add_two_ints') while not self.client.wait_for_service(timeout_sec=1.0): self.get_logger().info('service not available, waiting again...') self.req = AddTwoInts.Request() self.get_logger().info('==== Welcome to Two Int Addition Service ====')
def service_client(self, a, b): client = self.create_client(AddTwoInts, "First_server") while client.wait_for_service(0.25) == False: self.get_logger().warn("wating for server") request = AddTwoInts.Request() request.a = a request.b = b futur_obj = client.call_async(request) futur_obj.add_done_callback(self.future_call)
def call_service(self, a, b): while not self.client.wait_for_service(1): self.get_logger().info("waiting for " + self.client.srv_name) request = AddTwoInts.Request() request.a = a request.b = b future = self.client.call_async(request) future.add_done_callback(partial(self.done_callback, a=a, b=b))
def __init__(self): super().__init__('minimal_client_async') self.cli = self.create_client(AddTwoInts, 'add_two_ints') while not self.cli.wait_for_service(timeout_sec=1.0): self.get_logger().info('service not available, waiting again...') self.req = AddTwoInts.Request() self.grp_timer = MutuallyExclusiveCallbackGroup() self.create_timer(1.0, self.send_request, callback_group=self.grp_timer)
def call_add_two_ints_server(self, a, b): while not self.client_.wait_for_service(1.0): self.get_logger().warn("Waiting for add_two_ints Server...") request = AddTwoInts.Request() request.a = a request.b = b future = self.client_.call_async(request) future.add_done_callback( partial(self.callback_call_add_two_ints, a=a, b=b))
def call_add_two_ints(self, a, b): client = self.create_client(AddTwoInts, "add_two_ints") while not client.wait_for_service(3.0): self.get_logger().warn("Waiting for service add_two_ints") request = AddTwoInts.Request() request.a = a request.b = b future = client.call_async(request) future.add_done_callback( partial(self.callback_add_two_ints, input_a=a, input_b=b)) # callback when future completes.
def call_add_two_ints_server(self, a, b): client = self.create_client(AddTwoInts, "add_two_ints") while not client.wait_for_service(1.0): self.get_logger().warn("waiting for server Add Two Ints .....") request = AddTwoInts.Request() request.a = a request.b = b future = client.call_async(request) future.add_done_callback(partial(self.callback_add_two_ints, a=a, b=b))
def __init__(self): super().__init__('async_service_client') self.logger = self.get_logger() self._cli = self.create_client(AddTwoInts, 'add_two_ints') while not self._cli.wait_for_service(timeout_sec=1.0): self.logger.info('service not available, waiting again...') self.future = None self.req = AddTwoInts.Request() self.logger.info('----- [action_client]Start! -----')
async def call_service(): nonlocal cli, node, did_run, did_get_result did_run = True try: req = AddTwoInts.Request() req.a = 41 req.b = 1 future = cli.call_async(req) result = await future node.get_logger().info('Result of add_two_ints: for %d + %d = %d' % (req.a, req.b, result.sum)) finally: did_get_result = True
def __send_srv_request(self): req = AddTwoInts.Request() self.srv_seq_itr = self.srv_seq_itr + 1 req.a = self.srv_seq_itr req.b = 0 self.future01 = self.cli01.call_async(req) self.future02 = self.cli02.call_async(req) self.future03 = self.cli03.call_async(req) dtstr = self.__get_time_now() - self._dtstr self.logger.info("[%s]:Service Send(%d)" % (dtstr, self.srv_seq_itr))
def call_add_two_ints_server(self, a, b): client = self.create_client(AddTwoInts, "add_two_ints") while not client.wait_for_service(1.0): self.get_logger().warn("Waiting for server Add Two Ints...") request = AddTwoInts.Request() request.a = a request.b = b future = client.call_async(request) # use func_tools.partial to be able to pass additional parameters future.add_done_callback(partial(self.handle_server_response, a=a, b=b))
def main(args=None): rclpy.init(args=args) node = rclpy.create_node('add_two_ints_client') cli = node.create_client(AddTwoInts, 'add_two_ints') max_iter = 3 i = 0 while rclpy.ok() and i < max_iter: req = AddTwoInts.Request() req.a = i req.b = i + 1 cli.call(req) cli.wait_for_future() print('Result of add_two_ints: %d' % cli.response.sum) i += 1
def send_request(self): # Cancel timer and send a request only once self.timer.cancel() # Wait for server while not self.client.wait_for_service(timeout_sec=1.0): self.get_logger().info('server not available, waiting again...') # Define a service request self.req = AddTwoInts.Request() self.req.a = int(sys.argv[1]) self.req.b = int(sys.argv[2]) # Call call_async() method self.future = self.client.call_async(self.req) self.future.add_done_callback(self.get_result_callback)
async def call_service(): nonlocal cli, node, did_run, did_get_result did_run = True try: req = AddTwoInts.Request() req.a = 41 req.b = 1 future = cli.call_async(req) result = await future if result is not None: node.get_logger().info( 'Result of add_two_ints: for %d + %d = %d' % (req.a, req.b, result.sum)) else: node.get_logger().info('Service call failed %r' % (future.exception(),)) finally: did_get_result = True
def main(args=None): rclpy.init(args=args) node = rclpy.create_node('add_two_ints_client') cli = node.create_client(AddTwoInts, 'add_two_ints') while not cli.wait_for_service(timeout_sec=1.0): print('service not available, waiting again...') req = AddTwoInts.Request() req.a = 2 req.b = 3 cli.call(req) cli.wait_for_future() node.get_logger().info('Result of add_two_ints: %d' % cli.response.sum) node.destroy_node() rclpy.shutdown()
def main (args=None): rclpy.init(args=args) client=Node("My_client_node") client_obj=client.create_client(AddTwoInts,"First_server") while client_obj.wait_for_service(0.5)== False: client.get_logger().warn("wait for server node") req=AddTwoInts.Request() req.a=15 req.b=10 future_obj=client_obj.call_async(req) rclpy.spin_until_future_complete(client,future_obj) reponse=future_obj.result() client.get_logger().error(str(reponse.sum)) rclpy.shutdown()
def main(args=None): rclpy.init(args=args) node = rclpy.create_node('add_two_ints_client') cli = node.create_client(AddTwoInts, 'add_two_ints') # TODO(mikaelarguedas) No wait for service in Python # need to leave some time for the connection to be established time.sleep(1) req = AddTwoInts.Request() req.a = 2 req.b = 3 cli.call(req) cli.wait_for_future() node.get_logger().info('Result of add_two_ints: %d' % cli.response.sum) node.destroy_node() rclpy.shutdown()
def main(args=None): rclpy.init(args=args) node = rclpy.create_node('minimal_client') cli = node.create_client(AddTwoInts, 'add_two_ints') req = AddTwoInts.Request() req.a = 41 req.b = 1 while not cli.wait_for_service(timeout_sec=1.0): node.get_logger().info('service not available, waiting again...') future = cli.call_async(req) rclpy.spin_until_future_complete(node, future) result = future.result() node.get_logger().info('Result of add_two_ints: for %d + %d = %d' % (req.a, req.b, result.sum)) node.destroy_node() rclpy.shutdown()
def main(args=None): rclpy.init(args) node = rclpy.create_node('minimal_client') cli = node.create_client(AddTwoInts, 'add_two_ints') req = AddTwoInts.Request() req.a = 41 req.b = 1 # TODO(mikaelarguedas) remove this once wait for service implemented # wait for connection to be established # (no wait for service in Python yet) time.sleep(1) cli.call(req) # when calling wait for future # spin should not be called in the main loop cli.wait_for_future() # TODO(mikaelarguedas) This is not the final API, and this does not scale # for multiple pending requests. This will change once an executor model is implemented # In the future the response will not be stored in cli.response print('Result of add_two_ints: for %d + %d = %d' % (req.a, req.b, cli.response.sum))
def main(args=None): rclpy.init(args=args) node = Node("add_nums_client") client = node.create_client(AddTwoInts, "add_nums_service") while not client.wait_for_service(1): node.get_logger().info("waiting for " + client.srv_name) request = AddTwoInts.Request() request.a = 1 request.b = 2 future = client.call_async(request) rclpy.spin_until_future_complete(node, future) try: response = future.result() node.get_logger().info("Got " + str(response.sum)) except Exception as e: node.get.get_logger().error("Service error %r" % (e,)) rclpy.shutdown()