def generate_launch_description(): ld = LaunchDescription() # environment variables DRONE_DEVICE_ID = os.getenv('DRONE_DEVICE_ID') # arguments ld.add_action( DeclareLaunchArgument("rplidar_mode", default_value="outdoor")) ld.add_action( DeclareLaunchArgument("serial_port", default_value="/dev/rplidar")) # mode select for rplidar # ---------------------- # Sensitivity: optimized for longer ranger, better sensitivity but weak environment elimination # Boost: optimized for sample rate # Stability: for light elimination performance, but shorter range and lower sample rate rplidar_mode = PythonExpression([ '"Stability" if "outdoor" == "', LaunchConfiguration("rplidar_mode"), '" else "Sensitivity"' ]) #namespace declarations namespace = DRONE_DEVICE_ID # frame names fcu_frame = DRONE_DEVICE_ID + "/fcu" # the same definition is in static_tf_launch.py file rplidar_frame = DRONE_DEVICE_ID + "/rplidar" # the same definition is in static_tf_launch.py file garmin_frame = DRONE_DEVICE_ID + "/garmin" # the same definition is in static_tf_launch.py file ld.add_action( Node( namespace=namespace, package='rplidar_ros2', executable='rplidar', name='rplidar', parameters=[{ 'serial_port': LaunchConfiguration("serial_port"), 'serial_baudrate': 256000, # A3 'frame_id': rplidar_frame, 'inverted': False, 'angle_compensate': True, 'scan_mode': rplidar_mode, }], output='screen', ), ), ld.add_action( IncludeLaunchDescription( PythonLaunchDescriptionSource( [ThisLaunchFileDir(), '/static_tf_launch.py'])), ), return ld
def generate_launch_description(): gazebo = IncludeLaunchDescription( PythonLaunchDescriptionSource([ os.path.join(get_package_share_directory('gazebo_ros'), 'launch'), '/gazebo.launch.py' ]), ) gazebo_ros2_control_demos_path = os.path.join( get_package_share_directory('gazebo_ros2_control_demos')) xacro_file = os.path.join(gazebo_ros2_control_demos_path, 'urdf', 'effort_based_velocity.urdf') doc = xacro.parse(open(xacro_file)) xacro.process_doc(doc) params = {'robot_description': doc.toxml()} node_robot_state_publisher = Node(package='robot_state_publisher', executable='robot_state_publisher', output='screen', parameters=[params]) spawn_entity = Node( package='gazebo_ros', executable='spawn_entity.py', arguments=['-topic', 'robot_description', '-entity', 'cartpole'], output='screen') load_joint_state_broadcaster = ExecuteProcess(cmd=[ 'ros2', 'control', 'load_start_controller', 'joint_state_broadcaster' ], output='screen') load_effort_controller = ExecuteProcess( cmd=[ 'ros2', 'control', 'load_start_controller', 'effort_based_velocity_controller' ], output='screen', ) return LaunchDescription([ RegisterEventHandler(event_handler=OnProcessExit( target_action=spawn_entity, on_exit=[load_joint_state_broadcaster], )), RegisterEventHandler(event_handler=OnProcessExit( target_action=load_joint_state_broadcaster, on_exit=[load_effort_controller], )), gazebo, node_robot_state_publisher, spawn_entity, ])
def generate_launch_description(): """Launch the example.launch.py launch file.""" return LaunchDescription([ LogInfo(msg=[ 'Including launch file located at: ', ThisLaunchFileDir(), '/example.launch.py' ]), IncludeLaunchDescription( PythonLaunchDescriptionSource( [ThisLaunchFileDir(), '/example.launch.py'])), ])
def generate_launch_description(): ld = LaunchDescription() # Specify the actions bringup_cmd_group = GroupAction( [IncludeLaunchDescription( PythonLaunchDescriptionSource(os.path.join( get_package_share_directory('cpp_pubsub'), 'launch', 'cpp_topic.launch.py'))), IncludeLaunchDescription( PythonLaunchDescriptionSource(os.path.join( get_package_share_directory('py_pubsub'), 'py_topic.launch.py'))), # launch file for py in main share dir ] ) # Add the actions to launch all of the navigation nodes ld.add_action(bringup_cmd_group) return ld
def generate_launch_description(): # Get gazebo_ros package path sim_share_path = get_package_share_directory('arm_simulation') # Launch param server params_server = IncludeLaunchDescription( PythonLaunchDescriptionSource( os.path.join(sim_share_path, 'launch', 'params_server.launch.py')), ) # Launch arm spawner arm_spawner = IncludeLaunchDescription(PythonLaunchDescriptionSource( os.path.join(sim_share_path, 'launch', 'gazebo_spawn_arm.launch.py')), launch_arguments={ 'gym': 'True', 'gui': 'False' }.items()) # Launch forward kinematics service lobot_desc_share_path = get_package_share_directory('lobot_description') arm_urdf_path = os.path.join(lobot_desc_share_path, 'robots/arm_standalone.urdf') return LaunchDescription([params_server, arm_spawner])
def generate_launch_description(): base_launch = IncludeLaunchDescription( PythonLaunchDescriptionSource( [ThisLaunchFileDir(), "/rrbot.launch.py"]), launch_arguments={ "controllers_file": "rrbot_controllers_array.yaml", "robot_controller": "rrbot_controller", }.items(), ) return LaunchDescription([base_launch])
def generate_launch_description(): return LaunchDescription([ IncludeLaunchDescription( PythonLaunchDescriptionSource( [ThisLaunchFileDir(), '/rplidar_s1_tcp.launch.py'])), Node( package='rviz2', node_executable='rviz2', output='screen', arguments=['-d', [ThisLaunchFileDir(), '/../rviz/rplidar.rviz']], ) ])
def include(self, package, launch_file, launch_dir=None, launch_arguments=None): ''' Include another launch file ''' launch_file = self.find(package, launch_file, launch_dir) self.entity( IncludeLaunchDescription(AnyLaunchDescriptionSource(launch_file), launch_arguments=launch_arguments))
def generate_launch_description(): gazebo = IncludeLaunchDescription( PythonLaunchDescriptionSource( [PathJoinSubstitution([FindPackageShare("gazebo_ros"), "launch", "gazebo.launch.py"])] ), launch_arguments={"verbose": "false"}.items(), ) # Get URDF via xacro robot_description_content = Command( [ PathJoinSubstitution([FindExecutable(name="xacro")]), " ", PathJoinSubstitution( [ FindPackageShare("ar3_description"), "urdf", "ar3_system_position_only.urdf.xacro", ] ), " use_sim:=true", ] ) robot_description = {"robot_description": robot_description_content} node_robot_state_publisher = Node( package="robot_state_publisher", executable="robot_state_publisher", output="screen", parameters=[robot_description], ) spawn_entity = Node( package="gazebo_ros", executable="spawn_entity.py", arguments=["-topic", "robot_description", "-entity", "ar3_system_position"], output="screen", ) spawn_controller = Node( package="controller_manager", executable="spawner", arguments=["joint_state_broadcaster"], output="screen", ) return LaunchDescription( [ gazebo, node_robot_state_publisher, spawn_entity, spawn_controller, ] )
def generate_launch_description(): teleop_joy_launch = os.path.join( get_package_share_directory('teleop_twist_joy'), 'launch') napp_teleop_joy = GroupAction([ IncludeLaunchDescription(PythonLaunchDescriptionSource( os.path.join(teleop_joy_launch, 'teleop-launch.py')), launch_arguments={'joy_config': 'xbox'}.items()), ]) ld = LaunchDescription() ld.add_action(napp_teleop_joy) return ld
def generate_launch_description(): # Load Directories pkg_gazebo_ros = get_package_share_directory('gazebo_ros') marta_launch_dir = os.path.join( get_package_share_directory('marta_launch'), 'launch') rover_config_dir = os.path.join( get_package_share_directory('rover_config')) # Create urdf file from xacro and gazebo file from the package rover_config pkg_rover_config = get_package_share_directory('rover_config') xacro_model = os.path.join(pkg_rover_config, 'urdf', 'marta.xacro') urdf_model = to_urdf(xacro_model) world = LaunchConfiguration('world') world_1 = os.path.join(rover_config_dir, 'worlds', 'turtlebot3_houses', 'waffle.model') world_2 = os.path.join(pkg_gazebo_ros, 'worlds', 'empty.world') world_3 = os.path.join(rover_config_dir, 'worlds', 'empty_worlds', 'world_only.model') declare_world_cmd = DeclareLaunchArgument('world', default_value=[world_3, ''], description='SDF world file') # Gazebo launch # Starts the gzserver (handles computations) and gzclient (handles visualization) gazebo = IncludeLaunchDescription( PythonLaunchDescriptionSource( os.path.join(pkg_gazebo_ros, 'launch', 'gazebo.launch.py')), ) # Spawn rover spawn_rover_cmd = Node(package='gazebo_ros', executable='spawn_entity.py', name='spawn_entity', namespace=namespace_, output='screen', emulate_tty=True, arguments=[ '-entity', 'marta', '-x', '-1.5', '-y', '-0.5', '-z', '1', '-file', urdf_model, '-reference_frame', 'world' ]) return LaunchDescription([ # Launch Arguments declare_world_cmd, gazebo, # spawn_rover_cmd, ])
def generate_launch_description(): map_yaml_file = os.getenv('TEST_MAP') world = os.getenv('TEST_WORLD') bt_navigator_xml = os.path.join( get_package_share_directory('nav2_bt_navigator'), 'behavior_trees', os.getenv('BT_NAVIGATOR_XML')) bringup_dir = get_package_share_directory('nav2_bringup') params_file = os.path.join(bringup_dir, 'params', 'nav2_params.yaml') # Replace the `use_astar` setting on the params file param_substitutions = {'GridBased.use_astar': os.getenv('ASTAR')} configured_params = RewrittenYaml(source_file=params_file, root_key='', param_rewrites=param_substitutions, convert_types=True) return LaunchDescription([ SetEnvironmentVariable('RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1'), # Launch gazebo server for simulation ExecuteProcess(cmd=[ 'gzserver', '-s', 'libgazebo_ros_init.so', '--minimal_comms', world ], output='screen'), # TODO(orduno) Launch the robot state publisher instead # using a local copy of TB3 urdf file Node(package='tf2_ros', node_executable='static_transform_publisher', output='screen', arguments=[ '0', '0', '0', '0', '0', '0', 'base_footprint', 'base_link' ]), Node( package='tf2_ros', node_executable='static_transform_publisher', output='screen', arguments=['0', '0', '0', '0', '0', '0', 'base_link', 'base_scan']), IncludeLaunchDescription(PythonLaunchDescriptionSource( os.path.join(bringup_dir, 'launch', 'bringup_launch.py')), launch_arguments={ 'namespace': '', 'use_namespace': 'False', 'map': map_yaml_file, 'use_sim_time': 'True', 'params_file': configured_params, 'bt_xml_file': bt_navigator_xml, 'autostart': 'True' }.items()), ])
def generate_launch_description(): robot_description_content = Command([ PathJoinSubstitution([FindExecutable(name='xacro')]), " ", PathJoinSubstitution([ FindPackageShare('gazebo_ros2_control_demos'), 'urdf', 'test_gripper_mimic_joint.xacro.urdf' ]), ]) robot_description = {"robot_description": robot_description_content} node_robot_state_publisher = Node(package='robot_state_publisher', executable='robot_state_publisher', output='screen', parameters=[robot_description]) gazebo = IncludeLaunchDescription( PythonLaunchDescriptionSource( [FindPackageShare("gazebo_ros"), "/launch", "/gazebo.launch.py"]), ) spawn_entity = Node( package='gazebo_ros', executable='spawn_entity.py', arguments=['-topic', 'robot_description', '-entity', 'gripper'], output='screen') load_joint_state_controller = ExecuteProcess(cmd=[ 'ros2', 'control', 'load_controller', '--set-state', 'start', 'joint_state_broadcaster' ], output='screen') load_gripper_controller = ExecuteProcess(cmd=[ 'ros2', 'control', 'load_controller', '--set-state', 'start', 'gripper_controller' ], output='screen') return LaunchDescription([ RegisterEventHandler(event_handler=OnProcessExit( target_action=spawn_entity, on_exit=[load_joint_state_controller], )), RegisterEventHandler(event_handler=OnProcessExit( target_action=load_joint_state_controller, on_exit=[load_gripper_controller], )), gazebo, node_robot_state_publisher, spawn_entity, ])
def generate_launch_description(): return LaunchDescription([ Node( name = 'gym_node', package = 'gym_duckietown_ros2_agent', executable = 'rosagent', output = 'screen' ), Node( name = 'view_node', package = 'rqt_image_view', executable = 'rqt_image_view', #parameters = ['/lane_controller/corrected_image/compressed'], output = 'screen' ), Node( name = 'line_center_node', package = 'line_detect_center', executable = 'line_detect_center', output = 'screen' ), Node( name = 'line_right_node', package = 'line_detect_right', executable = 'line_detect_right', output = 'screen' ), Node( name = 'lanectrl_node', package = 'lane_controller', executable = 'lane_controller', output = 'screen' ), Node( name = 'statemachine_node', package = 'statemachine', executable = 'statemachine', output = 'screen' ), IncludeLaunchDescription(PythonLaunchDescriptionSource([get_package_share_directory('apriltag_ros'), '/launch/tag_16h5_all.launch.py'])), ])
def launch(shutdown_pipe, package_name, launch_file_name, launch_arguments, debug): """Launch a ROS system.""" event_loop = asyncio.new_event_loop() asyncio.set_event_loop(event_loop) # based on ros2launch/command/launch.py:main if package_name is None: single_file = True else: single_file = False get_package_prefix(package_name) path = None launch_arguments = [] if single_file: if os.path.exists(package_name): path = package_name else: raise ValueError(package_name) if launch_file_name is not None: launch_arguments.append(launch_file_name) else: try: path = get_share_file_path_from_package(package_name=package_name, file_name=launch_file_name) except PackageNotFoundError as exc: raise RuntimeError("Package '{}' not found: {}".format( package_name, exc)) except (FileNotFoundError, MultipleLaunchFilesError) as exc: raise RuntimeError(str(exc)) launch_arguments.extend(launch_arguments) launch_service = LaunchService(argv=launch_arguments, debug=debug) launch_description = LaunchDescription([ IncludeLaunchDescription( AnyLaunchDescriptionSource(path), launch_arguments={}, ), ]) launch_service.include_launch_description(launch_description) finished = False def shutdown(): while not finished and not shutdown_pipe.poll(1): pass launch_service.shutdown() t = threading.Thread(target=shutdown) t.start() launch_service.run(shutdown_when_idle=True) finished = True t.join() event_loop.close()
def generate_launch_description(): return LaunchDescription([ DeclareLaunchArgument('namespace', default_value=''), DeclareLaunchArgument('team', default_value='ijnek'), DeclareLaunchArgument('unum', default_value='2'), DeclareLaunchArgument('x', default_value='0.0'), DeclareLaunchArgument('y', default_value='0.0'), DeclareLaunchArgument('theta', default_value='0.0'), Node(package='rcss3d_nao', executable='rcss3d_nao', namespace=LaunchConfiguration('namespace'), parameters=[{ 'team': LaunchConfiguration('team'), 'unum': LaunchConfiguration('unum'), 'x': LaunchConfiguration('x'), 'y': LaunchConfiguration('y'), 'theta': LaunchConfiguration('theta') }]), IncludeLaunchDescription( PythonLaunchDescriptionSource([ get_package_share_directory('nao_state_publisher'), '/launch', '/nao_state_publisher_launch.py' ]), launch_arguments={ 'namespace': LaunchConfiguration('namespace'), }.items(), ), Node(package='static_pose_publisher', executable='static_pose_publisher', namespace=LaunchConfiguration('namespace'), parameters=[{ 'x': LaunchConfiguration('x'), 'y': LaunchConfiguration('y'), 'theta': LaunchConfiguration('theta') }]), Node( package='nao_ik', executable='ik_node', namespace=LaunchConfiguration('namespace'), ), Node( package='crouch', executable='crouch_node', namespace=LaunchConfiguration('namespace'), ), Node( package='kick', executable='kick_node', namespace=LaunchConfiguration('namespace'), ), ])
def generate_launch_description(): # Get the launch directory example_dir = get_package_share_directory('plansys2_multidomain_example') stdout_linebuf_envvar = SetEnvironmentVariable( 'RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1') 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_1/domain_1.pddl:' + example_dir + '/pddl_2/domain_2.pddl' }.items()) # Specify the actions move_cmd = Node( package='plansys2_multidomain_example', node_executable='move_action_node', node_name='move_action_node', output='screen', parameters=[]) charge_cmd = Node( package='plansys2_multidomain_example', node_executable='charge_action_node', node_name='charge_action_node', output='screen', parameters=[]) ask_charge_cmd = Node( package='plansys2_multidomain_example', node_executable='ask_charge_action_node', node_name='ask_charge_action_node', output='screen', parameters=[]) # Create the launch description and populate ld = LaunchDescription() # Set environment variables ld.add_action(stdout_linebuf_envvar) # Declare the launch options ld.add_action(plansys2_cmd) ld.add_action(move_cmd) ld.add_action(charge_cmd) ld.add_action(ask_charge_cmd) return ld
def include_launch( package: str, name: str, cond: Optional[str] = None, **kwargs, ): share = get_package_share_directory(package) launch_path = os.path.join(share, 'launch', name) return IncludeLaunchDescription( PythonLaunchDescriptionSource(launch_path), condition=IfCondition(LaunchConfiguration(cond)) if cond else None, **kwargs )
def generate_launch_description(): return LaunchDescription([ IncludeLaunchDescription( PythonLaunchDescriptionSource( [ThisLaunchFileDir(), "/start_turtlesim.launch.py"])), Node( package="dg_tutorial_with_turtlesim", node_executable="dgm_main_turtlesim_multiprocess", output="screen", prefix=['xterm -e gdb -ex=r --args'], # prefix=['xterm -hold -e'], ), ])
def generate_launch_description(): """Launch the example.launch.py launch file.""" return LaunchDescription([ LogInfo(msg=[ 'Including launch file located at: ', ThisLaunchFileDir(), '/example.launch.py' ]), IncludeLaunchDescription( PythonLaunchDescriptionSource( [ThisLaunchFileDir(), '/example.launch.py']), launch_arguments={'node_prefix': 'FOO'}.items(), ), ])
def generate_launch_description(): # Launch Arguments use_sim_time = LaunchConfiguration('use_sim_time', default=True) config_rviz2 = LaunchConfiguration('config_rviz2', default=os.path.join(get_package_share_directory('ign_moveit2'), 'launch', 'rviz.rviz')) return LaunchDescription([ # Launch Arguments DeclareLaunchArgument( 'use_sim_time', default_value=use_sim_time, description="If true, use simulated clock"), DeclareLaunchArgument( 'config_rviz2', default_value=config_rviz2, description="Path to config for RViz2"), # MoveIt2 move_group action server with necessary ROS2 <-> Ignition bridges IncludeLaunchDescription( PythonLaunchDescriptionSource( [os.path.join(get_package_share_directory('ign_moveit2'), 'launch', 'ign_moveit2.launch.py')]), launch_arguments=[('use_sim_time', use_sim_time), ('config_rviz2', config_rviz2)]), # Launch world IncludeLaunchDescription( PythonLaunchDescriptionSource( [os.path.join(get_package_share_directory('ign_moveit2'), 'launch', 'examples', 'worlds', 'world_panda_throw.launch.py')]), launch_arguments=[('use_sim_time', use_sim_time)]), # Python example script (object throwing) Node(name='ign_moveit2_example_throw', package='ign_moveit2', executable='example_throw.py', output='screen', parameters=[{'use_sim_time': use_sim_time}]) ])
def generate_launch_description(): # Path gazebo_launch_dir = os.path.join( get_package_share_directory('neuronbot2_gazebo'), 'launch') nb2slam_launch_dir = os.path.join( get_package_share_directory('neuronbot2_slam'), 'launch') # Parameters use_sim_time = LaunchConfiguration('use_sim_time', default='True') open_rviz = LaunchConfiguration('open_rviz', default='True') ## mememan_world.model / phenix_world.model world_model = LaunchConfiguration('world_model', default='mememan_world.model') neuron_app_bringup = GroupAction([ IncludeLaunchDescription(PythonLaunchDescriptionSource( os.path.join(gazebo_launch_dir, 'neuronbot2_world.launch.py')), launch_arguments={ 'use_sim_time': use_sim_time, 'world_model': world_model }.items()), IncludeLaunchDescription(PythonLaunchDescriptionSource( os.path.join(nb2slam_launch_dir, 'gmapping_launch.py')), launch_arguments={ 'use_sim_time': use_sim_time, 'open_rviz': open_rviz }.items()), ]) # Run mouse teleop mouse_teleop = Node(package='mouse_teleop', executable='mouse_teleop', remappings=[('mouse_vel', 'cmd_vel')], output='screen') ld = LaunchDescription() ld.add_action(neuron_app_bringup) ld.add_action(mouse_teleop) return ld
def generate_launch_description(): pkg_share = FindPackageShare("robot_tennis_description").find("robot_tennis_description") xacro_path = os.path.join(pkg_share,"urdf","robot.urdf.xacro") gazebo_path = os.path.join(get_package_share_directory('gazebo_ros'), "launch") gazebo_node = IncludeLaunchDescription(PythonLaunchDescriptionSource([gazebo_path, '/gazebo.launch.py'])) robot_state_publisher_node = Node(package='robot_state_publisher',executable='robot_state_publisher',parameters= [{"robot_description" : Command(["xacro"," ", xacro_path])}]) spawn_entity = Node(package='gazebo_ros', executable='spawn_entity.py',arguments=['-entity', 'robot_tennis','-topic','/robot_description']) catcher_ctrl_node = Node(package='catcher_control',executable='ctrl') return LaunchDescription([catcher_ctrl_node,robot_state_publisher_node,gazebo_node,spawn_entity])
def generate_launch_description(): config_rviz2 = os.path.join(get_package_share_directory('ecard'), 'config', 'rgbd_gaze', 'calibration', 'rviz2.rviz') return LaunchDescription([ IncludeLaunchDescription( PythonLaunchDescriptionSource([ os.path.join(get_package_share_directory('ecard'), 'launch', 'rs', 'rs_face_d415.launch.py') ]), ), IncludeLaunchDescription( PythonLaunchDescriptionSource([ os.path.join(get_package_share_directory('ecard'), 'launch', 'rgbd_gaze', 'calibration_eyeball.launch.py') ]), ), IncludeLaunchDescription(PythonLaunchDescriptionSource([ os.path.join(get_package_share_directory('ecard'), 'launch', 'rviz2.launch.py') ]), launch_arguments=[('config_rviz2', config_rviz2)]), ])
def generate_launch_description(): pkg_bringup = launch_ros.substitutions.FindPackageShare( package='nanosaur_bringup').find('nanosaur_bringup') pkg_description = launch_ros.substitutions.FindPackageShare( package='nanosaur_description').find('nanosaur_description') pkg_camera = launch_ros.substitutions.FindPackageShare( package='nanosaur_camera').find('nanosaur_camera') nanosaur_dir = LaunchConfiguration('nanosaur_dir', default=os.path.join( pkg_bringup, 'param', 'nanosaur.yml')) nanosaur_node = launch_ros.actions.Node(package='nanosaur_robot', executable='nanosaur', name='nanosaur', parameters=[nanosaur_dir], output='screen') return launch.LaunchDescription([ DeclareLaunchArgument( 'nanosaur_dir', default_value=nanosaur_dir, description='Full path to nanosaur parameter file to load'), # https://answers.ros.org/question/306935/ros2-include-a-launch-file-from-a-launch-file/ IncludeLaunchDescription( PythonLaunchDescriptionSource( [pkg_description, '/launch/description.launch.py'])), # Camera launch IncludeLaunchDescription( PythonLaunchDescriptionSource( [pkg_camera, '/launch/camera.launch.py'])), # Launch nanusaur driver nanosaur_node ]) # EOF
def generate_launch_description(): use_sim_time = LaunchConfiguration('use_sim_time', default='true') # world_file_name = 'amazon_warehouse.world' # world = os.path.join(get_package_share_directory('amazon_robot_gazebo'), 'worlds', world_file_name) # launch_file_dir = os.path.join(get_package_share_directory('amazon_robot_gazebo'), 'launch') world_file_name = 'amazon_warehouse/amazon_robot.model' world = os.path.join(get_package_share_directory('amazon_robot_gazebo'), 'worlds', world_file_name) launch_file_dir = os.path.join(get_package_share_directory('amazon_robot_gazebo'), 'launch') # sdf_file_name = 'amazon_robot2/model.sdf' # sdf = os.path.join( # get_package_share_directory('amazon_robot_gazebo'), # 'models', # sdf_file_name) # urdf_file_name = 'amazon_warehouse_robot.urdf.xacro' # urdf = os.path.join( # get_package_share_directory('amazon_robot_description'), # 'urdf', # urdf_file_name) # xml = open(sdf, 'r').read() # xml = xml.replace('"', '\\"') # swpan_args = '{name: \"amazon_robot\", xml: \"' + xml + '\" }' return LaunchDescription([ ExecuteProcess( cmd=['gazebo', '--verbose', world, '-s', 'libgazebo_ros_init.so'], output='screen'), # ExecuteProcess( # cmd=['ros2', 'param', 'set', '/gazebo', 'use_sim_time', use_sim_time], # output='screen'), IncludeLaunchDescription( PythonLaunchDescriptionSource([launch_file_dir, '/robot_state_publisher.py']), launch_arguments={'use_sim_time': use_sim_time}.items(), ), # ExecuteProcess( # cmd=['ros2', 'service', 'call', '/spawn_entity', 'gazebo_msgs/SpawnEntity', swpan_args], # output='screen'), ])
def generate_launch_description(): use_sim_time = LaunchConfiguration('use_sim_time', default='true') sdf_dir = os.path.join( get_package_share_directory('megarover_samples_ros2'), 'models/vmegarover') sdf_file = os.path.join(sdf_dir, 'vmegarover.sdf') launch_file_dir = os.path.join( get_package_share_directory('megarover_samples_ros2'), 'launch') pkg_gazebo_ros = get_package_share_directory('gazebo_ros') return LaunchDescription([ IncludeLaunchDescription( PythonLaunchDescriptionSource( os.path.join(pkg_gazebo_ros, 'launch', 'gazebo.launch.py')), ), Node(package='gazebo_ros', executable='spawn_entity.py', name='spawn_entity', output='screen', arguments=[ '-entity', 'vmegarover', '-x', '0', '-y', '0', '-z', '1', '-file', sdf_file, ]), IncludeLaunchDescription( PythonLaunchDescriptionSource( [launch_file_dir, '/robot_state_publisher.launch.py']), launch_arguments={'use_sim_time': use_sim_time}.items(), ), ])
def generate_launch_description(): # Include the default rplidar_ros launch file with default parameters. # If you need to customize any rplidar parameters uncomment and use the # the launch config below. rplidar_launchDescription = IncludeLaunchDescription( PythonLaunchDescriptionSource( os.path.join(get_package_share_directory('rplidar_ros'), 'launch', 'rplidar.launch.py')), launch_arguments={}.items()) # This launch action (node) was copied from rplidar.launch.py # rplidar_launchDescription = Node( # name='rplidar_node', # package='rplidar_ros', # executable='rplidar_composition', # output='screen', # parameters=[{ # 'serial_port': '/dev/ttyUSB0', # 'serial_baudrate': 115200, # A1 / A2 # # 'serial_baudrate': 256000, # A3 # 'frame_id': 'laser', # 'inverted': False, # 'angle_compensate': True # }], # ) gbot_ros2_no_lidar_launchDescription = IncludeLaunchDescription( PythonLaunchDescriptionSource( os.path.join(get_package_share_directory('gbot_core'), 'launch', 'gbot_ros2_no_lidar.launch.py')), launch_arguments={}.items()) ld = LaunchDescription() ld.add_action(rplidar_launchDescription) ld.add_action(gbot_ros2_no_lidar_launchDescription) return ld
def generate_launch_description(): docking_launch_dir = os.path.join(get_package_share_directory('apriltag_docking'), 'launch') neuron_app_bringup = GroupAction([ IncludeLaunchDescription( PythonLaunchDescriptionSource([docking_launch_dir, '/autodock_gazebo.launch.py']), ), ]) ld = LaunchDescription() ld.add_action(neuron_app_bringup) return ld
def generate_launch_description(): return LaunchDescription([ SetEnvironmentVariable('RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1'), #Launch from Same Package #Launch Rviz IncludeLaunchDescription(PythonLaunchDescriptionSource([ThisLaunchFileDir(), '/rviz.launch.py'])), #Launch SLAM #TODO #Launch Controller IncludeLaunchDescription(PythonLaunchDescriptionSource([ThisLaunchFileDir(), '/controller.launch.py'])), IncludeLaunchDescription(PythonLaunchDescriptionSource([ThisLaunchFileDir(), '/localization.launch.py'])), IncludeLaunchDescription(PythonLaunchDescriptionSource([ThisLaunchFileDir(), '/slam.launch.py'])), #Pull from different packages #IncludeLaunchDescription( # PythonLaunchDescriptionSource(os.path.join(launch_dir, # 'bringup_launch.py')), # launch_arguments={ # 'map': "/home/ros/willmap.yaml"}.items()), #IncludeLaunchDescription(PythonLaunchDescriptionSource(os.path.join(launch_dir, 'localization_launch.py')), ])