| import time |
| from enum import Enum |
|
|
| from action_msgs.msg import GoalStatus |
| from geometry_msgs.msg import PoseStamped |
| from nav2_msgs.action import NavigateThroughPoses |
| from nav2_msgs.srv import ManageLifecycleNodes |
|
|
| import rclpy |
| from rclpy.action import ActionClient |
| from rclpy.node import Node |
|
|
|
|
| class TaskResult(Enum): |
| """Enum for task result.""" |
| UNKNOWN = 0 |
| SUCCEEDED = 1 |
| CANCELED = 2 |
| FAILED = 3 |
|
|
|
|
| class Navigator(Node): |
| """ |
| Um navegador simplificado para enviar uma lista de poses para o Nav2. |
| Focado para setups sem mapa e sem AMCL. |
| """ |
|
|
| def __init__(self, node_name='navigator', namespace=''): |
| super().__init__(node_name=node_name, namespace=namespace) |
| self.goal_handle = None |
| self.result_future = None |
| self.feedback = None |
| self.status = None |
|
|
| |
| self.nav_through_poses_client = ActionClient( |
| self, NavigateThroughPoses, 'navigate_through_poses') |
| self.lifecycle_manager_client = self.create_client( |
| ManageLifecycleNodes, 'lifecycle_manager_navigation/manage_nodes') |
|
|
| def destroy_node(self): |
| self.info('Destruindo o Navigator.') |
| self.nav_through_poses_client.destroy() |
| self.lifecycle_manager_client.destroy() |
| super().destroy_node() |
|
|
| def startup(self): |
| """ |
| Ativa os nós de ciclo de vida do Nav2 enviando um único comando |
| para o gerenciador de ciclo de vida. |
| """ |
| self.info('Enviando comando STARTUP para o lifecycle_manager_navigation...') |
| |
| while not self.lifecycle_manager_client.wait_for_service(timeout_sec=1.0): |
| self.info('Serviço do lifecycle_manager_navigation não disponível, aguardando...') |
|
|
| req = ManageLifecycleNodes.Request() |
| req.command = ManageLifecycleNodes.Request.STARTUP |
| |
| future = self.lifecycle_manager_client.call_async(req) |
| rclpy.spin_until_future_complete(self, future) |
|
|
| if future.result() and future.result().success: |
| self.info('Nós do Nav2 ativados com sucesso.') |
| else: |
| self.error('Falha ao ativar os nós do Nav2.') |
| return |
|
|
| def goThroughPoses(self, poses, behavior_tree=''): |
| """ |
| Envia uma lista de poses para o Nav2 seguir. |
| """ |
| self.info("Aguardando o servidor de ação 'navigate_through_poses'...") |
| while not self.nav_through_poses_client.wait_for_server(timeout_sec=1.0): |
| self.info("'navigate_through_poses' não disponível, aguardando...") |
|
|
| goal_msg = NavigateThroughPoses.Goal() |
| goal_msg.poses = poses |
| goal_msg.behavior_tree = behavior_tree |
|
|
| self.info(f'Enviando {len(goal_msg.poses)} waypoints para o Nav2...') |
| send_goal_future = self.nav_through_poses_client.send_goal_async( |
| goal_msg, self._feedbackCallback) |
| |
| rclpy.spin_until_future_complete(self, send_goal_future) |
| self.goal_handle = send_goal_future.result() |
|
|
| if not self.goal_handle.accepted: |
| self.error('O objetivo de seguir os waypoints foi rejeitado!') |
| return False |
|
|
| self.result_future = self.goal_handle.get_result_async() |
| self.info('Objetivo aceito, iniciando a navegação...') |
| return True |
|
|
| def cancelTask(self): |
| """Cancela a tarefa atual.""" |
| self.info('Cancelando a tarefa atual.') |
| if self.result_future: |
| future = self.goal_handle.cancel_goal_async() |
| rclpy.spin_until_future_complete(self, future) |
| return |
|
|
| def isTaskComplete(self): |
| """Verifica se a tarefa foi concluída.""" |
| if not self.result_future: |
| return True |
| |
| rclpy.spin_until_future_complete(self, self.result_future, timeout_sec=0.10) |
| |
| if self.result_future.result(): |
| self.status = self.result_future.result().status |
| if self.status != GoalStatus.STATUS_SUCCEEDED: |
| return True |
| else: |
| return False |
|
|
| return True |
|
|
| def getFeedback(self): |
| """Retorna o feedback da ação atual.""" |
| return self.feedback |
|
|
| def getResult(self): |
| """Retorna o resultado final da tarefa.""" |
| if self.status == GoalStatus.STATUS_SUCCEEDED: |
| return TaskResult.SUCCEEDED |
| elif self.status == GoalStatus.STATUS_ABORTED: |
| return TaskResult.FAILED |
| elif self.status == GoalStatus.STATUS_CANCELED: |
| return TaskResult.CANCELED |
| else: |
| return TaskResult.UNKNOWN |
|
|
| def _feedbackCallback(self, msg): |
| self.feedback = msg.feedback |
| return |
|
|
| |
| def info(self, msg): |
| self.get_logger().info(msg) |
|
|
| def warn(self, msg): |
| self.get_logger().warn(msg) |
|
|
| def error(self, msg): |
| self.get_logger().error(msg) |
|
|
| def debug(self, msg): |
| self.get_logger().debug(msg) |
|
|
