def __init__(self): super().__init__('minimal_action_server') self._action_server = ActionServer( self, Fibonacci, 'fibonacci', execute_callback=self.execute_callback, callback_group=ReentrantCallbackGroup(), goal_callback=self.goal_callback, cancel_callback=self.cancel_callback)
def __init__(self): super().__init__('complex_node') self.publisher = self.create_publisher(Arrays, 'arrays', qos_profile_system_default) self.subscription = self.create_subscription( Strings, 'strings', lambda msg: None, qos_profile_system_default ) self.server = self.create_service(BasicTypes, 'basic', lambda req, res: res) self.action_server = ActionServer( self, Fibonacci, 'fibonacci', self.action_callback ) self.timer = self.create_timer(1.0, self.pub_callback)
def __init__(self, namespace: str = None): super().__init__('each_leg_gait', namespace=namespace) self._gait_action_server = ActionServer( self, Gait, 'gait', execute_callback=self.execute_callback, callback_group=ReentrantCallbackGroup(), goal_callback=self.goal_callback, cancel_callback=self.cancel_callback) self._move_leg_action_client = ActionClient(self, MoveLeg, 'move_leg')
def __init__(self, node, exit_future): threading.Thread.__init__(self) self._node = node self._exit_future = exit_future self._action_server = ActionServer( node, Fibonacci, 'fibonacci', execute_callback=self.execute_callback, callback_group=ReentrantCallbackGroup(), goal_callback=self.goal_callback, cancel_callback=self.cancel_callback)
def setUpClass(cls): cls.context = rclpy.context.Context() rclpy.init(context=cls.context) cls.node0 = rclpy.create_node(TEST_NODE0, namespace=TEST_NAMESPACE0, context=cls.context) cls.node1 = rclpy.create_node(TEST_NODE1, namespace=TEST_NAMESPACE1, context=cls.context) cls.node2 = rclpy.create_node(TEST_NODE2, namespace=TEST_NAMESPACE2, context=cls.context) cls.action_client10 = ActionClient(cls.node1, Fibonacci, TEST_ACTION0) cls.action_server10 = ActionServer(cls.node1, Fibonacci, TEST_ACTION0, lambda: None) cls.action_client20 = ActionClient(cls.node2, Fibonacci, TEST_ACTION0) cls.action_client21 = ActionClient(cls.node2, Fibonacci, TEST_ACTION1) cls.action_server20 = ActionServer(cls.node2, Fibonacci, TEST_ACTION0, lambda: None) cls.action_server21 = ActionServer(cls.node2, Fibonacci, TEST_ACTION1, lambda: None)
def __init__(self): super().__init__(self.node_name()) self._dict = self.init_argument() self.cb_group = ReentrantCallbackGroup() self._action_server = ActionServer( self, TsDoSubtask, "subtask_node_" + str(self.id()), execute_callback=self.execute_callback, callback_group=self.cb_group, goal_callback=self.goal_callback, cancel_callback=self.cancel_callback)
def __init__(self): super().__init__('minimal_action_server') self._sequence = [] self._action_server = ActionServer( self, Fibonacci, 'fibonacci', execute_callback=lambda x, self_=self: self_.execute_callback(x), callback_group=ReentrantCallbackGroup(), goal_callback=lambda x, self_=self: self_.goal_callback(x), cancel_callback=lambda x, self_=self: self_.cancel_callback(x))
def __init__(self): super().__init__('fibonacci_action_server') self.action_server = ActionServer( self, Fibonacci, 'fibonacci', callback_group=ReentrantCallbackGroup(), execute_callback=self.execute_callback, goal_callback=self.goal_callback, cancel_callback=self.cancel_callback, ) self.get_logger().info('=== Fibonacci Action Server Started ====')
def __init__(self): super().__init__('minimal_action_server_8') self._action_server = ActionServer( self, Fibonacci, 'fibonacci_8', execute_callback=self.execute_callback, callback_group=ReentrantCallbackGroup(), goal_callback=self.goal_callback, cancel_callback=self.cancel_callback) self.get_logger().info('SERVER 8 : ONLINE')
def __init__(self): super().__init__('minimal_action_server') self._goal_handle = None self._goal_lock = threading.Lock() self._action_server = ActionServer( self, Fibonacci, 'fibonacci', execute_callback=self.execute_callback, goal_callback=self.goal_callback, handle_accepted_callback=self.handle_accepted_callback, cancel_callback=self.cancel_callback, callback_group=ReentrantCallbackGroup())
def __init__(self): super().__init__('minimal_action_server_6') self._action_server = ActionServer( self, Simple, 'simple_6', execute_callback=self.execute_callback, callback_group=ReentrantCallbackGroup(), goal_callback=self.goal_callback, cancel_callback=self.cancel_callback) self.get_logger().info('SERVER 6 : ONLINE')
def __init__(self): super().__init__('move_distance_action') self._goal_lock = threading.Lock() self._goal_handle = None self._action_server = ActionServer( self, MoveDistance, 'move_distance', execute_callback=self.execute_callback, handle_accepted_callback=self.handle_accepted_callback, callback_group=ReentrantCallbackGroup(), goal_callback=self.goal_callback, cancel_callback=self.cancel_callback)
def __init__(self): """ Class Constructor. Starts the action server node """ super().__init__('hydrophone_streamer_aserver') self.action_server = ActionServer( self, Hydrophoneraw, 'hydrophoneraw', self.execute_callback ) self.publisher = self.create_publisher(String, 'hydrophonerawdata', 10) self.are_hydrophones_in = False
def __init__(self, goal_tolerance: float=0.05, pos_handler: str=None, pos_topic: str=None): super().__init__(pos_handler, pos_topic) self._goalreached_event = Event() self._abort_event = Event() self._lock = Lock() self.goal_point = None self._tolerance = goal_tolerance self._action_server = ActionServer( self, PositionAction, 'positionaction', self.execute_callback) self.tocontrol_publisher = self.create_publisher(Point, 'goal', 10)
def test_get_num_entities(self): action_server = ActionServer( self.node, Fibonacci, 'fibonacci', execute_callback=self.execute_goal_callback, ) num_entities = action_server.get_num_entities() self.assertEqual(num_entities.num_subscriptions, 0) self.assertEqual(num_entities.num_guard_conditions, 0) self.assertEqual(num_entities.num_timers, 1) self.assertEqual(num_entities.num_clients, 0) self.assertEqual(num_entities.num_services, 3) action_server.destroy()
def __init__(self): super(TFRepublisher, self).__init__('tf2_web_republisher') self.tf_transform_server = ActionServer( node=self, action_type=TFSubscription, action_name='tf2_web_republisher', execute_callback=self.goal_cb, cancel_callback=self.cancel_cb) self.republish_service = self.create_service(RepublishTFs, 'republish_tfs', self.request_cb) self.tf_buffer = Buffer() self.tf_listener = TransformListener(self.tf_buffer, node=self) self.active_clients = {}
def __init__(self): """コンストラクタ """ self.cb_group = ReentrantCallbackGroup() super().__init__("task_scheduler_manager") self.get_logger().info('task_scheduler_manager') self.action_server = ActionServer(self, TsReq, "tms_ts_master", self.execute_callback, goal_callback=self.goal_callback, cancel_callback=self.cancel_callback, callback_group=self.cb_group)
def __init__(self): super().__init__('pipeline_manager') self.nodes_in_pipeline = [] self.pipeline_success = False self.pipeline_abort = False self.pipeline_feedback_msg = "" self.pipeline_types = [ PipelineType.TYPE_CIRCLE_APPROACH, PipelineType.TYPE_BAR ] self.declare_parameters(namespace='pipeline', parameters=[('components', ['']), ('remap_rules', ['']), ('pkg_name', ''), ('namespace', '')]) self.feedback_sub = self.create_subscription(PipelineFeedback, '/tr/pipeline_feedback', self.feedback_callback, 10) self.pipeline_loading_client = self.create_client( LoadNode, '/tr/pipeline/_container/load_node') while not self.pipeline_loading_client.wait_for_service( timeout_sec=1.0): self.get_logger().warn( 'Pipeline loading service not available, waiting again...') self.pipeline_unloading_client = self.create_client( UnloadNode, '/tr/pipeline/_container/unload_node') while not self.pipeline_unloading_client.wait_for_service( timeout_sec=1.0): self.get_logger().warn( 'Pipeline unloading service not available, waiting again...') self.pipeline_listing_client = self.create_client( ListNodes, '/tr/pipeline/_container/list_nodes') while not self.pipeline_listing_client.wait_for_service( timeout_sec=1.0): self.get_logger().warn( 'Pipeline listing service not available, waiting again...') self.pipeline_running_server = ActionServer(self, RunPipeline, 'run_pipeline', self.run_pipeline) self.pipeline_configuring_server = self.create_service( ConfigurePipeline, 'configure_pipeline', self.configure_pipeline)
def receive_goals(node, action_type, expected_goals): from rclpy.action import ActionServer def execute_callback(goal_handle): for expected_goal in expected_goals: if expected_goal.is_goal_expected(goal_handle.request): return expected_goal.execute_goal(goal_handle) # Not an expected goal (this should not happen) print('Unexpected goal received by action server', file=sys.stderr) goal_handle.set_aborted() return action_type.Result() action_name = 'test/action/' + action_type.__name__ return ActionServer(node, action_type, action_name, execute_callback)
def __init__(self, exit_future): multiprocessing.Process.__init__(self) self._node = rclpy.create_node('minimal_action_server') self._executor = MultiThreadedExecutor() self._exit_future = exit_future self._action_server = ActionServer( self._node, Fibonacci, 'fibonacci', execute_callback=self.execute_callback, callback_group=ReentrantCallbackGroup(), goal_callback=self.goal_callback, cancel_callback=self.cancel_callback)
def __init__(self): super().__init__('R_KR10') self.publisher_ = self.create_publisher(AdjacencyList, 'graph_node_network', 10) timer_period = 1 # seconds self.timer = self.create_timer(timer_period, self.timer_callback) #Action server declaration self._action_server = ActionServer(self,Transport,'transport_request',self.transport_callback,goal_callback=self.goal_parse_msg) self.action_storage_client_2 = ActionClient(self, Storage, 'storage_request_2') self.action_storage_client_5 = ActionClient(self, Storage, 'storage_request_5') self.action_storage_client_6 = ActionClient(self, Storage, 'storage_request_6') self.servcie_machine_client_4 = self.create_client(MachineRequest5, 'machine_request_5') self.graph = AdjacencyList() self.graph.node = 3 self.graph.adjacent = [2,4,5,6] self.storage_2_ready = 0 print("init.....") #--------GPIO pin setup start------------- GPIO.setmode(GPIO.BOARD) GPIO.setwarnings(False) self.pin_start_23 = 33 self.pin_start_32 = 35 self.pin_start_34 = 36 self.pin_start_43 = 37 self.pin_start_35 = 38 self.pin_start_36 = 40 self.pin_progress = 16 self.pin_finished = 18 GPIO.setup(self.pin_start_23, GPIO.OUT) #Input 2 Kuka GPIO.setup(self.pin_start_32, GPIO.OUT) #Input 3 Kuka GPIO.setup(self.pin_start_34, GPIO.OUT) #Input 4 Kuka GPIO.setup(self.pin_start_43, GPIO.OUT) #Input 5 Kuka GPIO.setup(self.pin_start_35, GPIO.OUT) #Input 6 Kuka GPIO.setup(self.pin_start_36, GPIO.OUT) #Input 7 Kuka GPIO.setup(self.pin_progress, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(self.pin_finished, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.output(self.pin_start_23, GPIO.LOW) GPIO.output(self.pin_start_32, GPIO.LOW) GPIO.output(self.pin_start_34, GPIO.LOW) GPIO.output(self.pin_start_43, GPIO.LOW) GPIO.output(self.pin_start_35, GPIO.LOW) GPIO.output(self.pin_start_36, GPIO.LOW) #--------GPIO pin setup end------------- print("ready")
def __init__(self): """ Class Constructor. Starts the action server node """ super().__init__('hydrophone_localiser_aserver') self.action_server = ActionServer(self, Hydrophonelocalise, 'hydrophonelocaliser', self.execute_callback) self.samp_rate = 192000 self.heading_publisher = self.create_publisher(String, 'target_heading', 10) self.distance_publisher = self.create_publisher( Float32, 'target_distance', 10) self.channel_one_data = "" self.channel_two_data = "" self.channel_three_data = ""
def __init__(self): self.task_node_list = [] self.cb_group = ReentrantCallbackGroup() self.name = 'task_scheduler_manager' self.goal_handles = [] super().__init__('task_scheduler_manager') self.action_server = ActionServer( self, TsReq, "tms_ts_master", self.execute_callback, callback_group=self.cb_group, goal_callback=self.goal_callback, cancel_callback=self.cancel_callback )
def __init__(self, executor): """Initialize.""" super().__init__('test_runner') self.node_executor = executor self.invariant_evaluations = [] self.invariant_evaluation_subscription = self.create_subscription( ConditionEvaluationPairStamped, INVARIANT_EVALUATIONS_TOPIC, self.add_invariant_evaluation, 10) # prevent unused variable warning self.invariant_evaluation_subscription self.spinning = False self._action_server = ActionServer(self, ExecuteXMLTestSuite, 'execute_xml_test_suite', self.execute_xml_test_suite) self.active_goal_handle = None
def __init__(self, task_tree): """コンストラクタ """ self.cb_group = ReentrantCallbackGroup() self.name = f'tasknode_{TaskNode._count}' self.task_tree = task_tree self.subtask_goalhandles = {} super().__init__(self.name) TaskNode._count += 1 self.action_server = ActionServer(self, TsDoTask, self.name, self.execute_callback, cancel_callback=self.cancel_callback, callback_group=self.cb_group)
def __init__(self): super().__init__('action_server_node') self._goal_handle = None self._goal_lock = threading.Lock() self._execute_lock = threading.Lock() self._as = ActionServer( self, Move, 'move', execute_callback=self.execute_callback, # goal_callback=self.goal_callback, # handle_accepted_callback=self.handle_accepted_callback, # cancel_callback=self.cancel_callback, # callback_group=ReentrantCallbackGroup() )
def test_cancel_goal_accept(self): def execute_callback(goal_handle): # Wait, to give the opportunity to cancel time.sleep(3.0) self.assertTrue(goal_handle.is_cancel_requested) goal_handle.canceled() return Fibonacci.Result() def cancel_callback(request): return CancelResponse.ACCEPT executor = MultiThreadedExecutor(context=self.context) action_server = ActionServer( self.node, Fibonacci, 'fibonacci', callback_group=ReentrantCallbackGroup(), execute_callback=execute_callback, handle_accepted_callback=lambda gh: None, cancel_callback=cancel_callback, ) goal_uuid = UUID(uuid=list(uuid.uuid4().bytes)) goal_order = 10 goal_msg = Fibonacci.Impl.SendGoalService.Request() goal_msg.goal_id = goal_uuid goal_msg.goal.order = goal_order goal_future = self.mock_action_client.send_goal(goal_msg) rclpy.spin_until_future_complete(self.node, goal_future, executor) goal_handle = goal_future.result() self.assertTrue(goal_handle.accepted) cancel_srv = CancelGoal.Request() cancel_srv.goal_info.goal_id = goal_uuid cancel_srv.goal_info.stamp.sec = 0 cancel_srv.goal_info.stamp.nanosec = 0 cancel_future = self.mock_action_client.cancel_goal(cancel_srv) rclpy.spin_until_future_complete(self.node, cancel_future, executor) cancel_result = cancel_future.result() self.assertEqual(len(cancel_result.goals_canceling), 1) assert all( cancel_result.goals_canceling[0].goal_id.uuid == goal_uuid.uuid) action_server.destroy() executor.shutdown()
def test_constructor_no_defaults(self): action_server = ActionServer( self.node, Fibonacci, 'fibonacci', execute_callback=self.execute_goal_callback, callback_group=ReentrantCallbackGroup(), goal_callback=lambda req: GoalResponse.REJECT, handle_accepted_callback=lambda gh: None, cancel_callback=lambda req: CancelResponse.REJECT, goal_service_qos_profile=rclpy.qos.qos_profile_default, result_service_qos_profile=rclpy.qos.qos_profile_default, cancel_service_qos_profile=rclpy.qos.qos_profile_default, feedback_pub_qos_profile=rclpy.qos.qos_profile_default, status_pub_qos_profile=rclpy.qos.qos_profile_default, result_timeout=300, ) action_server.destroy()
def __init__(self): """Starts a simple action server and waits for requests.""" super().__init__("animation") # currently, we set log level to info since the action server is spamming too much if not self.get_parameter("use_sim_time"): pass # todo how does this work in rclpy # rospy.on_shutdown(self.on_shutdown_hook) self.get_logger().debug("Starting Animation Server") self.current_joint_states = None self.hcm_state = 0 self.current_animation = None self.animation_cache = {} all_animations = find_all_animations_by_name(self) for animation_name, animation_file in all_animations.items(): try: with open(animation_file) as fp: self.animation_cache[animation_name] = parse(json.load(fp)) except IOError: self.get_logger().error("Animation '%s' could not be loaded" % animation_name) except ValueError: self.get_logger().error( "Animation '%s' had a ValueError. Probably there is a syntax error in the animation file. " "See traceback" % animation_name) traceback.print_exc() # predefined messages for performance self.anim_msg = AnimationMsg() # AnimationMsg takes a JointTrajectory message to also be able to process trajectories. To keep this # functionality, we use this message type, even though we only need a single joint goal in this case. self.traj_msg = JointTrajectory() self.traj_point = JointTrajectoryPoint() self.create_subscription(JointState, "joint_states", self.update_current_pose, 1) self.create_subscription(RobotControlState, "robot_state", self.update_hcm_state, 1) self.hcm_publisher = self.create_publisher(AnimationMsg, "animation", 1) self._as = ActionServer(self, PlayAnimation, "animation", self.execute_cb)
def __init__(self): super().__init__('minimal_publisher') self.publisher_ = self.create_publisher(AdjacencyList, 'graph_node_network', 10) timer_period = 1 # seconds self.timer = self.create_timer(timer_period, self.timer_callback) self._action_server = ActionServer(self, Storage, 'storage_request_2', self.spin_execute_callback) self.graph = AdjacencyList() self.graph.node = 2 self.graph.adjacent = [1, 3] self.trays = [0, 0, 0] self.spinning = 0 self.conveyor_GPIO_pin = 15 self.conveyor_IR_pins = [38, 40] self.pneumatic_stop_pins = [8, 7] self.pneumatic_pin = 0 self.new_ir_readings = [0, 0] self.old_ir_readings = [0, 0] self.kuka_tray_counter = [-1, -1] self.debounce_counter = [0, 0] self.tray_requested = 0 self.found = 0 self.correct_edge_found = 0 print("init.....") #--------GPIO pin setup start------------- GPIO.setmode(GPIO.BOARD) GPIO.setwarnings(False) GPIO.setup(self.conveyor_GPIO_pin, GPIO.OUT) GPIO.setup(self.conveyor_IR_pins[0], GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(self.conveyor_IR_pins[1], GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(self.pneumatic_stop_pins[0], GPIO.OUT) GPIO.setup(self.pneumatic_stop_pins[1], GPIO.OUT) #--------GPIO pin setup end------------- print("ready")