def generate_launch_description(): gazebo = IncludeLaunchDescription( PythonLaunchDescriptionSource( [FindPackageShare("gazebo_ros"), '/launch/gazebo.launch.py']), ) pkg_share = FindPackageShare('pilsbot_description').find('pilsbot_description') urdf_dir = os.path.join(pkg_share, 'urdf') xacro_file = os.path.join(urdf_dir, 'pilsbot.urdf.xacro') robot_desc = Command('xacro {}'.format(xacro_file)) params = {'robot_description': robot_desc, 'use_sim_time': True} robot_description = Node(package='robot_state_publisher', executable='robot_state_publisher', output='both', parameters=[params]) spawn_entity = Node(package='gazebo_ros', executable='spawn_entity.py', arguments=['-topic', '/robot_description', '-entity', 'pilsbot'], output='screen') return LaunchDescription([ gazebo, robot_description, spawn_entity, ])
def generate_launch_description(): pkg_share1 = FindPackageShare('robot_tennis').find('robot_tennis') pkg_share2 = FindPackageShare('gazebo_ros').find('gazebo_ros') model_file = os.path.join(pkg_share1, 'urdf', "robot_tennis.urdf") robot_state_publisher_node = Node(package="robot_state_publisher", executable="robot_state_publisher", arguments=[model_file]) rqt_robot_steering_node = Node(package="rqt_robot_steering", executable="rqt_robot_steering") # GAZEBO_MODEL_PATH has to be correctly set for Gazebo to be able to find the model spawn_entity = Node(package='gazebo_ros', executable='spawn_entity.py', arguments=[ '-entity', 'robot_tennis', '-topic', '/robot_description', '-x', '5', '-y', '5', '-z', '0' ]) robot_controller_node = Node(package="robot_tennis_controller", executable="controller") navigation_node = Node(package="robot_tennis_controller", executable="navigation") return LaunchDescription([ robot_state_publisher_node, #rviz_node, spawn_entity, rqt_robot_steering_node, robot_controller_node, navigation_node ])
def generate_launch_description(): pkg_description = FindPackageShare("scaraball_description").find( "scaraball_description") model_file = os.path.join(pkg_description, "urdf", "scaraball.urdf.xacro") pkg_gazebo = FindPackageShare("scaraball_gazebo").find("scaraball_gazebo") gazebo_path = os.path.join( FindPackageShare("gazebo_ros").find("gazebo_ros"), "launch") with open("/tmp/scaraball.urdf", "w") as stream: stream.write(xacro.process_file(model_file).toxml()) robot_state_publisher_node = Node( package='robot_state_publisher', node_executable='robot_state_publisher', arguments=["/tmp/scaraball.urdf"], output='screen', ) gazebo = IncludeLaunchDescription( PythonLaunchDescriptionSource([gazebo_path, '/gazebo.launch.py'])) # GAZEBO_MODEL_PATH has to be correctly set for Gazebo to be able to find the model spawn_entity = Node( package='gazebo_ros', node_executable='spawn_entity.py', arguments=['-entity', 'scaraball', '-topic', "/robot_description"], # arguments = ['-entity', 'my_robot', '-file', "/tmp/my_robot.urdf"], output='screen', ) return LaunchDescription( [gazebo, spawn_entity, robot_state_publisher_node])
def generate_launch_description(): def add_launch_arg(name: str, default_value=None): return DeclareLaunchArgument(name, default_value=default_value) return launch.LaunchDescription([ add_launch_arg("input_pointcloud", "/sensing/lidar/no_ground/pointcloud"), add_launch_arg("input_map", "/map/pointcloud_map"), add_launch_arg("output_clusters", "clusters"), add_launch_arg("use_pointcloud_map", "false"), add_launch_arg( "voxel_grid_param_path", [ FindPackageShare("euclidean_cluster"), "/config/voxel_grid.param.yaml" ], ), add_launch_arg( "euclidean_param_path", [ FindPackageShare("euclidean_cluster"), "/config/euclidean_cluster.param.yaml" ], ), OpaqueFunction(function=launch_setup), ])
def generate_launch_description(): pkg_share1 = FindPackageShare('robot_tennis').find('robot_tennis') pkg_share2 = FindPackageShare('gazebo_ros').find('gazebo_ros') model_file = os.path.join(pkg_share1, 'urdf', "robot_tennis.urdf") #mesh_file = os.path.join(pkg_share1, 'meshs', "pince2.dae") path = os.path.join(pkg_share2, 'launch', "gazebo.launch.py") #rviz_config_file = os.path.join(pkg_share, 'config', "display.rviz") robot_state_publisher_node = Node( package="robot_state_publisher", node_executable="robot_state_publisher", arguments=[model_file] #, mesh_file] ) rqt_robot_steering_node = Node(package="rqt_robot_steering", node_executable="rqt_robot_steering") gazebo = IncludeLaunchDescription(PythonLaunchDescriptionSource([path]), ) # GAZEBO_MODEL_PATH has to be correctly set for Gazebo to be able to find the model spawn_entity = Node( package='gazebo_ros', node_executable='spawn_entity.py', arguments=['-entity', 'robot_tennis', '-topic', '/robot_description']) return LaunchDescription([ robot_state_publisher_node, gazebo, spawn_entity, rqt_robot_steering_node ])
def generate_launch_description(): log_level = 'info' cmd_vel_mux_config = PathJoinSubstitution([ FindPackageShare('rocket_kaya_bringup'), 'config', 'rocket_kaya_cmd_vel_mux.yaml', ]) base_launch_path = PathJoinSubstitution([ FindPackageShare('rocket_kaya_controller'), 'launch', 'rocket_kaya_controller.launch.py', ]) cmd_vel_mux = Node( package='twist_mux', executable='twist_mux', name='cmd_vel_mux', # remappings=[('/cmd_vel_out', '/cmd_vel')], parameters=[cmd_vel_mux_config], output='both', arguments=['--ros-args', '--log-level', log_level], emulate_tty=True, ) base_launch = IncludeLaunchDescription( PythonLaunchDescriptionSource(base_launch_path)) return LaunchDescription([ cmd_vel_mux, base_launch, ])
def generate_launch_description(): fsm = Node(package='state_machine', executable='fsm', output='screen') #### path planner pkg_share_path_planner = FindPackageShare( package='path_planner').find('path_planner') path_planner = IncludeLaunchDescription( PythonLaunchDescriptionSource( [pkg_share_path_planner, '/launch/path_planner.launch.py']), ) #### Robot pkg_share_crabe = FindPackageShare( package='crabe_description').find('crabe_description') crabe = IncludeLaunchDescription( PythonLaunchDescriptionSource( [pkg_share_crabe, '/launch/display.launch.py']), ) #### localisation des balles pkg_share_ball_loc = FindPackageShare( package='balls_localization').find('balls_localization') ball_localization = IncludeLaunchDescription( PythonLaunchDescriptionSource( [pkg_share_ball_loc, '/launch/ball_tracking.launch.py']), ) #### Controleur """ pkg_share_controller = FindPackageShare(package='crabe_controller').find('crabe_controller') crabe_controller = IncludeLaunchDescription( PythonLaunchDescriptionSource([pkg_share_controller, '/launch/crabe_controller.launch.py']), ) """ crabe_controller = Node(package='crabe_controller', executable='controller', output='screen') #### localisation du robot """ pkg_share_crabe_loc = FindPackageShare(package='crabe_localization').find('crabe_localization') crabe_localization = IncludeLaunchDescription( PythonLaunchDescriptionSource([pkg_share_crabe_loc, '/launch/localization.launch.py']), ) """ crabe_localization = Node(package='crabe_localization', executable='localizer', output='screen') #### localisation des joueurs pkg_share_player_loc = FindPackageShare( package='player_localization').find('player_localization') player_localization = IncludeLaunchDescription( PythonLaunchDescriptionSource( [pkg_share_player_loc, '/launch/player_localization.launch.py']), ) return LaunchDescription([ fsm, path_planner, crabe, ball_localization, crabe_controller, crabe_localization, player_localization ])
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(): 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(): log_level = 'info' camera_config = PathJoinSubstitution([ FindPackageShare("rocket_kaya_vision"), "config", "vision_pipeline_d435i.yaml", ]) depth2laser_config = PathJoinSubstitution([ FindPackageShare("rocket_kaya_vision"), "config", "vision_pipeline_depth2laser.yaml", ]) rocket_kaya_camera = ComposableNode( package="realsense2_camera", plugin='realsense2_camera::RealSenseNodeFactory', name="camera", namespace="vision", parameters=[camera_config], ) depth2laser = ComposableNode( package="depthimage_to_laserscan", plugin='depthimage_to_laserscan::DepthImageToLaserScanROS', name="depth2laser", namespace="vision", parameters=[depth2laser_config], remappings=[("/vision/depth", "/vision/aligned_depth_to_color/image_raw"), ("/vision/depth_camera_info", "/vision/aligned_depth_to_color/camera_info")], ) """Generate launch description with multiple components.""" vision_pipeline = ComposableNodeContainer( name='vision_pipeline', namespace='vision', package='rclcpp_components', executable='component_container', composable_node_descriptions=[ rocket_kaya_camera, depth2laser, ], output="both", arguments=['--ros-args', '--log-level', log_level], emulate_tty=True, ) return launch.LaunchDescription([vision_pipeline])
def generate_launch_description(): nodes = [ Node( package='swiftpro', node_executable='swiftpro_write_node', node_name='swiftpro_write_node' ), Node( package='swiftpro', node_executable='swiftpro_moveit_node', node_name='swiftpro_moveit_node' ), Node( package='swiftpro', node_executable='swiftpro_rviz_node', node_name='swiftpro_rviz_node' ), ] pkg_share = FindPackageShare('swiftpro').find('swiftpro') urdf_dir = os.path.join(pkg_share, 'urdf') xacro_file = os.path.join(urdf_dir, 'pro_model.xacro') doc = xacro.process_file(xacro_file) robot_desc = doc.toprettyxml(indent=' ') params = {'robot_description': robot_desc} rsp = Node(package='robot_state_publisher', node_executable='robot_state_publisher', output='both', parameters=[params]) nodes.append(rsp) return launch.LaunchDescription(nodes)
def generate_launch_description() -> LaunchDescription: # Declare all launch arguments declared_arguments = generate_declared_arguments() # Get substitution for all arguments rviz_config = LaunchConfiguration("rviz_config") use_sim_time = LaunchConfiguration("use_sim_time") log_level = LaunchConfiguration("log_level") # List of included launch descriptions launch_descriptions = [ # Launch move_group of MoveIt 2 IncludeLaunchDescription( PythonLaunchDescriptionSource( PathJoinSubstitution( [ FindPackageShare("panda_moveit_config"), "launch", "move_group.launch.py", ] ) ), launch_arguments=[ ("ros2_control_plugin", "fake"), ("ros2_control_command_interface", "position"), ("rviz_config", rviz_config), ("use_sim_time", use_sim_time), ("log_level", log_level), ], ), ] return LaunchDescription(declared_arguments + launch_descriptions)
def get_shared_file_substitution(package_name: str, *path: List[str]) -> SomeSubstitutionsType: """Return a Substitution that resolves to the path to the given shared file.""" return PathJoinSubstitution([ FindPackageShare(package=package_name), *path, ])
def generate_launch_description(): num_samples = LaunchConfiguration('num_samples') chain_start = LaunchConfiguration('chain_start') chain_end = LaunchConfiguration('chain_end') timeout = LaunchConfiguration('timeout') pkg_share = FindPackageShare('trac_ik_examples').find('trac_ik_examples') urdf_file = os.path.join(pkg_share, 'launch', 'pr2.urdf') with open(urdf_file, 'r') as infp: robot_desc = infp.read() return LaunchDescription([ DeclareLaunchArgument('num_samples', default_value='1000'), DeclareLaunchArgument('chain_start', default_value='torso_lift_link'), DeclareLaunchArgument('chain_end', default_value='r_wrist_roll_link'), DeclareLaunchArgument('timeout', default_value='0.005'), Node( package='trac_ik_examples', executable='ik_tests', output='screen', parameters=[{ 'robot_description': robot_desc, 'num_samples': num_samples, 'chain_start': chain_start, 'chain_end': chain_end, 'timeout': timeout, }], ), ])
def generate_launch_description(): log_level = 'info' rocket_kaya_vision_config = PathJoinSubstitution( [ FindPackageShare("rocket_kaya_vision"), "config", "d435i.yaml", ] ) rocket_kaya_camera = Node( package="realsense2_camera", executable="realsense2_camera_node", namespace="camera", parameters=[rocket_kaya_vision_config], output="both", arguments=['--ros-args', '--log-level', log_level], emulate_tty=True, ) return LaunchDescription( [ rocket_kaya_camera, ] )
def generate_launch_description(): pkg_share = FindPackageShare('crane_plus_description').find('crane_plus_description') urdf_dir = os.path.join(pkg_share, 'urdf') xacro_file = os.path.join(urdf_dir, 'crane_plus.urdf.xacro') doc = xacro.process_file(xacro_file) robot_desc = doc.toprettyxml(indent=' ') params = {'robot_description': robot_desc} rsp = Node(package='robot_state_publisher', executable='robot_state_publisher', output='both', parameters=[params]) jsp = Node( package='joint_state_publisher_gui', executable='joint_state_publisher_gui', output='screen', ) rviz_config_file = get_package_share_directory( 'crane_plus_description') + '/launch/display.rviz' rviz_node = Node(package='rviz2', executable='rviz2', name='rviz2', output='log', arguments=['-d', rviz_config_file]) return LaunchDescription([rsp, jsp, rviz_node])
def generate_launch_description(): x = LaunchConfiguration('x', default='0.0') y = LaunchConfiguration('y', default='0.0') z = LaunchConfiguration('z', default='1.0') urdf_file = PathJoinSubstitution( [FindPackageShare('rexrov2_description'), 'robots', 'rexrov2_default.xacro']) gazebo = ExecuteProcess( cmd=['gazebo', '--verbose', '-s', 'libgazebo_ros_factory.so'], output='screen') rsp = Node( package='robot_state_publisher', executable='robot_state_publisher', name='robot_state_publisher', output='screen', parameters=[{ 'robot_description': Command([ ExecutableInPackage(package='xacro', executable='xacro'), ' ', urdf_file ]) }]) spawn_entity = Node( package='gazebo_ros', executable='spawn_entity.py', arguments=[ '-entity', 'rexrov2', '-topic', '/robot_description', '-x', x, '-y', y, '-z', z], output='screen') return LaunchDescription([ gazebo, rsp, spawn_entity, ])
def generate_launch_description(): urdf_path = PathJoinSubstitution([ FindPackageShare('kobuki_description'), 'urdf', 'kobuki_standalone.urdf.xacro' ]) rviz_config_path = PathJoinSubstitution( [FindPackageShare('kobuki_description'), 'rviz', 'model.rviz']) return LaunchDescription([ DeclareLaunchArgument(name='urdf', default_value=urdf_path, description='URDF path'), DeclareLaunchArgument(name='use_sim_time', default_value='false', description='Use simulation time'), DeclareLaunchArgument(name='rviz', default_value='false', description='Run rviz'), Node(package='robot_state_publisher', executable='robot_state_publisher', name='robot_state_publisher', output='screen', parameters=[{ 'use_sim_time': LaunchConfiguration('use_sim_time'), 'robot_description': Command(['xacro ', LaunchConfiguration('urdf')]) }]), Node(package='joint_state_publisher', executable='joint_state_publisher', name='joint_state_publisher', parameters=[{ 'use_sim_time': LaunchConfiguration('use_sim_time') }]), Node(package='rviz2', executable='rviz2', name='rviz2', output='screen', arguments=['-d', rviz_config_path], condition=IfCondition(LaunchConfiguration('rviz')), parameters=[{ 'use_sim_time': LaunchConfiguration('use_sim_time') }]), ])
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") rviz_config_file = os.path.join(pkg_share,"config","display.rviz") robot_state_publisher_node = Node(package="robot_state_publisher",executable="robot_state_publisher",parameters= [{"robot_description" : Command(["xacro"," ", xacro_path])}]) rviz_node = Node(package="rviz2", executable="rviz2", arguments=["-d",rviz_config_file]) joint_state_publisher_node = Node(package="joint_state_publisher_gui", executable="joint_state_publisher_gui") return LaunchDescription([robot_state_publisher_node,joint_state_publisher_node,rviz_node])
def generate_launch_description(): #Spawn robot pkg_share_2 = FindPackageShare("robot_tennis_description").find( "robot_tennis_description") xacro_path = os.path.join(pkg_share_2, "urdf", "robot.urdf.xacro") 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_description', '-topic', 'robot_description', '-x', '0', '-y', '13', '-Y', '1.57' ]) #Load catcher ctrl catcher_ctrl_node = Node(package='catcher_control', executable='ctrl') detection_balles_node = Node(package="detection_balles", executable="detection_balles") labelisation_balles_node = Node(package="labelisation_balles", executable="labelisation") #localisation_aruco_node = Node(package="localisation_aruco", executable="viewer") localisation_gps_node = Node(package="robot_control", executable="fake_gps") detection_joueurs_node = Node(package="detection_joueurs", executable="detection_joueurs") detection_balles_cage_node = Node(package="detection_balles_cage", executable="detection_balles_cage") yaw_ctrl_node = Node(package="yaw_ctrl", executable="yaw_ctrl") fake_imu_node = Node(package="yaw_ctrl", executable="fake_imu") potential_field_node = Node(package="field_command", executable="field_command") robot_control_node = Node(package="robot_control", executable="rbt_control") return LaunchDescription([ robot_state_publisher_node, spawn_entity, catcher_ctrl_node, detection_balles_node, labelisation_balles_node, #localisation_aruco_node, localisation_gps_node, detection_joueurs_node, detection_balles_cage_node, yaw_ctrl_node, fake_imu_node, potential_field_node, robot_control_node ])
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 launch_rviz(context, *args, **kwargs): examples_dir = FindPackageShare('dorna_example').find('dorna_example') sp_model = launch.substitutions.LaunchConfiguration('sp_model').perform(context) filename = "cylinders.rviz" if sp_model == "cylinders" else "cylinders2.rviz" rviz_config_file = os.path.join(examples_dir, 'config', filename) launch_rviz = launch.actions.DeclareLaunchArgument(name="rviz", default_value="False", description="Launch RViz?") rviz_cond = launch.conditions.IfCondition(launch.substitutions.LaunchConfiguration("rviz")) rviz = launch_ros.actions.Node(package='rviz2', executable='rviz2', arguments=['-d', rviz_config_file], output='screen', condition = rviz_cond) return [launch_rviz, rviz]
def generate_launch_description(): pkg_share = FindPackageShare('robot_state_publisher').find('robot_state_publisher') urdf_dir = os.path.join(pkg_share, 'urdf') xacro_file = os.path.join(urdf_dir, 'test-desc.urdf.xacro') robot_desc = launch.substitutions.Command('xacro %s' % xacro_file) params = {'robot_description': robot_desc} rsp = launch_ros.actions.Node(package='robot_state_publisher', executable='robot_state_publisher', output='both', parameters=[params]) return launch.LaunchDescription([rsp])
def generate_launch_description(): # Initialize launch description launch_description = LaunchDescription() # Declare arguments launch_description.add_action( DeclareLaunchArgument(name='xacro_file', description='Target xacro file.')) launch_description.add_action( DeclareLaunchArgument(name='rviz_config', description='Rviz config file.', default_value=PathJoinSubstitution([ FindPackageShare('xacro_live'), 'rviz/view_robot.rviz' ]))) # Add nodes launch_description.add_action( Node(package='xacro_live', executable='xacro_live', name='xacro_live', output='screen', parameters=[{ 'xacro_file': LaunchConfiguration('xacro_file') }])) launch_description.add_action( Node(package='robot_state_publisher', executable='robot_state_publisher', name='robot_state_publisher', output='screen', parameters=[{ 'robot_description': Command([ ExecutableInPackage(package='xacro', executable='xacro'), ' ', LaunchConfiguration('xacro_file') ]) }])) launch_description.add_action( Node( package='joint_state_publisher_gui', executable='joint_state_publisher_gui', name='joint_state_publisher_gui', output='screen', ), ) launch_description.add_action( Node(package='rviz2', executable='rviz2', name='rviz', output='screen', arguments=['-d', LaunchConfiguration('rviz_config')]), ) return launch_description
def generate_launch_description(): pkg_share = FindPackageShare('aplotter_ros2').find('aplotter_ros2') urdf_file = os.path.join(pkg_share, 'urdf', 'aplotter.urdf') with open(urdf_file, 'r') as infp: robot_desc = infp.read() coordinates_file = os.path.join(pkg_share, 'launch', 'coordinates.csv') joy = launch_ros.actions.Node(package='joy_linux', executable='joy_linux_node', output='both') roc = launch_ros.actions.Node(package='ros2_odrive_can', executable='odrive_can', output='both') rsp = launch_ros.actions.Node(package='robot_state_publisher', executable='robot_state_publisher', output='both', parameters=[{ "robot_description": robot_desc }, { "publish_frequency": 50.0 }]) asp = launch_ros.actions.Node( package='aplotter_ros2', executable='aplotter', output='both', parameters=[ { "control_loop_frequency": 50 }, # In hz { "left_arm_length": 361.0 }, # mm { "right_arm_pivot_length": 379.62 }, # mm { "right_arm_full_length": 567.5 }, # mm { "right_arm_offset_angle": 0.0923 }, # rad { "homed_joint_offset": 95.0 }, # mm { "mm_per_rev": 12.417 }, # rev/mm, (20/89)*pi*17.598 Measured approximately 12.8 mm per rev { "coordinates_file": coordinates_file } ]) return launch.LaunchDescription([joy, roc, rsp, asp])
def generate_launch_description(): pkg_share = FindPackageShare('aplotter_ros2').find('aplotter_ros2') urdf_file = os.path.join(pkg_share, 'urdf', 'aplotter.urdf') rsp = launch_ros.actions.Node(package='robot_state_publisher', node_executable='robot_state_publisher', output='both', arguments=[urdf_file]) asp = launch_ros.actions.Node(package='aplotter_ros2', node_executable='aplotter_state_publisher', output='both') return launch.LaunchDescription([rsp, asp])
def generate_launch_description(): pkg_share = FindPackageShare('robot_state_publisher').find('robot_state_publisher') urdf_dir = os.path.join(pkg_share, 'urdf') xacro_file = os.path.join(urdf_dir, 'test-desc.urdf.xacro') p = subprocess.Popen(['xacro', xacro_file], stdout=subprocess.PIPE, stderr=subprocess.PIPE) robot_desc, stderr = p.communicate() params = {'robot_description': robot_desc.decode('utf-8')} rsp = launch_ros.actions.Node(package='robot_state_publisher', executable='robot_state_publisher', output='both', parameters=[params]) return launch.LaunchDescription([rsp])
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 launch_setup(context, *args, **kwargs): # use_sim_time set_use_sim_time = SetParameter(name="use_sim_time", value=LaunchConfiguration("use_sim_time")) # vehicle_info vehicle_description_pkg = FindPackageShare( [LaunchConfiguration("vehicle_model"), "_description"] ).perform(context) load_vehicle_info = IncludeLaunchDescription( PythonLaunchDescriptionSource( [FindPackageShare("vehicle_info_util"), "/launch/vehicle_info.launch.py"] ), launch_arguments={ "vehicle_info_param_file": [vehicle_description_pkg, "/config/vehicle_info.param.yaml"] }.items(), ) return [ set_use_sim_time, load_vehicle_info, ]
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