def main(): rclpy.init(args=None) node = rclpy.create_node('minimal_action_node') executor = MultiThreadedExecutor() exit_future = rclpy.Future() asw = ActionServerWrapperThread(node, exit_future) asw.start() time.sleep( 0.5 ) # without this instruction this error is thrown at the end of the program: # PyCapsule_GetPointer called with invalid PyCapsule object #3 acw = ActionClientWrapperThread(node, exit_future) acw.start() while not exit_future.done(): rclpy.spin_until_future_complete(node, exit_future, executor=executor, timeout_sec=1) acw.destroy() asw.destroy() executor.shutdown() node.destroy_node() rclpy.shutdown()
def main(args=None): rclpy.init(args=args) #Executor to control all topic nodes executor = MultiThreadedExecutor() nodeList = [] #std_msgs/String topics -- topics = ['rosout', 'actions', 'status'] rosout_node = RosoutListener() executor.add_node(rosout_node) logger.info(f'creating node for rosout messages') nodeList.append(rosout_node) for topic in topics: #Node creation for all topics subscriber = TopicNode(topic) executor.add_node(subscriber) nodeList.append(subscriber) print(f'creating node for string topic /{topic} messages') try: executor.spin() finally: executor.shutdown() for subscriber in nodeList: subscriber.destroy_node() rclpy.shutdown()
def test_multi_threaded_executor_executes(self): self.assertIsNotNone(self.node.handle) executor = MultiThreadedExecutor(context=self.context) try: self.assertTrue(self.func_execution(executor)) finally: executor.shutdown()
def main(args=None): logging.basicConfig(format='%(asctime)s %(levelname)-8s %(message)s', level=logging.INFO, datefmt='%Y-%m-%d %H:%M:%S') rclpy.init(args=args) executor = MultiThreadedExecutor() odom_node = TransformLoggerNode('odom', 'base_link', executor=executor) map_node = TransformLoggerNode('map', 'base_link', executor=executor) executor.add_node(odom_node) executor.add_node(map_node) try: #rclpy.spin(log_node) while True: executor.spin_once() #logging.info(f"num nodes is: {len(executor.get_nodes())}") if len(executor.get_nodes()) == 0: break if odom_node.is_done() and map_node.is_done(): break except: logging.warning(f"hit exception") pass #executor.shutdown() finally: logging.warning(f"cleaning up") odom_node.plot_data() map_node.plot_data() plt.pause(1) plt.show(block=True) odom_node.destroy_node() map_node.destroy_node()
def start_a_message_equality_tester_node_and_get_result(future_result : Future, exe : MultiThreadedExecutor, expected_data : Dict): node = MessageEqualityTesterNode('topic', 'std_msgs/msg/String', expected_data, future_result) exe.add_node(node) exe.spin_until_future_complete(future_result) node.destroy_node() return future_result.result()
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, nodes: list = []): self.nodes = nodes # self.executor = SingleThreadedExecutor() # commented out to test out MultiThreadedExecutor and see how it works self.executor = MultiThreadedExecutor( num_threads=2) # if num_threads is 1, it executes as single thread if len(nodes) is 0: self.executor.shutdown() rclpy.shutdown() raise ValueError('Not any node was given!') elif len(nodes) > 1: for node in nodes: self.executor.add_node(node) else: self.executor.add_node(node)
def main(args=None): global executor rclpy.init(args=args) try: executor = MultiThreadedExecutor() executor.add_node(SubtaskRoomLightOn()) executor.add_node(SubtaskRoomLightOff()) try: executor.spin() finally: executor.shutdown() finally: rclpy.shutdown()
def main(args=None): global logger rclpy.init(args=args) node = rclpy.create_node('minimal_action_server') logger = node.get_logger() # Use a ReentrantCallbackGroup to enable processing multiple goals concurrently # Default goal callback accepts all goals # Default cancel callback rejects cancel requests action_server = ActionServer(node, Fibonacci, 'fibonacci', execute_callback=execute_callback, cancel_callback=cancel_callback, callback_group=ReentrantCallbackGroup()) # Use a MultiThreadedExecutor to enable processing goals concurrently executor = MultiThreadedExecutor() rclpy.spin(node, executor=executor) action_server.destroy() node.destroy_node() rclpy.shutdown()
def main(args=None): rclpy.init(args=args) server = Supervisor() # Use a MultiThreadedExecutor to enable processing goals concurrently executor = MultiThreadedExecutor() rclpy.spin(server, executor=executor) rclpy.shutdown()
def main(args=None): rclpy.init(args=args) minimal_action_server = MinimalActionServer() executor = MultiThreadedExecutor() rclpy.spin(minimal_action_server, executor=executor) minimal_action_server.destroy() rclpy.shutdown()
def test_multi_goal_accept(self): executor = MultiThreadedExecutor(context=self.context) action_server = ActionServer( self.node, Fibonacci, 'fibonacci', execute_callback=self.execute_goal_callback, callback_group=ReentrantCallbackGroup(), handle_accepted_callback=lambda gh: None, ) goal_msg = Fibonacci.Impl.SendGoalService.Request() goal_msg.goal_id = UUID(uuid=list(uuid.uuid4().bytes)) future0 = self.mock_action_client.send_goal(goal_msg) goal_msg.goal_id = UUID(uuid=list(uuid.uuid4().bytes)) future1 = self.mock_action_client.send_goal(goal_msg) goal_msg.goal_id = UUID(uuid=list(uuid.uuid4().bytes)) future2 = self.mock_action_client.send_goal(goal_msg) rclpy.spin_until_future_complete(self.node, future0, executor) rclpy.spin_until_future_complete(self.node, future1, executor) rclpy.spin_until_future_complete(self.node, future2, executor) self.assertTrue(future0.result().accepted) self.assertTrue(future1.result().accepted) self.assertTrue(future2.result().accepted) action_server.destroy()
def setUpClass(cls): cls.context = rclpy.context.Context() rclpy.init(context=cls.context) cls.node = rclpy.create_node(TEST_NODE, namespace=TEST_NAMESPACE, context=cls.context) cls.executor = MultiThreadedExecutor(context=cls.context, num_threads=2) cls.executor.add_node(cls.node) cls.node.declare_parameter('bool_param', True) cls.node.declare_parameter('int_param', 42) cls.node.declare_parameter('double_param', 1.23) cls.node.declare_parameter('str_param', 'Hello World') cls.node.declare_parameter( 'foo' + PARAMETER_SEPARATOR_STRING + 'str_param', 'foo') cls.node.declare_parameter( 'foo' + PARAMETER_SEPARATOR_STRING + 'bar' + PARAMETER_SEPARATOR_STRING + 'str_param', 'foobar') # We need both the test node and 'dump' # node to be able to spin cls.exec_thread = threading.Thread(target=cls.executor.spin) cls.exec_thread.start()
def main(args=None): rclpy.init(args=args) qos = QoSProfile(reliability=QoSReliabilityPolicy.RMW_QOS_POLICY_RELIABILITY_BEST_EFFORT, depth=1, history=QoSHistoryPolicy.RMW_QOS_POLICY_HISTORY_KEEP_LAST) try: deepracer_offroad_navigation_node = DeepracerOffroadNavigationNode(qos) executor = MultiThreadedExecutor() def signal_handler(signum, frame): """Callback function to handle registered signal handler to join and stop executing running thread created. Args: signum: The signal number. frame: the current stack frame (None or a frame object). """ deepracer_offroad_navigation_node.get_logger().info("Signal Handler initiated") deepracer_offroad_navigation_node.thread_shutdown() deepracer_offroad_navigation_node.wait_for_thread() # Register SIGINT handler signal.signal(signal.SIGINT, signal_handler) rclpy.spin(deepracer_offroad_navigation_node, executor) except Exception as ex: deepracer_offroad_navigation_node.get_logger().error(f"Exception in Deepracer Offroad Navigation Node: {ex}") deepracer_offroad_navigation_node.destroy_node() rclpy.shutdown() # Destroy the node explicitly # (optional - otherwise it will be done automatically # when the garbage collector destroys the node object) deepracer_offroad_navigation_node.destroy_node() rclpy.shutdown()
def start_multi_equality_tester(future : Future, exe : MultiThreadedExecutor): topic_and_expected_values_pairs = [ TopicAndValuesPair('topic1', 'std_msgs/msg/String', {'data' : 'hello1'}), TopicAndValuesPair('topic2', 'std_msgs/msg/String', {'data' : 'hello2'}), TopicAndValuesPair('topic3', 'std_msgs/msg/String', {'data' : 'hello3'}), ] node = MultiMessageEqualityTesterNode(topic_and_expected_values_pairs, EqualityType.ALLOF, future) exe.add_node(node) exe.spin_until_future_complete(future) node.destroy_node() return future.result()
def main(args=None) -> None: """! Main Functions of Local Console Node """ # Initialize ROS communications for a given context. setProcessName("planner-node") rclpy.init(args=args) # Execute work and block until the context associated with the # executor is shutdown. planner_node = PlannerNode() # Runs callbacks in a pool of threads. executor = MultiThreadedExecutor() # Execute work and block until the context associated with the # executor is shutdown. Callbacks will be executed by the provided # executor. rclpy.spin(planner_node, executor) # Clear thread planner_node.clear() # Destroy the node explicitly # (optional - otherwise it will be done automatically # when the garbage collector destroys the node object) planner_node.destroy_node() rclpy.shutdown()
def main(args=None): rclpy.init(args=args) pipeline_manager = PipelineManager() executor = MultiThreadedExecutor() executor.add_node(pipeline_manager) executor.spin() pipeline_manager.destroy_node() executor.shutdown() rclpy.shutdown()
def main(args=None): rclpy.init(args=args) paella_action_server = PaellaActionServer() executor = MultiThreadedExecutor() rclpy.spin(paella_action_server, executor=executor) paella_action_server.destroy() rclpy.shutdown()
def main(args=None): """Run a ROSPIT test session.""" rclpy.init(args=args) executor = MultiThreadedExecutor() node = ROSTestRunnerNode(executor) action_client = ActionClient(node, ExecuteXMLTestSuite, '/execute_xml_test_suite') node.declare_parameter('path') executor.add_node(node) t1 = ExecuteCall(node, action_client) t2 = ExecuteSpin(node, executor) t1.start() t2.start() t1.join() t2.spinning = False t2.join() rclpy.shutdown()
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 main(args=None): time.sleep(1) # to measure the load on instantiation rclpy.init(args=args) try: nodes = {} for i in range(int(os.environ["ROS2_TEST_NUM_PER_GROUP"])): nodes[f'pub{i:03d}'] = NodePublish(cli_args=[ "--ros-args", "-r", f"__node:=node_publish_{i:03d}", ]) nodes[f'sub{i:03d}'] = NodeSubscribe(cli_args=[ "--ros-args", "-r", f"__node:=node_subscribe_{i:03d}", ]) executor = MultiThreadedExecutor() [executor.add_node(node) for node in nodes.values()] try: executor.spin() finally: executor.shutdown() [node.destroy_node() for node in nodes.values()] finally: rclpy.shutdown()
def main(args=None): '''start interaction with shell''' #TODO init parameter # print(args) shell = Shell() Process(target=write_string, args=(shell, )).start() rclpy.init(args=args) shell_read = ReadShell(shell) shell_write = WriteShell(shell) executor = MultiThreadedExecutor() executor.add_node(shell_read) executor.add_node(shell_write) executor.spin() executor.shutdown() shell_read.destroy_node() shell_write.destroy_node()
def main(args=None): rclpy.init(args=args) action_server = RandomCrawlActionServer() executor = MultiThreadedExecutor() rclpy.spin(action_server, executor=executor) action_server.destroy() rclpy.shutdown()
def main(args=None): rclpy.init(args=args) try: # MultiThreadedExecutor executes callbacks with a thread pool. If num_threads is not # specified then num_threads will be multiprocessing.cpu_count() if it is implemented. # Otherwise it will use a single thread. This executor will allow callbacks to happen in # parallel, however the MutuallyExclusiveCallbackGroup in DoubleTalker will only allow its # callbacks to be executed one at a time. The callbacks in Listener are free to execute in # parallel to the ones in DoubleTalker however. executor = MultiThreadedExecutor(num_threads=4) executor.add_node(DoubleTalker()) executor.add_node(Listener()) try: executor.spin() finally: executor.shutdown() finally: rclpy.shutdown()
def main(args=None): rclpy.init(args=args) action_client = NavigationActionClient() action_client.get_logger().info('********************************') executor = MultiThreadedExecutor() rclpy.spin(action_client, executor) action_client.get_logger().info('=================================')
def main(args=None): rclpy.init(args=args) software_update_node = SoftwareUpdateNode() executor = MultiThreadedExecutor() rclpy.spin(software_update_node, executor) # Destroy the node explicitly # (optional - otherwise it will be done automatically # when the garbage collector destroys the node object) software_update_node.destroy_node() rclpy.shutdown()
def main(args=None): rclpy.init() node = SampleActionServer() executor = MultiThreadedExecutor() # executor = SingleThreadedExecutor() rclpy.spin(node, executor=executor) node.destroy_node() rclpy.shutdown()
def main(args=None): rclpy.init(args=args) leg_names = ['front_left', 'middle_left', 'rear_left', 'rear_right', 'middle_right', 'front_right'] executor = MultiThreadedExecutor(num_threads=7) # EachLegGaitノード6スレッド+RoughWalkノード1スレッド+1スレッド for leg_name in leg_names: executor.add_node(EachLegGait(namespace='hapthexa/leg/'+leg_name)) executor.add_node(RoughWalk()) executor.spin() rclpy.shutdown()
def main(args=None): rclpy.init(args=args) with USBMonitorNode() as usb_monitor_node: executor = MultiThreadedExecutor() rclpy.spin(usb_monitor_node, executor) # Destroy the node explicitly # (optional - otherwise it will be done automatically # when the garbage collector destroys the node object) usb_monitor_node.destroy_node() rclpy.shutdown()
def main(args=None): rclpy.init(args=args) model_loader_node = ModelLoaderNode() executor = MultiThreadedExecutor() rclpy.spin(model_loader_node, executor) # Destroy the node explicitly # (optional - otherwise it will be done automatically # when the garbage collector destroys the node object) model_loader_node.destroy_node() rclpy.shutdown()