def generate_test_description(executable, ready_fn): command = [executable] # Execute python files using same python used to start this test env = dict(os.environ) if command[0][-3:] == '.py': command.insert(0, sys.executable) env['PYTHONUNBUFFERED'] = '1' launch_description = LaunchDescription() test_context = {} for replacement_name, (replacement_value, cli_argument) in TEST_CASES.items(): random_string = '%d_%s' % ( random.randint(0, 9999), time.strftime('%H_%M_%S', time.gmtime())) launch_description.add_action( ExecuteProcess( cmd=command + [cli_argument.format(**locals())], name='name_maker_' + replacement_name, env=env ) ) test_context[replacement_name] = replacement_value.format(**locals()) launch_description.add_action( OpaqueFunction(function=lambda context: ready_fn()) ) return launch_description, test_context
def generate_launch_description(): use_sim_time = LaunchConfiguration("use_sim_time") slam_params_file = LaunchConfiguration("slam_params_file") declare_use_sim_time_argument = DeclareLaunchArgument( "use_sim_time", default_value="true", description="Use simulation/Gazebo clock") declare_slam_params_file_cmd = DeclareLaunchArgument( "slam_params_file", default_value=os.path.join( get_package_share_directory("sm_aws_warehouse_navigation"), "params", "mapper_params_online_sync.yaml", ), description= "Full path to the ROS2 parameters file to use for the slam_toolbox node", ) start_sync_slam_toolbox_node = Node( parameters=[slam_params_file, { "use_sim_time": use_sim_time }], package="slam_toolbox", executable="sync_slam_toolbox_node", name="slam_toolbox", output="screen", ) ld = LaunchDescription() ld.add_action(declare_use_sim_time_argument) ld.add_action(declare_slam_params_file_cmd) ld.add_action(start_sync_slam_toolbox_node) return ld
def generate_launch_description(): message = LaunchConfiguration('message') declare_message_cmd = DeclareLaunchArgument('message') stdout_linebuf_envvar = SetEnvironmentVariable( 'RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1') file_param_node_cmd = Node(package='parameters_ros2', node_executable='simple_param_node', output='screen', parameters=[{ "number": 2, "person_name": "luis", "message": message }]) ld = LaunchDescription() ld.add_action(stdout_linebuf_envvar) ld.add_action(declare_message_cmd) ld.add_action(file_param_node_cmd) return ld
def generate_launch_description(): ob = LaunchDescription() gps_link_node = Node( package="tf2_ros", executable="static_transform_publisher", output="screen", arguments=["0", "0", "1.77", "0", "0", "0", "base_link", "gps_link"]) lidar_link_node = Node(package="tf2_ros", executable="static_transform_publisher", output="screen", arguments=[ "1.92", "0", "0.36", "0", "0", "0", "base_link", "lidar_link" ]) zed2_link_node = Node(package="tf2_ros", executable="static_transform_publisher", output="screen", arguments=[ "1.8", "0.03", "1", "0", "0", "0", "base_link", "zed2_link" ]) ment_link_node = Node(package="tf2_ros", executable="static_transform_publisher", output="screen", arguments=[ "-0.1", "0", "0.88", "3.14", "0", "0", "base_link", "ment_link" ]) imu_link_node = Node(package="tf2_ros", executable="static_transform_publisher", output="screen", arguments=[ "1.8", "0.5", "1", "-1.57", "0", "0", "base_link", "imu_link" ]) ob.add_action(gps_link_node) ob.add_action(lidar_link_node) ob.add_action(zed2_link_node) ob.add_action(ment_link_node) ob.add_action(imu_link_node) return ob
def generate_launch_description(): # Get the launch directory example_dir = get_package_share_directory('plansys2_patrol_navigation_example') plansys2_cmd = IncludeLaunchDescription( PythonLaunchDescriptionSource(os.path.join( get_package_share_directory('plansys2_bringup'), 'launch', 'plansys2_bringup_launch_monolithic.py')), launch_arguments={'model_file': example_dir + '/pddl/patrol.pddl'}.items() ) fake_nav2_cmd = Node( package='plansys2_bt_example', executable='nav2_sim_node', name='nav2_sim_node', output='screen', parameters=[]) # Specify the actions move_cmd = Node( package='plansys2_patrol_navigation_example', executable='move_action_node', name='move_action_node', output='screen', parameters=[]) patrol_cmd = Node( package='plansys2_patrol_navigation_example', executable='patrol_action_node', name='patrol_action_node', output='screen', parameters=[]) # Create the launch description and populate ld = LaunchDescription() # Declare the launch options ld.add_action(plansys2_cmd) ld.add_action(fake_nav2_cmd) ld.add_action(move_cmd) ld.add_action(patrol_cmd) return ld
def generate_launch_description(): ld = LaunchDescription() rviz_config_dir = os.path.join( get_package_share_directory('interestingness_ros2'), 'intere.rviz') assert os.path.exists(rviz_config_dir) interestingness_node = Node( package="interestingness_ros2", executable="live_detector", parameters=[ { "image-topic": ["/rs_front/color/image"] }, { "model-save": '/home/li/CMU_RISS/my_ws2/src/interestingness_ros2/saves/vgg16.pt.SubTF.n100usage.mse' }, { "crop-size": 320 }, { "num-interest": 10 }, { "skip-frames": 1 }, { "window-size": 1 }, { "save-flag": "test" }, { "rr": 3250 }, { "wr": 5 }, ]) rviz_node = Node(package='rviz2', executable='rviz2', name='rviz2', output='screen', arguments=['-d', rviz_config_dir]) marker_node = Node(package='interestingness_ros2', executable='interest_marker', name='interest_marker', parameters=[ { "min-level": 0.2 }, ]) ld.add_action(interestingness_node) ld.add_action(rviz_node) ld.add_action(marker_node) return ld
def generate_launch_description(): ld = LaunchDescription() use_sim_time = LaunchConfiguration('use_sim_time', default='false') package_name = 'robot_sim' urdf_name = "robot.urdf" package_path = FindPackageShare(package=package_name).find(package_name) urdf_path = os.path.join(package_path, 'urdf', urdf_name) param_path = os.path.join(package_path, 'param', 'params.yaml') launch_path = os.path.join(package_path, 'launch') with open(urdf_path, 'r') as urdf: robot_desc = urdf.read() info = LogInfo(msg=['Execute Robot Sim']) robot_sim_node = Node(package=package_name, executable='robot_sim', parameters=[param_path], output='screen') robot_state_publisher_node = Node(package='robot_state_publisher', executable='robot_state_publisher', name='robot_state_publisher', output='screen', arguments=[urdf_path], parameters=[{ 'use_sim_time': use_sim_time, 'robot_description': robot_desc }]) rviz_launch = IncludeLaunchDescription( PythonLaunchDescriptionSource( os.path.join(launch_path, 'rviz2.launch.py'))) ld.add_action(info) ld.add_action(robot_sim_node) ld.add_action(robot_state_publisher_node) ld.add_action(rviz_launch) return ld
def generate_launch_description(): ld = LaunchDescription() use_sim_time_cfg = LaunchConfiguration('use_sim_time', default='true') robot_name_in_model = 'robot_gazebo' package_name = 'robot_gazebo' urdf_name = "robot.urdf" package_path = FindPackageShare(package=package_name).find(package_name) urdf_path = os.path.join(package_path, 'urdf', urdf_name) launch_path = os.path.join(package_path, 'launch') print('\033[92m' + "spawn_entity: Use urdf dir: " + urdf_path + '\033[0m') gazebo_world_path = os.path.join(package_path, 'worlds/migong.world') use_sim_time_arg = DeclareLaunchArgument( 'use_sim_time', default_value='true', description='Use simulation (Gazebo) clock if true') # Start Gazebo server start_gazebo_cmd = ExecuteProcess(cmd=[ 'gazebo', '--verbose', '-s', 'libgazebo_ros_factory.so', gazebo_world_path ], additional_env={ 'GAZEBO_MODEL_PATH': os.path.join(package_path, 'meshes') }, output='screen') # Launch the robot spawn_entity_node = Node( package='gazebo_ros', executable='spawn_entity.py', arguments=['-entity', robot_name_in_model, '-file', urdf_path], output='screen') robot_state_publisher_launch = IncludeLaunchDescription( PythonLaunchDescriptionSource( os.path.join(launch_path, 'robot_state_publisher.launch.py')), launch_arguments={ 'use_sim_time': use_sim_time_cfg, 'urdf_path': urdf_path }.items()) ld.add_action(use_sim_time_arg) ld.add_action(start_gazebo_cmd) ld.add_action(robot_state_publisher_launch) ld.add_action(spawn_entity_node) return ld
def generate_launch_description(): params_file_path = os.path.join( get_package_share_directory('qualisys_driver'), 'config', 'qualisys_driver_params.yaml') stdout_linebuf_envvar = SetEnvironmentVariable( 'RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1') # print('') # print('params_file_path: ', params_file_path) # print('') driver_node = LifecycleNode( node_name='qualisys_driver_node', package='qualisys_driver', node_executable='qualisys_driver_main', output='screen', parameters=[params_file_path], ) # Make the driver node take the 'configure' transition driver_configure_trans_event = EmitEvent(event=ChangeState( lifecycle_node_matcher=launch.events.matchers.matches_action( driver_node), transition_id=lifecycle_msgs.msg.Transition.TRANSITION_CONFIGURE, )) # Make the driver node take the 'activate' transition driver_activate_trans_event = EmitEvent(event=ChangeState( lifecycle_node_matcher=launch.events.matchers.matches_action( driver_node), transition_id=lifecycle_msgs.msg.Transition.TRANSITION_ACTIVATE, )) # Create the launch description and populate ld = LaunchDescription() ld.add_action(stdout_linebuf_envvar) ld.add_action(driver_node) ld.add_action(driver_configure_trans_event) ld.add_action(driver_activate_trans_event) return ld
def generate_launch_description(): use_sim_time = LaunchConfiguration('use_sim_time', default='false') urdf_file = os.path.join(get_package_share_directory('gbot_core'), 'urdf', 'head_2d.urdf') with open(urdf_file, 'r') as infp: urdf = infp.read() start_robot_state_publisher_node = Node(package='robot_state_publisher', executable='robot_state_publisher', name='robot_state_publisher_node', output='screen', parameters=[{ 'use_sim_time': use_sim_time, 'robot_description': urdf }]) cartographer_config_files_dir = os.path.join( get_package_share_directory('gbot_core'), 'configuration_files') start_cartographer_node = Node(package='cartographer_ros', executable='cartographer_node', name='cartographer_node', output='screen', parameters=[{ 'use_sim_time': use_sim_time }], arguments=[ '-configuration_directory', cartographer_config_files_dir, '-configuration_basename', 'gbot_lidar_2d.lua' ]) # Additional node which converts Cartographer map into ROS occupancy grid map. # Not used and can be skipped in this case start_occupancy_grid_node = Node(package='cartographer_ros', executable='occupancy_grid_node', name='cartographer_occupancy_grid_node', output='screen', parameters=[{ 'use_sim_time': use_sim_time }], arguments=['-resolution', '0.05']) ld = LaunchDescription() ld.add_action(start_robot_state_publisher_node) ld.add_action(start_cartographer_node) ld.add_action(start_occupancy_grid_node) return ld
def generate_launch_description(): ld = LaunchDescription() # add the sink node total_nodes = int(work_nodes_count) + 2 sink_node_topic_name = topic_base + '_' + str(total_nodes - 2) + '_' + str(total_nodes - 1) sink_node = Node(env=rmw_env_sub, package='mp_latency', namespace='ipc_lat', executable=exe_sink, output='screen', arguments=[ test_duration, rely_type, pub_frequency, str(total_nodes), sink_node_topic_name, rmw_sub_type, config_name ], name='sink') ld.add_action(sink_node) # add the work nodes for n in range(1, (total_nodes - 1)): this_node_name = 'work{}'.format(str(n)) from_node_topic_name = '{}_{}_{}'.format(topic_base, str(n - 1), str(n)) to_node_topic_name = '{}_{}_{}'.format(topic_base, str(n), str(n + 1)) ld.add_action( Node(package='mp_latency', namespace='ipc_lat', executable=exe_work, output='screen', arguments=[ test_duration, rely_type, str(n), from_node_topic_name, to_node_topic_name ], name=this_node_name)) # add the source node source_node_topic_name = '{}_0_1'.format(topic_base) ld.add_action( Node(package='mp_latency', namespace='ipc_lat', executable=exe_source, output='screen', arguments=[ test_duration, rely_type, pub_frequency, '0', source_node_topic_name, rmw_type ], name='source')) return ld
def generate_launch_description(): ld = LaunchDescription() duckiebot_urdf = os.path.join( get_package_share_directory('duckiebot_interface'), 'urdf', 'duckiebot.urdf') robot_state_publisher_node = Node(package='robot_state_publisher', node_name='robot_state_publisher', node_executable='robot_state_publisher', output='screen', arguments=[duckiebot_urdf]) #start wheels driver node wheels_driver_node = Node(package='dagu_car', node_name='wheels_driver_node', node_executable='wheels_driver_node', output='screen') #start LED emitter node led_emitter_node_config = os.path.join( get_package_share_directory('led_emitter'), 'config/led_emitter_node', 'LED_protocol.yaml') led_emitter_node = Node(package='led_emitter', node_name='led_emitter_node', node_executable='led_emitter_node', output='screen', parameters=[led_emitter_node_config]) #start camera node camera_node = Node(package='camera_driver', node_name='camera_node', node_executable='camera_node', output='screen') ld.add_action(robot_state_publisher_node) ld.add_action(wheels_driver_node) ld.add_action(led_emitter_node) ld.add_action(camera_node) return ld
def generate_launch_description(): ld = LaunchDescription() # Set env var to print messages to stdout immediately arg = SetEnvironmentVariable('RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1') ld.add_action(arg) driver_launch = IncludeLaunchDescription( PythonLaunchDescriptionSource(launch_file_path=PathJoinSubstitution([ FindPackageShare('bluespace_ai_xsens_mti_driver'), 'launch', 'xsens_mti_node.launch.py' ]), )) ld.add_action(driver_launch) # Rviz2 node rviz_config_path = os.path.join( get_package_share_directory('bluespace_ai_xsens_mti_driver'), 'rviz', 'display.rviz') rviz2_node = Node( package='rviz2', executable='rviz2', name='xsens_rviz2', output='screen', arguments=[["-d"], [rviz_config_path]], ) ld.add_action(rviz2_node) # Robot State Publisher node urdf_file_path = os.path.join( get_package_share_directory('bluespace_ai_xsens_mti_driver'), 'urdf', 'MTi_6xx.urdf') state_publisher_node = Node( package='robot_state_publisher', executable='robot_state_publisher', name='xsens_state_publisher', output='screen', arguments=[urdf_file_path], ) ld.add_action(state_publisher_node) return ld
def generate_launch_description(): ld = LaunchDescription() use_sim_time_cfg = LaunchConfiguration('use_sim_time', default='false') package_name = 'robot' urdf_name = "robot.urdf" package_path = FindPackageShare(package=package_name).find(package_name) launch_path = os.path.join(package_path, 'launch') urdf_path = os.path.join(package_path, 'urdf', urdf_name) params_path = os.path.join(package_path, 'config', 'params.yaml') # 调用节点 start_robot = Node(package=package_name, executable='robot', parameters=[ params_path, { 'publish_odom_transform': True }, { 'odom_frame': "/odom" } ], output='screen') robot_state_publisher_launch = IncludeLaunchDescription( PythonLaunchDescriptionSource( os.path.join(launch_path, 'robot_state_publisher.launch.py')), launch_arguments={ 'use_sim_time': use_sim_time_cfg, 'urdf_path': urdf_path }.items()) rviz_launch = IncludeLaunchDescription( PythonLaunchDescriptionSource( os.path.join(launch_path, 'rviz2.launch.py'))) # base_footprint_to_imu = Node( # package='tf2_ros', # executable='static_transform_publisher', # arguments=['-0.035', '0', '0.95', '1.57', '0', '0', 'base_footprint', 'base_imu_link'], # output='screen' # ) ld.add_action(start_robot) ld.add_action(robot_state_publisher_launch) # ld.add_action(base_footprint_to_imu) ld.add_action(rviz_launch) return ld
def generate_launch_description(): # Create the launch configuration variables model_file = LaunchConfiguration('model_file') namespace = LaunchConfiguration('namespace') params_file = LaunchConfiguration('params_file') stdout_linebuf_envvar = SetEnvironmentVariable( 'RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1') declare_model_file_cmd = DeclareLaunchArgument( 'model_file', default_value='src/ros2_planning_system/' 'plansys2_domain_expert/test/pddl/domain_simple.pddl', description='PDDL Model file') declare_namespace_cmd = DeclareLaunchArgument( 'namespace', default_value='', description='Namespace') # Specify the actions domain_expert_cmd = Node( package='plansys2_problem_expert', node_executable='problem_expert_node', node_name='problem_expert', node_namespace=namespace, output='screen', parameters=[{'model_file': model_file}, params_file]) # Create the launch description and populate ld = LaunchDescription() # Set environment variables ld.add_action(stdout_linebuf_envvar) ld.add_action(declare_model_file_cmd) ld.add_action(declare_namespace_cmd) # Declare the launch options ld.add_action(domain_expert_cmd) return ld
def generate_launch_description(): # Get the launch directory pkg_dir = get_package_share_directory('gb_manipulation') namespace = LaunchConfiguration('namespace') declare_namespace_cmd = DeclareLaunchArgument('namespace', default_value='', description='Namespace') stdout_linebuf_envvar = SetEnvironmentVariable( 'RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1') # Specify the actions pick_1_cmd = Node(package='plansys2_bt_actions', executable='bt_action_node', name='pick_1', namespace=namespace, output='screen', parameters=[ pkg_dir + '/config/params.yaml', { 'action_name': 'pick', 'bt_xml_file': pkg_dir + '/behavior_trees_xml/pick.xml' } ]) place_1_cmd = Node(package='plansys2_bt_actions', executable='bt_action_node', name='place_1', namespace=namespace, output='screen', parameters=[ pkg_dir + '/config/params.yaml', { 'action_name': 'place', 'bt_xml_file': pkg_dir + '/behavior_trees_xml/place.xml' } ]) ld = LaunchDescription() # Set environment variables ld.add_action(stdout_linebuf_envvar) ld.add_action(declare_namespace_cmd) # Declare the launch options ld.add_action(pick_1_cmd) ld.add_action(place_1_cmd) return ld
def generate_launch_description(): # Get the launch directory bringup_dir = get_package_share_directory('plansys2_bringup') config_dir = os.path.join(bringup_dir, 'params') config_file = os.path.join(config_dir, 'plansys2_params.yaml') # Create the launch configuration variables model_file = LaunchConfiguration('model_file') namespace = LaunchConfiguration('namespace') stdout_linebuf_envvar = SetEnvironmentVariable( 'RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1') declare_model_file_cmd = DeclareLaunchArgument( 'model_file', description='PDDL Model file') declare_namespace_cmd = DeclareLaunchArgument('namespace', default_value='', description='Namespace') plansys2_node_cmd = Node(package='plansys2_bringup', node_executable='plansys2_node', output='screen', node_namespace=namespace, parameters=[{ 'model_file': model_file }, config_file]) # Create the launch description and populate ld = LaunchDescription() # Set environment variables ld.add_action(stdout_linebuf_envvar) ld.add_action(declare_model_file_cmd) ld.add_action(declare_namespace_cmd) # Declare the launch options ld.add_action(plansys2_node_cmd) return ld
def generate_launch_description(): # parameter dev = LaunchConfiguration('dev') # sim = LaunchConfiguration('sim') # TODO : 現在未使用 シミュレータの切り替え用 # TODO : consai2r2_descriptionからのパラメータ読み込み declare_dev_cmd = DeclareLaunchArgument('dev', default_value='/dev/input/js0', description='joystick device file') start_joy_node_cmd = Node(package='joy', node_executable='joy_node', output='screen', parameters=[{ 'dev': dev }]) start_teleop_node_cmd = Node(package='consai2r2_teleop', node_executable='teleop_node', output='screen') start_sender_cmd = Node( package='consai2r2_sender', node_executable='sim_sender', output='screen', parameters=[ os.path.join(get_package_share_directory('consai2r2_sender'), 'config', 'grsim.yaml') ]) ld = LaunchDescription() ld.add_action(declare_dev_cmd) ld.add_action(start_joy_node_cmd) ld.add_action(start_teleop_node_cmd) ld.add_action(start_sender_cmd) return ld
def generate_launch_description(): urdf_file_name = 'vehicle.urdf' print("urdf_file_name : {}".format(urdf_file_name)) urdf_file = os.path.join( get_package_share_directory('vehicle_model'), 'urdf', urdf_file_name) rviz_display_config_file = os.path.join( get_package_share_directory('vehicle_model'), 'config', 'vehicle.rviz' ) with open(urdf_file, 'r') as infp: robot_description_file = infp.read(); ld = LaunchDescription(); robot_state_publisher = Node( package='robot_state_publisher', executable='robot_state_publisher', parameters=[ {'use_sim_time': False}, {'robot_description': robot_description_file} ], output='screen' ) joint_state_publisher_gui = Node( package='joint_state_publisher_gui', executable='joint_state_publisher_gui', output='screen' ) rviz2 = Node( package='rviz2', executable='rviz2', arguments=['-d', rviz_display_config_file], output='screen' ) ld.add_action(robot_state_publisher) ld.add_action(joint_state_publisher_gui) ld.add_action(rviz2) return ld
def generate_launch_description(): ld = LaunchDescription() arg = DeclareLaunchArgument("bagfile") # this is a bad way to get the launch file bag_file = sys.argv[-1] bag_process = ExecuteProcess( cmd=['ros2', 'bag', 'play', launch.substitutions.LaunchConfiguration("bagfile")] ) ekf_node = Node( package="robot_projects_ekf_localization", executable="ekf_localization", output={"both": "screen"}, parameters=[ {'filter_type':'ekf'} ] ) vis_node = Node( package="rviz2", executable="rviz2", arguments=["-d", os.path.join(get_package_share_directory("robot_projects_ekf_localization"), "config", "ekf_sim_world.rviz")], output={"both": "screen"} ) # get params file for eval node parameters_file_name = "ekf_evaluate_params.yaml" parameters_file_path = str(pathlib.Path(__file__).parents[1]) # get current path and go one level up parameters_file_path += '/config/' + parameters_file_name print(parameters_file_path) eval_node = Node( package="robot_projects_ekf_localization", executable="ekf_evaluation", parameters=[ parameters_file_path ] ) ld.add_action(ekf_node) ld.add_action(eval_node) ld.add_action(bag_process) ld.add_entity(vis_node) ld.add_entity(arg) return ld
def generate_launch_description(): # Webapp server node ld = LaunchDescription() remap_number_topic = ("number", "my_number") atl_ide_webappserver_node = Node( package="atl_blockly_ide_py_pkg", executable="atl_ide_webappserver_node", # name="my_number_publisher", # remappings=[ # remap_number_topic # ], parameters=[{ "webapp_port": 8080 }, { "atl_IDE_webappserver_install_dir": os.path.join(get_package_share_directory('ide_bringup'), '../../../../..', 'webapp_root/') }]) atl_ide_python_code_executor_node = Node( package="atl_blockly_ide_py_pkg", executable="atl_ide_python_code_executor_node", # name="my_number_publisher", # remappings=[ # remap_number_topic # ], parameters=[{ "number_to_publish": 4 }]) atl_ide_session_manager_node = Node( package="atl_blockly_ide_py_pkg", executable="atl_ide_session_manager_node", # name="my_number_publisher", # remappings=[ # remap_number_topic # ], parameters=[{ "number_to_publish": 4 }]) ld.add_action(atl_ide_webappserver_node) ld.add_action(atl_ide_python_code_executor_node) ld.add_action(atl_ide_session_manager_node) return ld
def generate_test_description(): launch_description = LaunchDescription() # Set the output format to a "verbose" format that is expected by the executable output launch_description.add_action( SetEnvironmentVariable( name='RCUTILS_CONSOLE_OUTPUT_FORMAT', value='[{severity}] [{name}]: {message} ' '({function_name}() at {file_name}:{line_number})')) executable = os.path.join(os.getcwd(), 'test_logging_long_messages') if os.name == 'nt': executable += '.exe' process_name = 'test_logging_long_messages' launch_description.add_action( ExecuteProcess(cmd=[executable], name=process_name, output='screen')) launch_description.add_action(launch_testing.actions.ReadyToTest()) return launch_description, {'process_name': process_name}
def generate_launch_description(): # launch paths metrobot_description_dir = get_package_share_directory( 'metrobot_description') metrobot_simulation_dir = get_package_share_directory( 'metrobot_simulation') # Create the launch configuration variables use_sim_time = LaunchConfiguration('use_sim_time', default='True') launch_gazebo_cmd = IncludeLaunchDescription( PythonLaunchDescriptionSource([ get_package_share_directory('gazebo_ros'), '/launch/gazebo.launch.py' ])) set_use_sim_time_cmd = ExecuteProcess( cmd=['ros2', 'param', 'set', '/gazebo', 'use_sim_time', use_sim_time], output='screen') launch_robot_description_cmd = IncludeLaunchDescription( PythonLaunchDescriptionSource([ metrobot_description_dir, '/launch/metrobot_description.launch.py' ]), launch_arguments={'use_sim_time': use_sim_time}.items()) spawn_robot_cmd = IncludeLaunchDescription( PythonLaunchDescriptionSource( [metrobot_simulation_dir, '/launch/spawn_metrobot.launch.py'])) ld = LaunchDescription() ld.add_action(launch_gazebo_cmd) ld.add_action(set_use_sim_time_cmd) ld.add_action(launch_robot_description_cmd) ld.add_action(spawn_robot_cmd) return ld
def generate_launch_description(): # Create the launch description and populate ld = LaunchDescription() amazon_gazebo_package_dir = get_package_share_directory( 'amazon_robot_gazebo') amazon_bringup_package_dir = get_package_share_directory( 'amazon_robot_bringup') world = LaunchConfiguration('world') # Our own gazebo world from CustomRobots declare_world_cmd = DeclareLaunchArgument( 'world', default_value=os.path.join(amazon_gazebo_package_dir, 'worlds', 'amazon_warehouse', 'amazon_robot.model'), description='Full path to world model file to load') # Default Nav2 actions # Specify the actions start_gazebo_server_cmd = ExecuteProcess(cmd=[ 'gzserver', '--verbose', '-s', 'libgazebo_ros_factory.so', '-s', 'libgazebo_ros_force_system.so', world ], output='screen') start_gazebo_client_cmd = ExecuteProcess(cmd=['gzclient'], output='screen') spawn_robot_cmd = IncludeLaunchDescription(PythonLaunchDescriptionSource( os.path.join(amazon_bringup_package_dir, 'launch', 'spawn_tb3_launch.py')), launch_arguments={ 'x_pose': '5', 'y_pose': '0', 'z_pose': '0.1', 'robot_name': 'test' }.items()) ld.add_action(spawn_robot_cmd) ld.add_action(declare_world_cmd) ld.add_action(start_gazebo_server_cmd) ld.add_action(start_gazebo_client_cmd) return ld
def generate_launch_description(): ld = LaunchDescription() use_sim_time_arg = DeclareLaunchArgument( 'use_sim_time', default_value='true', description='Use simulation (Gazebo) clock if true') urdf_path_arg = DeclareLaunchArgument('urdf_path', default_value='robot.urdf', description='urdf_path') ld.add_action(urdf_path_arg) ld.add_action(use_sim_time_arg) ld.add_action(OpaqueFunction(function=launch_setup)) return ld
def generate_launch_description(): # Get dir names pkg_share = get_package_share_directory('diffbot2_description') # Compute robot_description string xacro_file = os.path.join(pkg_share, 'urdf/diffbot2.xacro') robot_description = xacro.process(xacro_file) # Launch description launch_description = LaunchDescription() # Define parameters common_params = { 'robot_description': robot_description, } # Add nodes launch_description.add_action( launch.actions.DeclareLaunchArgument( name='namespace', default_value='', description='Node namespace' ) ) launch_description.add_action( Node( package='robot_state_publisher', executable='robot_state_publisher', name='robot_state_publisher', output='screen', namespace=LaunchConfiguration('namespace'), parameters=[common_params], ) ) launch_description.add_action( Node( package='joint_state_publisher', executable='joint_state_publisher', name='joint_state_publisher', output='screen', namespace=LaunchConfiguration('namespace'), parameters=[common_params], ), ) return launch_description
def generate_launch_description(): stdout_linebuf_envvar = SetEnvironmentVariable( 'RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1') namespace = LaunchConfiguration('namespace') params_file = LaunchConfiguration('params_file') default_action_bt_xml_filename = LaunchConfiguration( 'default_action_bt_xml_filename') declare_namespace_cmd = DeclareLaunchArgument('namespace', default_value='', description='Namespace') declare_default_bt_file_cmd = DeclareLaunchArgument( 'default_action_bt_xml_filename', default_value=os.path.join( get_package_share_directory('plansys2_executor'), 'behavior_trees', 'plansys2_action_bt.xml'), description='BT representing a PDDL action') # Specify the actions executor_cmd = Node(package='plansys2_executor', node_executable='executor_node', node_name='executor', namespace=namespace, output='screen', parameters=[{ 'default_action_bt_xml_filename': default_action_bt_xml_filename }, params_file]) # Create the launch description and populate ld = LaunchDescription() # Set environment variables ld.add_action(stdout_linebuf_envvar) ld.add_action(declare_namespace_cmd) ld.add_action(declare_default_bt_file_cmd) # Declare the launch options ld.add_action(executor_cmd) return ld
def generate_launch_description(): spawner_dir = get_package_share_directory('robot_spawner_pkg') declare_robots_file_cmd = DeclareLaunchArgument( 'robots_file', default_value=os.path.join(spawner_dir, 'tb3_swarmlab_arena.yaml')) declare_base_frame_cmd = DeclareLaunchArgument( 'base_frame', default_value='base_footprint') # Create the launch description and populate ld = LaunchDescription() # Add declarations for launch file arguments ld.add_action(declare_robots_file_cmd) ld.add_action(declare_base_frame_cmd) # The opaque function is neccesary to resolve the context of the launch file and read the LaunchDescription param at runtime ld.add_action(OpaqueFunction(function=initialize_robots)) return ld
def generate_launch_description(): ld = LaunchDescription([ LogInfo(msg = ['Launch ;'+PACKAGE_NAME]), ]) node = launch_ros.actions.LifecycleNode( node_name = PACKAGE_NAME, package = PACKAGE_NAME, node_executable = NODE_EXECUTABLE, node_namespace = NODE_NAMESPACE, parameters=[], output = 'screen', ) # When the node reaches the 'inactive' state, make it to the 'activate' evt_hwnd = launch.actions.RegisterEventHandler( launch_ros.event_handlers.OnStateTransition( target_lifecycle_node = node, goal_state='inactive', entities=[ launch.actions.LogInfo( msg = PACKAGE_NAME + " reached the 'inactive' state, 'activating'."), launch.actions.EmitEvent( event=launch_ros.events.lifecycle.ChangeState( lifecycle_node_matcher=launch.events.matches_action(node), transition_id=lifecycle_msgs.msg.Transition.TRANSITION_ACTIVATE, )), ], ) ) # Make the node take the 'configure' transition. emit_configure_transition = launch.actions.EmitEvent( event=launch_ros.events.lifecycle.ChangeState( lifecycle_node_matcher=launch.events.matches_action(node), transition_id=lifecycle_msgs.msg.Transition.TRANSITION_CONFIGURE, ) ) ld.add_action(evt_hwnd) ld.add_action(node) ld.add_action(emit_configure_transition) return ld
def generate_launch_description(): # Substitution that can access launch configuration variables. namespace = LaunchConfiguration('ns_variable') # Action that declares a new launch argument. declare_namespace_cmd = DeclareLaunchArgument( 'ns_variable', # variable name default_value='new_ns', # default value description='Top-level namespace') # description # Action that executes a ROS node. publisher_node = launch_ros.actions.Node( package='tutorial_publisher', # package name node_executable='talker', # executable file name output='log', # output is selected of log, screen, both node_name='publisher', # change node name node_namespace=namespace, # add namespace remappings=[((namespace, '/topic'), (namespace, '/new_topic')) ] # topic remapping ) # Action that executes a ROS node. subscriber_node = launch_ros.actions.Node( package='tutorial_listener', # package name node_executable='listener', # executable file name output='log', # output is selected of log, screen, both node_name='subscriber', # change node name node_namespace=namespace, # add namespace remappings=[((namespace, '/topic'), (namespace, '/new_topic')) ] # topic remapping ) # Description of a launch-able system. ld = LaunchDescription() # Add an action to the LaunchDescription. ld.add_action(declare_namespace_cmd) ld.add_action(publisher_node) ld.add_action(subscriber_node) return ld
def generate_launch_description(): #this function gets the absolute shared path of the package pkg_teleop = get_package_share_directory('teleop_twist_joy') #uncomment these to view the output #print(pkg_teleop) #file_path= os.path.join(pkg_teleop, 'launch', 'teleop-launch.py'), #print(file_path) #ld=PythonLaunchDescriptionSource(file_path) #print(ld) #the include launch description function would launch a separate launch file in another package launch_teleop = IncludeLaunchDescription( PythonLaunchDescriptionSource( os.path.join(pkg_teleop, 'launch', 'teleop-launch.py'), )) ld = LaunchDescription() #run t1 t1 = Node(package='turtlesim', namespace='turtlesim1', executable='turtlesim_node', name='sim') #run t2 t2 = Node(package='turtlesim', namespace='turtlesim2', executable='turtlesim_node', name='sim') #run mimic mimic = Node(package='turtlesim', executable='mimic', name='mimic', remappings=[ ('/input/pose', '/turtlesim1/turtle1/pose'), ('/output/cmd_vel', '/turtlesim2/turtle1/cmd_vel'), ]) ld.add_action(t1) ld.add_action(t2) ld.add_action(mimic) ld.add_action(launch_teleop) return ld