def generate_test_description():
# Get (valid) parameters using the demo config file
servo_yaml = load_yaml('moveit_servo',
'config/panda_simulated_config.yaml')
servo_params = {'moveit_servo': servo_yaml}
param_node_valid = Node(
package='moveit_servo',
executable=PathJoinSubstitution([
LaunchConfiguration('test_binary_dir'),
'test_servo_parameters_node'
]),
output='screen',
name='valid_parameter_load',
parameters=[servo_params, {
'expect_valid_params': True
}])
param_gtest = launch_testing.actions.GTest(path=PathJoinSubstitution(
[LaunchConfiguration('test_binary_dir'), 'test_servo_parameters']),
timeout=4000.0,
output='screen')
return LaunchDescription([
launch.actions.DeclareLaunchArgument(
name='test_binary_dir',
description='Binary directory of package '
'containing test executables'), param_node_valid, param_gtest,
launch_testing.actions.ReadyToTest()
]), {
'param_node_valid': param_node_valid,
'param_gtest': param_gtest
}
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():
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():
pkg_gazebo_ros = get_package_share_directory("gazebo_ros")
# "warehouse.world".
pkg_dir = get_package_share_directory('robot_description')
os.environ["GAZEBO_MODEL_PATH"] = os.path.join(pkg_dir, "model")
#os.environ["GAZEBO_MODEL_PATH"] = "/home/kong/dev_ws/src/robot_description/model"
# world = os.path.join(pkg_dir, 'warehouse.world')
world = os.path.join(pkg_dir, 'turtlebot3.world')
gazebo = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(pkg_gazebo_ros, 'launch', 'gazebo.launch.py')), )
use_sim_time = LaunchConfiguration('use_sim_time', default='true')
# 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', 'demo', "-topic", "robot_description"],
output='screen')
#
robot_pub = Node(
package='robot_state_publisher',
executable='robot_state_publisher',
name='robot_state_publisher',
output='screen',
parameters=[{
'use_sim_time': use_sim_time
}, {
'robot_description':
Command([
PathJoinSubstitution(
[FindPackagePrefix('xacro'), "bin", "xacro"]),
' ',
PathJoinSubstitution([
get_package_share_directory('robot_description'),
'my_robot.xacro'
]),
])
}],
)
# gazebo launch
return LaunchDescription([
DeclareLaunchArgument("world",
default_value=world,
description="world description file name"),
gazebo,
robot_pub,
spawn_entity,
])
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() -> 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 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 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():
return LaunchDescription([
DeclareLaunchArgument("robot_name", default_value="robot.urdf.xacro"),
Node(
package='robot_state_publisher',
executable='robot_state_publisher',
name='robot_state_publisher',
output='screen',
parameters=[{
'robot_description':
Command([
'xacro',
' ',
PathJoinSubstitution(
[get_package_share_directory('abb_gofa_description'),
'urdf',
LaunchConfiguration('robot_name')]
)
]),
}]
),
Node(
package='joint_state_publisher_gui',
executable='joint_state_publisher_gui',
name='joint_state_publisher',
output='screen'
)
])
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 find(package, file_name, file_dir=None):
'''
Retrieve the path to a file within its share directory.
* package -- name of the package, if None then assumes an absolute file path
* file_name -- name of the file to find
* file_dir -- package directory containing the file (if None, will search the file)
If any argument is neither string nore None, assumes use of parameters and returns the corresponding Substitution
'''
# deal with non-resolvable package - cannot find anything in there
if not regular_path_elem(package):
return PathJoinSubstitution([
entry for entry in (package, file_dir, file_name)
if entry is not None
])
# resolve package
package_dir = package and get_package_share_directory(package) or None
# deal with other launch arguments
if not regular_path_elem(file_name) or not regular_path_elem(file_dir):
return PathJoinSubstitution([
entry for entry in (package_dir, file_dir, file_name)
if entry is not None
])
# below this point all arguments are strings or None
if package_dir == None:
return file_name
# do not look for it, it's (said to be) there
if file_dir is not None:
return join(package_dir, file_dir, file_name)
# look for it
from os import walk
for root, dirs, files in walk(package_dir, topdown=False):
if file_name in files:
return join(package_dir, root, file_name)
# not there
raise Exception('Could not find file {} in package {}'.format(
file_name, package))
def generate_launch_description() -> launch.LaunchDescription:
"""
Launch file to launch rqt input device.
:argument: use_sim_time, whether the node should use the simulation time as published on the /clock topic.
:argument: ping_safety_node, whether the node should regularly send an Alive message for the safety node.
"""
layout_file = [
PathJoinSubstitution([
get_package_share_directory("march_rqt_input_device"),
"config",
LaunchConfiguration("layout"),
]),
".json",
]
return launch.LaunchDescription([
DeclareLaunchArgument(
name="node_prefix",
default_value=[EnvironmentVariable("USER"), "_"],
description="Prefix for node names",
),
DeclareLaunchArgument(
name="ping_safety_node",
default_value="True",
description="Whether to ping the safety node",
),
DeclareLaunchArgument(
name="use_sim_time",
default_value="False",
description="Whether to use simulation time",
),
DeclareLaunchArgument(
name="layout",
default_value="training",
description=
"Layout .json file to use. Must be in the config directory.",
),
Node(
package="march_rqt_input_device",
executable="input_device",
output="screen",
name="input_device",
namespace="march",
parameters=[
{
"use_sim_time": LaunchConfiguration("use_sim_time")
},
{
"ping_safety_node": LaunchConfiguration("ping_safety_node")
},
{
"layout_file": layout_file
},
],
),
])
def generate_launch_description():
robot_description_content = Command([
PathJoinSubstitution([FindExecutable(name="xacro")]),
" ",
PathJoinSubstitution([
FindPackageShare("fusion2urdf_description"),
"urdf",
"fusion2urdf.xacro",
]),
])
robot_description = {"robot_description": robot_description_content}
return LaunchDescription([
Node(package='robot_state_publisher',
executable='robot_state_publisher',
name='robot_state_publisher',
output='screen',
parameters=[robot_description]),
])
def generate_launch_description():
return LaunchDescription([
Node(
package="laser_filters",
executable="scan_to_scan_filter_chain",
parameters=[
PathJoinSubstitution([
get_package_share_directory("laser_filters"),
"examples", "multiple_filters_example.yaml",
])],
)
])
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_test_description():
share_dir = FindPackageShare('diffbot2_description')
spawn_launch_path = PathJoinSubstitution(
[share_dir, 'launch', 'spawn_robot.launch.py'])
spawn_launch = IncludeLaunchDescription(
PythonLaunchDescriptionSource(spawn_launch_path),
launch_arguments={'namespace': 'ns'}.items(),
)
return (launch.LaunchDescription([
spawn_launch,
launch_testing.actions.ReadyToTest(),
]), {
'spawn_launch': spawn_launch
})
def generate_launch_description():
rocket_kaya_joy_config = PathJoinSubstitution([
FindPackageShare("rocket_kaya_teleop"),
"config",
"rocket_kaya_joy.yaml",
])
rocket_kaya_teleop_config = PathJoinSubstitution([
FindPackageShare("rocket_kaya_teleop"),
"config",
"rocket_kaya_teleop.yaml",
])
rocket_kaya_joy = Node(
package="joy",
# namespace="rocket_kaya",
executable="joy_node",
name="rocket_kaya_joy",
parameters=[rocket_kaya_joy_config],
output="both",
)
rocket_kaya_teleop = Node(
package="joy_teleop",
# namespace="rocket_kaya",
executable="joy_teleop",
name="rocket_kaya_teleop",
parameters=[rocket_kaya_teleop_config],
output="both",
)
return LaunchDescription([
rocket_kaya_joy,
rocket_kaya_teleop,
])
def generate_launch_description() -> LaunchDescription:
# Declare all launch arguments
declared_arguments = generate_declared_arguments()
# Get substitution for all arguments
robot_type = LaunchConfiguration("robot_type")
rviz_config = LaunchConfiguration("rviz_config")
use_sim_time = LaunchConfiguration("use_sim_time")
ign_verbosity = LaunchConfiguration("ign_verbosity")
log_level = LaunchConfiguration("log_level")
# List of included launch descriptions
launch_descriptions = [
# Launch world with robot (configured for this example)
IncludeLaunchDescription(
PythonLaunchDescriptionSource(
PathJoinSubstitution([
FindPackageShare("ign_moveit2_examples"),
"launch",
"default.launch.py",
])),
launch_arguments=[
("world_type", "follow_target"),
("robot_type", robot_type),
("rviz_config", rviz_config),
("use_sim_time", use_sim_time),
("ign_verbosity", ign_verbosity),
("log_level", log_level),
],
),
]
# List of nodes to be launched
nodes = [
# Run the example node (Python)
Node(
package="ign_moveit2_examples",
executable="ex_follow_target.py",
output="log",
arguments=["--ros-args", "--log-level", log_level],
parameters=[{
"use_sim_time": use_sim_time
}],
),
]
return LaunchDescription(declared_arguments + launch_descriptions + nodes)
def generate_launch_description():
position_goals = PathJoinSubstitution([
FindPackageShare("ur_robot_driver"), "config",
"test_goal_publishers_config.yaml"
])
return LaunchDescription([
Node(
package="ros2_controllers_test_nodes",
executable="publisher_joint_trajectory_controller",
name="publisher_scaled_joint_trajectory_controller",
parameters=[position_goals],
output="screen",
)
])
def generate_launch_description():
return LaunchDescription([
Node(package='robot_state_publisher',
executable='robot_state_publisher',
name='robot_state_publisher',
output='screen',
parameters=[{
'robot_description':
Command([
'xacro', ' ',
PathJoinSubstitution([
get_package_share_directory('abb_gofa_description'),
'urdf', 'robot.urdf.xacro'
])
]),
}])
])
def generate_launch_description() -> LaunchDescription:
# Declare all launch arguments
declared_arguments = generate_declared_arguments()
# Get substitution for all arguments
world = LaunchConfiguration("world")
use_sim_time = LaunchConfiguration("use_sim_time")
ign_verbosity = LaunchConfiguration("ign_verbosity")
log_level = LaunchConfiguration("log_level")
# List of included launch descriptions
launch_descriptions = [
# Launch Ignition Gazebo
IncludeLaunchDescription(
PythonLaunchDescriptionSource(
PathJoinSubstitution(
[
FindPackageShare("ros_ign_gazebo"),
"launch",
"ign_gazebo.launch.py",
]
)
),
launch_arguments=[("ign_args", [world, " -r -v ", ign_verbosity])],
),
]
# List of nodes to be launched
nodes = [
# ros_ign_bridge (clock -> ROS 2)
Node(
package="ros_ign_bridge",
executable="parameter_bridge",
output="log",
arguments=[
"/clock@rosgraph_msgs/msg/Clock[ignition.msgs.Clock",
"--ros-args",
"--log-level",
log_level,
],
parameters=[{"use_sim_time": use_sim_time}],
),
]
return LaunchDescription(declared_arguments + launch_descriptions + nodes)
def generate_test_description():
diffbot2_launch = \
PythonLaunchDescriptionSource(PathJoinSubstitution(
[FindPackageShare('diffbot2_simulation'), 'launch', 'diffbot2.launch.py']),
)
return (
LaunchDescription([
IncludeLaunchDescription(
diffbot2_launch,
launch_arguments={'namespace': 'ns', 'server_only': 'True'}.items()),
ReadyToTest(),
]),
# Test Args
{'diffbot2_launch': diffbot2_launch}
)
def generate_test_description():
share_dir = FindPackageShare('xacro_live')
spawn_launch_path = PathJoinSubstitution(
[share_dir, 'launch/xacro_live_view.launch.py'])
xacro_file_path = str(Path(__file__).parent / 'urdf/robot.xacro')
spawn_launch = IncludeLaunchDescription(
PythonLaunchDescriptionSource(spawn_launch_path),
launch_arguments={'xacro_file': xacro_file_path}.items(),
)
return (launch.LaunchDescription([
spawn_launch,
TimerAction(period=5., actions=[ReadyToTest()]),
]), {
'spawn_launch': spawn_launch
})
def generate_launch_description():
# Get rviz config
rviz_config = PathJoinSubstitution(
[FindPackageShare('diffbot2_description'), 'rviz/view_robot.rviz'])
# OBS: do not add rviz2 as dependency because it is heavy
return LaunchDescription([
DeclareLaunchArgument(name='namespace',
default_value='',
description='Node namespace'),
Node(
package='rviz2',
executable='rviz2',
name='rviz',
output='screen',
namespace=LaunchConfiguration('namespace'),
arguments=['-d', rviz_config],
)
])
def generate_launch_description():
velocity_goals = PathJoinSubstitution([
FindPackageShare("ur_bringup"), "config",
"test_velocity_goal_publishers_config.yaml"
])
return LaunchDescription([
Node(
package="ros2_control_test_nodes",
executable="publisher_forward_position_controller",
name="publisher_forward_velocity_controller",
parameters=[velocity_goals],
output={
"stdout": "screen",
"stderr": "screen",
},
)
])
def generate_launch_description() -> launch.LaunchDescription:
return launch.LaunchDescription([
DeclareLaunchArgument(
"use_sim_time",
default_value="False",
description="Whether to use simulation time",
),
DeclareLaunchArgument(
name="perspective",
default_value="full_monitor",
description="Which perspective file to use.",
),
Node(
package="rqt_gui",
executable="rqt_gui",
namespace="march/monitor",
output="screen",
arguments=[
"--perspective-file",
[
PathJoinSubstitution([
get_package_share_directory("march_monitor"),
"config",
LaunchConfiguration("perspective"),
]),
".perspective",
],
],
parameters=[{
"use_sim_time": LaunchConfiguration("use_sim_time")
}],
),
IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(
get_package_share_directory("march_rqt_robot_monitor"),
"launch",
"march_rqt_robot_monitor.launch.py",
)),
launch_arguments=[("rqt", "false")],
),
])
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():
position_goals = PathJoinSubstitution([
FindPackageShare("ros2_control_demo_bringup"),
"config",
"rrbot_joint_trajectory_publisher.yaml",
])
return LaunchDescription([
Node(
package="ros2_control_test_nodes",
executable="publisher_joint_trajectory_controller",
name="publisher_joint_trajectory_controller",
parameters=[position_goals],
output={
"stdout": "screen",
"stderr": "screen",
},
)
])