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
