def reset(self):
"""
Reset the agent for a particular experiment condition.
"""
self.iterator = 0
if self.reset_jnts:
# reset simulation
while not self.reset_sim.wait_for_service(timeout_sec=1.0):
self.node.get_logger().info('/reset_simulation service not available, waiting again...')
reset_future = self.reset_sim.call_async(Empty.Request())
rclpy.spin_until_future_complete(self.node, reset_future)
self.ros_clock = rclpy.clock.Clock().now().nanoseconds
# delete entity
while not self.delete_entity_cli.wait_for_service(timeout_sec=1.0):
self.node.get_logger().info('/reset_simulation service not available, waiting again...')
req = DeleteEntity.Request()
req.name = "target"
delete_future = self.delete_entity_cli.call_async(req)
rclpy.spin_until_future_complete(self.node, delete_future)
self.spawn_target()
# Take an observation
obs = self.take_observation()
# Return the corresponding observation
return obs
def delete_entity(self):
req = DeleteEntity.Request()
req.name = self.entity_name
while not self.delete_entity_client.wait_for_service(timeout_sec=1.0):
self.get_logger().info('service not available, waiting again...')
self.delete_entity_client.call_async(req)
def delete_ball(self, ball_id):
"""
:type ball_id: int
"""
ball = self.balls[ball_id]
self.delete_entity_client.call_async(
DeleteEntity.Request(name=ball.name))
ball.set_destroyed(self.get_clock().now())
self.score += self.compute_score(ball.get_lifespan())
self.publish_stats()
self.get_logger().info(f"Ball {ball_id} deleted")
def delete_entity(self):
delete_req = DeleteEntity.Request()
delete_req.name = self.entity_name
# check connection to the service server
while not self.delete_entity_client.wait_for_service(timeout_sec=1.0):
self.get_logger().warn(
'service for delete_entity is not available, waiting ...')
future = self.delete_entity_client.call_async(delete_req)
rclpy.spin_until_future_complete(self, future)
def __delete(self):
models = ["coke_can", "beer"]
for model in models:
request = DeleteEntity.Request()
request.name = model
done = False
while not done:
future = self.del_client.call_async(request)
rclpy.spin_until_future_complete(self.del_node, future)
if future.result().success:
done = True
def delete_ball(self, ball_id):
"""
:type ball_id: int
"""
ball = self.balls[ball_id]
self.delete_entity_client.call_async(
DeleteEntity.Request(name=ball.name))
ball.set_destroyed(self.get_clock().now())
self.score += self.compute_score(ball.get_lifespan())
self.get_logger().info(f"Ball {ball_id} deleted")
if self.get_ball_count() == 0 and len(
self.balls) == self.TOTAL_BALL_COUNT:
self.get_logger().info(f"End of simulation, congratulations :)")
self.destroy_node()
def delete_entity(self):
"""
Deletes the goal_box entity by sending a request to the gazebo srvice
This method mostly will be called upon a task success and a task failed request from RL_environment
"""
delete_req = DeleteEntity.Request()
delete_req.name = self.entity_name
# check connection to the service server
while not self.delete_entity_client.wait_for_service(timeout_sec=1.0):
self.get_logger().warn(
'service for delete_entity is not available, waiting ...')
future = self.delete_entity_client.call_async(delete_req)
rclpy.spin_until_future_complete(self, future)
def delete_entity(self, entity_name: str) -> bool:
"""
Deletes an entity from gazebo by name of the entity
:param entity_name:
:return: bool representing whether the delete is successful
"""
while not self._entity_delete.wait_for_service(timeout_sec=1.0):
self.node.get_logger().info(
'/delete_entity service not available, waiting again...')
delete_future = self._entity_delete.call_async(
DeleteEntity.Request(name=entity_name))
print("Deleting entity")
rclpy.spin_until_future_complete(self.node, delete_future)
if delete_future.done():
delete_result = delete_future.result()
delete_success_status = delete_result.success
delete_message = delete_result.status_message
print(delete_message)
return delete_success_status
def _delete_entity(self):
# Delete entity from gazebo on shutdown if bond flag enabled
self.get_logger().info('Deleting entity [{}]'.format(self.args.entity))
client = self.create_client(
DeleteEntity, '%s/delete_entity' % self.args.gazebo_namespace)
if client.wait_for_service(timeout_sec=self.args.timeout):
req = DeleteEntity.Request()
req.name = self.args.entity
self.get_logger().info('Calling service %s/delete_entity' %
self.args.gazebo_namespace)
srv_call = client.call_async(req)
while rclpy.ok():
if srv_call.done():
self.get_logger().info('Deleting status: %s' %
srv_call.result().status_message)
break
rclpy.spin_once(self)
else:
self.get_logger().error(
'Service %s/delete_entity unavailable. ' +
'Was Gazebo started with GazeboRosFactory?')
def send_delete(self, model_name):
self.req = DeleteEntity.Request()
self.req.name = model_name
self.future = self.cli.call_async(self.req)
