def generate_launch_description():
# Get the launch directory
social_bringup_dir = get_package_share_directory('social_nav2_bringup')
pedsim_dir = get_package_share_directory('pedsim_simulator')
# nav_bringup_dir = get_package_share_directory('nav2_bringup')
launch_dir = os.path.join(social_bringup_dir, 'launch')
# Create the launch configuration variables
namespace = LaunchConfiguration('namespace')
frame_id = LaunchConfiguration('frame_id')
scene_file = LaunchConfiguration('scene_file')
simulation_factor = LaunchConfiguration('simulation_factor')
declare_frame_id_cmd = DeclareLaunchArgument('frame_id',
default_value='map',
description='Reference frame')
declare_scene_file_cmd = DeclareLaunchArgument(
'scene_file',
default_value=os.path.join(pedsim_dir, 'scenarios',
'tb3_house_demo_crowd.xml'),
description='')
declare_simulation_factor_cmd = DeclareLaunchArgument(
'simulation_factor',
default_value='0.07',
description='Simulator factor. 0.0 to get static agents')
# Specify the actions
social_nav_bringup_cmd = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(launch_dir, 'tb3_house_simulation_launch.py')))
pedsim_cmd = IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(get_package_share_directory('pedsim_simulator'), 'launch',
'simulator_launch.py')),
launch_arguments={
'scene_file':
scene_file,
'simulation_factor':
simulation_factor
}.items())
pedsim_visualizer_cmd = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(get_package_share_directory('pedsim_visualizer'),
'launch', 'visualizer_launch.py')),
launch_arguments={'frame_id': frame_id}.items())
#dummy_set_agent_action_cmd = Node(
# package='social_nav2_tooling',
# executable='dummy_set_agent_action',
# name='dummy_set_agent_action',
# output='screen'
#)
# Create the launch description and populate
ld = LaunchDescription()
# Declare the launch options
ld.add_action(declare_scene_file_cmd)
ld.add_action(declare_simulation_factor_cmd)
ld.add_action(declare_frame_id_cmd)
# ld.add_action(dummy_set_agent_action_cmd)
# Add any conditioned actions
ld.add_action(pedsim_cmd)
ld.add_action(pedsim_visualizer_cmd)
ld.add_action(social_nav_bringup_cmd)
return ld
def generate_launch_description():
# Nav needs TF. Specifically:
# ros2 run tf2_ros static_transform_publisher
# 1 2 3 0.5 0.1 -1.0 odom base_link
# ros2 run tf2_ros static_transform_publisher
# 1 2 3 0.5 0.1 -1.0 map odom
# Get the launch directory
bringup_dir = get_package_share_directory('nav2_bringup')
launch_dir = os.path.join(bringup_dir, 'launch')
# Create the launch configuration variables
slam = LaunchConfiguration('slam')
namespace = LaunchConfiguration('namespace')
use_namespace = LaunchConfiguration('use_namespace')
map_yaml_file = LaunchConfiguration('map')
use_sim_time = LaunchConfiguration('use_sim_time')
params_file = LaunchConfiguration('params_file')
default_bt_xml_filename = LaunchConfiguration('default_bt_xml_filename')
autostart = LaunchConfiguration('autostart')
# Launch configuration variables specific to simulation
rviz_config_file = LaunchConfiguration('rviz_config_file')
use_rviz = LaunchConfiguration('use_rviz')
# Declare the launch arguments
declare_namespace_cmd = DeclareLaunchArgument(
'namespace', default_value='', description='Top-level namespace')
declare_use_namespace_cmd = DeclareLaunchArgument(
'use_namespace',
default_value='false',
description='Whether to apply a namespace to the navigation stack')
declare_slam_cmd = DeclareLaunchArgument('slam',
default_value='False',
description='Whether run a SLAM')
declare_map_yaml_cmd = DeclareLaunchArgument(
'map',
# default_value=os.path.join(
# bringup_dir, 'maps', 'hadabot_world.yaml'),
default_value='./hadabot_world.yaml',
description='Full path to map file to load')
declare_use_sim_time_cmd = DeclareLaunchArgument(
'use_sim_time',
default_value='false',
description='Use simulation (Gazebo) clock if true')
declare_params_file_cmd = DeclareLaunchArgument(
'params_file',
#default_value=os.path.join(bringup_dir, 'params', 'nav2_params.yaml'),
default_value=os.path.join('/home/dsryzhov/hadabot/hadabot_rds/ros_ws',
'launch', 'nav2_params.yaml'),
description=('Full path to the ROS2 parameters file to '
'use for all launched nodes'))
declare_bt_xml_cmd = DeclareLaunchArgument(
'default_bt_xml_filename',
default_value=os.path.join(
get_package_share_directory('nav2_bt_navigator'), 'behavior_trees',
'navigate_w_replanning_and_recovery.xml'),
description='Full path to the behavior tree xml file to use')
declare_autostart_cmd = DeclareLaunchArgument(
'autostart',
default_value='true',
description='Automatically startup the nav2 stack')
declare_rviz_config_file_cmd = DeclareLaunchArgument(
'rviz_config_file',
default_value=os.path.join('.', 'rviz', 'hadabot_nav2_view.rviz'),
description='Full path to the RVIZ config file to use')
declare_use_rviz_cmd = DeclareLaunchArgument(
'use_rviz', default_value='True', description='Whether to start RVIZ')
# Specify the actions
rviz_cmd = IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(launch_dir, 'rviz_launch.py')),
condition=IfCondition(use_rviz),
launch_arguments={
'namespace': '',
'use_namespace': 'False',
'rviz_config': rviz_config_file
}.items())
nav2_bringup_cmd = IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(launch_dir, 'bringup_launch.py')),
launch_arguments={
'namespace': namespace,
'use_namespace':
use_namespace,
'slam': slam,
'map': map_yaml_file,
'use_sim_time':
use_sim_time,
'params_file': params_file,
'default_bt_xml_filename':
default_bt_xml_filename,
'autostart': autostart
}.items())
# Create the launch description and populate
ld = LaunchDescription()
# Declare the launch options
ld.add_action(declare_namespace_cmd)
ld.add_action(declare_use_namespace_cmd)
ld.add_action(declare_slam_cmd)
ld.add_action(declare_map_yaml_cmd)
ld.add_action(declare_use_sim_time_cmd)
ld.add_action(declare_params_file_cmd)
ld.add_action(declare_bt_xml_cmd)
ld.add_action(declare_autostart_cmd)
#ld.add_action(declare_rviz_config_file_cmd)
#ld.add_action(declare_use_rviz_cmd)
# Add the actions to launch all of the navigation nodes
#ld.add_action(rviz_cmd)
ld.add_action(nav2_bringup_cmd)
return ld
def generate_launch_description():
# Get the launch directory
bringup_dir = get_package_share_directory('nav2_bringup')
mod_bringup_dir = get_package_share_directory('rsb_nav2')
launch_dir = os.path.join(bringup_dir, 'launch')
# Create the launch configuration variables
slam = LaunchConfiguration('slam')
namespace_1 = LaunchConfiguration('namespace_1')
namespace_2 = LaunchConfiguration('namespace_2')
use_namespace = LaunchConfiguration('use_namespace')
map_yaml_file = LaunchConfiguration('map')
use_sim_time = LaunchConfiguration('use_sim_time')
params_file_1 = LaunchConfiguration('params_file_1')
params_file_2 = LaunchConfiguration('params_file_2')
default_bt_xml_filename = LaunchConfiguration('default_bt_xml_filename')
autostart = LaunchConfiguration('autostart')
# Launch configuration variables specific to simulation
rviz_config_file = LaunchConfiguration('rviz_config_file')
use_simulator = LaunchConfiguration('use_simulator')
use_robot_state_pub = LaunchConfiguration('use_robot_state_pub')
use_rviz = LaunchConfiguration('use_rviz')
headless = LaunchConfiguration('headless')
world = LaunchConfiguration('world')
# Map fully qualified names to relative ones so the node's namespace can be prepended.
# In case of the transforms (tf), currently, there doesn't seem to be a better alternative
# https://github.com/ros/geometry2/issues/32
# https://github.com/ros/robot_state_publisher/pull/30
# TODO(orduno) Substitute with `PushNodeRemapping`
# https://github.com/ros2/launch_ros/issues/56
remappings = [('/tf', 'tf'), ('/tf_static', 'tf_static')]
# Declare the launch arguments
declare_namespace_cmd_1 = DeclareLaunchArgument(
'namespace_1',
default_value='robot1',
description='Top-level namespace')
declare_namespace_cmd_2 = DeclareLaunchArgument(
'namespace_2',
default_value='robot2',
description='Top-level namespace')
declare_use_namespace_cmd = DeclareLaunchArgument(
'use_namespace',
default_value='True',
description='Whether to apply a namespace to the navigation stack')
declare_slam_cmd = DeclareLaunchArgument('slam',
default_value='False',
description='Whether run a SLAM')
declare_map_yaml_cmd = DeclareLaunchArgument(
'map',
default_value=os.path.join(bringup_dir, 'maps',
'turtlebot3_world.yaml'),
description='Full path to map file to load')
declare_use_sim_time_cmd = DeclareLaunchArgument(
'use_sim_time',
default_value='true',
description='Use simulation (Gazebo) clock if true')
declare_params_file_1_cmd = DeclareLaunchArgument(
'params_file_1',
default_value=os.path.join(mod_bringup_dir, 'params',
'nav2_multirobot_params_1.yaml'),
description=
'Full path to the ROS2 parameters file to use for all launched nodes')
declare_params_file_2_cmd = DeclareLaunchArgument(
'params_file_2',
default_value=os.path.join(mod_bringup_dir, 'params',
'nav2_multirobot_params_2.yaml'),
description=
'Full path to the ROS2 parameters file to use for all launched nodes')
declare_bt_xml_cmd = DeclareLaunchArgument(
'default_bt_xml_filename',
default_value=os.path.join(
get_package_share_directory('nav2_bt_navigator'), 'behavior_trees',
'navigate_w_replanning_and_recovery.xml'),
description='Full path to the behavior tree xml file to use')
declare_autostart_cmd = DeclareLaunchArgument(
'autostart',
default_value='true',
description='Automatically startup the nav2 stack')
declare_rviz_config_file_cmd = DeclareLaunchArgument(
'rviz_config_file',
default_value=os.path.join(bringup_dir, 'rviz',
'nav2_namespaced_view.rviz'),
description='Full path to the RVIZ config file to use')
declare_use_simulator_cmd = DeclareLaunchArgument(
'use_simulator',
default_value='True',
description='Whether to start the simulator')
declare_use_robot_state_pub_cmd = DeclareLaunchArgument(
'use_robot_state_pub',
default_value='True',
description='Whether to start the robot state publisher')
declare_use_rviz_cmd = DeclareLaunchArgument(
'use_rviz', default_value='True', description='Whether to start RVIZ')
declare_simulator_cmd = DeclareLaunchArgument(
'headless',
default_value='False',
description='Whether to execute gzclient)')
declare_world_cmd = DeclareLaunchArgument(
'world',
# TODO(orduno) Switch back once ROS argument passing has been fixed upstream
# https://github.com/ROBOTIS-GIT/turtlebot3_simulations/issues/91
# default_value=os.path.join(get_package_share_directory('turtlebot3_gazebo'),
# 'worlds/turtlebot3_worlds/waffle.model'),
default_value=os.path.join(mod_bringup_dir, 'worlds',
'2_tb3_world.model'),
description='Full path to world model file to load')
# Specify the actions
start_gazebo_server_cmd = ExecuteProcess(
condition=IfCondition(use_simulator),
cmd=['gzserver', '-s', 'libgazebo_ros_init.so', world],
cwd=[launch_dir],
output='screen')
start_gazebo_client_cmd = ExecuteProcess(condition=IfCondition(
PythonExpression([use_simulator, ' and not ', headless])),
cmd=['gzclient'],
cwd=[launch_dir],
output='screen')
urdf = os.path.join(bringup_dir, 'urdf', 'turtlebot3_waffle.urdf')
start_robot_state_publisher_1_cmd = Node(
condition=IfCondition(use_robot_state_pub),
package='robot_state_publisher',
executable='robot_state_publisher',
name='robot_state_publisher_1',
namespace=namespace_1,
output='screen',
parameters=[{
'use_sim_time': use_sim_time
}],
remappings=remappings,
arguments=[urdf])
start_robot_state_publisher_2_cmd = Node(
condition=IfCondition(use_robot_state_pub),
package='robot_state_publisher',
executable='robot_state_publisher',
name='robot_state_publisher_2',
namespace=namespace_2,
output='screen',
parameters=[{
'use_sim_time': use_sim_time
}],
remappings=remappings,
arguments=[urdf])
rviz_cmd_1 = IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(launch_dir, 'rviz_launch.py')),
condition=IfCondition(use_rviz),
launch_arguments={
'namespace': 'robot1',
'use_namespace': 'True',
'rviz_config': rviz_config_file
}.items())
rviz_cmd_2 = IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(launch_dir, 'rviz_launch.py')),
condition=IfCondition(use_rviz),
launch_arguments={
'namespace': 'robot2',
'use_namespace': 'True',
'rviz_config': rviz_config_file
}.items())
bringup_cmd_1 = IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(launch_dir, 'bringup_launch.py')),
launch_arguments={
'namespace': namespace_1,
'use_namespace':
use_namespace,
'slam': slam,
'map': map_yaml_file,
'use_sim_time': use_sim_time,
'params_file': params_file_1,
'default_bt_xml_filename':
default_bt_xml_filename,
'autostart': autostart
}.items())
bringup_cmd_2 = IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(launch_dir, 'bringup_launch.py')),
launch_arguments={
'namespace': namespace_2,
'use_namespace':
use_namespace,
'slam': slam,
'map': map_yaml_file,
'use_sim_time': use_sim_time,
'params_file': params_file_2,
'default_bt_xml_filename':
default_bt_xml_filename,
'autostart': autostart
}.items())
# Create the launch description and populate
ld = LaunchDescription()
# Declare the launch options
ld.add_action(declare_namespace_cmd_1)
ld.add_action(declare_namespace_cmd_2)
ld.add_action(declare_use_namespace_cmd)
ld.add_action(declare_use_namespace_cmd)
ld.add_action(declare_slam_cmd)
ld.add_action(declare_map_yaml_cmd)
ld.add_action(declare_use_sim_time_cmd)
ld.add_action(declare_params_file_1_cmd)
ld.add_action(declare_params_file_2_cmd)
ld.add_action(declare_bt_xml_cmd)
ld.add_action(declare_autostart_cmd)
ld.add_action(declare_rviz_config_file_cmd)
ld.add_action(declare_use_simulator_cmd)
ld.add_action(declare_use_robot_state_pub_cmd)
ld.add_action(declare_use_rviz_cmd)
ld.add_action(declare_simulator_cmd)
ld.add_action(declare_world_cmd)
# Add any conditioned actions
ld.add_action(start_gazebo_server_cmd)
ld.add_action(start_gazebo_client_cmd)
# Add the actions to launch all of the navigation nodes
ld.add_action(start_robot_state_publisher_1_cmd)
ld.add_action(start_robot_state_publisher_2_cmd)
ld.add_action(rviz_cmd_1)
ld.add_action(rviz_cmd_2)
ld.add_action(bringup_cmd_1)
ld.add_action(bringup_cmd_2)
return ld
def generate_launch_description():
m = launch.LaunchDescription()
use_sim_time = LaunchConfiguration('use_sim_time', default='false')
m.add_entity(use_sim_time)
param_file_name = TURTLEBOT3_MODEL + '.yaml'
# Declare the launc parameter
n = DeclareLaunchArgument('params',
default_value='c:\home',
description='Argument for child launch file')
m.add_entity(n)
run_rqt_arg = DeclareLaunchArgument(name="run_rqt",
default_value="True",
description="Launch RQT?")
m.add_entity(run_rqt_arg)
run_rviz_arg = DeclareLaunchArgument(name="run_rviz",
default_value="False",
description="Launch RVIZ?")
m.add_entity(run_rviz_arg)
#run_rqt_arg.default_value
param_dir = LaunchConfiguration(
'params',
default=os.path.join(
get_package_share_directory('turtlebot3_navigation2'), 'param',
param_file_name))
m.add_entity(param_dir)
print('param_file_name', param_file_name)
#e = param_dir.variable_name
# f=param_dir.perform(self)
l = launch.substitutions.LaunchConfiguration('params')
m.add_entity(l)
#b=e[0]
#c=b.describe()
print("zz")
print("params ", l)
b = run_rviz_arg.default_value[0].describe()
print("run_rviz_arg.default_value", b)
#print(run_rqt_arg.name," default ", run_rqt_arg.default_value[0].describe())
#print(" ")
#print("globals", globals())
#print(" ")
#print("locals",locals())
#print(" ")
#print("dir launchdescription ", dir(LaunchDescription))
#print(" ")
#print("dir launch ", dir(launch))
#c=run_rqt_arg.visit()
#print(c)
#print(" ")
print("dir m ", dir(m))
print(" ")
o = m.get_launch_arguments(False)
print("o ", o[0], o.count)
print(" zzzzz")
#d=run_rqt_arg.name
#print(d)
# d=param_dir.__format__
#print(launch.substitution.LaunchConfiguration('params') )
#print(h)
return m
def generate_launch_description():
# Get the launch directory
bringup_dir = get_package_share_directory('lesson_urdf')
launch_dir = os.path.join(bringup_dir, 'launch')
# Launch configuration variables specific to simulation
rviz_config_file = LaunchConfiguration('rviz_config_file')
use_robot_state_pub = LaunchConfiguration('use_robot_state_pub')
use_joint_state_pub = LaunchConfiguration('use_joint_state_pub')
use_rviz = LaunchConfiguration('use_rviz')
urdf_file = LaunchConfiguration('urdf_file')
declare_rviz_config_file_cmd = DeclareLaunchArgument(
'rviz_config_file',
default_value=os.path.join(bringup_dir, 'rviz', 'view.rviz'),
description='Full path to the RVIZ config file to use')
declare_use_robot_state_pub_cmd = DeclareLaunchArgument(
'use_robot_state_pub',
default_value='True',
description='Whether to start the robot state publisher')
declare_use_joint_state_pub_cmd = DeclareLaunchArgument(
'use_joint_state_pub',
default_value='True',
description='Whether to start the joint state publisher')
declare_use_rviz_cmd = DeclareLaunchArgument(
'use_rviz', default_value='True', description='Whether to start RVIZ')
declare_urdf_cmd = DeclareLaunchArgument(
'urdf_file',
default_value=os.path.join(bringup_dir, 'urdf', 'planar_3dof.urdf'),
description='Whether to start RVIZ')
start_robot_state_publisher_cmd = Node(
condition=IfCondition(use_robot_state_pub),
package='robot_state_publisher',
executable='robot_state_publisher',
name='robot_state_publisher',
output='screen',
#parameters=[{'use_sim_time': use_sim_time}],
arguments=[urdf_file])
start_joint_state_publisher_cmd = Node(
condition=IfCondition(use_joint_state_pub),
package='joint_state_publisher_gui',
executable='joint_state_publisher_gui',
name='joint_state_publisher_gui',
output='screen',
arguments=[urdf_file])
rviz_cmd = Node(condition=IfCondition(use_rviz),
package='rviz2',
executable='rviz2',
name='rviz2',
arguments=['-d', rviz_config_file],
output='screen')
# Create the launch description and populate
ld = LaunchDescription()
# Declare the launch options
ld.add_action(declare_rviz_config_file_cmd)
ld.add_action(declare_urdf_cmd)
ld.add_action(declare_use_robot_state_pub_cmd)
ld.add_action(declare_use_joint_state_pub_cmd)
ld.add_action(declare_use_rviz_cmd)
# Add any conditioned actions
ld.add_action(start_joint_state_publisher_cmd)
ld.add_action(start_robot_state_publisher_cmd)
ld.add_action(rviz_cmd)
return ld
def generate_launch_description():
# Get the launch directory
bringup_dir = get_package_share_directory('amazon_robot_bringup')
namespace = LaunchConfiguration('namespace')
map_yaml_file = LaunchConfiguration('map')
use_sim_time = LaunchConfiguration('use_sim_time')
autostart = LaunchConfiguration('autostart')
params_file = LaunchConfiguration('params_file')
lifecycle_nodes = ['map_server', 'amcl']
amazon_bringup_package_dir = get_package_share_directory(
'amazon_robot_bringup')
# Map fully qualified names to relative ones so the node's namespace can be prepended.
# In case of the transforms (tf), currently, there doesn't seem to be a better alternative
# https://github.com/ros/geometry2/issues/32
# https://github.com/ros/robot_state_publisher/pull/30
# TODO(orduno) Substitute with `PushNodeRemapping`
# https://github.com/ros2/launch_ros/issues/56
remappings = [('/tf', 'tf'), ('/tf_static', 'tf_static')]
# Create our own temporary YAML files that include substitutions
param_substitutions = {
'use_sim_time': use_sim_time,
'yaml_filename': map_yaml_file
}
configured_params = RewrittenYaml(source_file=params_file,
root_key=namespace,
param_rewrites=param_substitutions,
convert_types=True)
return LaunchDescription([
# Set env var to print messages to stdout immediately
SetEnvironmentVariable('RCUTILS_LOGGING_BUFFERED_STREAM', '1'),
DeclareLaunchArgument('namespace',
default_value='',
description='Top-level namespace'),
DeclareLaunchArgument(
'map',
default_value=os.path.join(amazon_bringup_package_dir, 'maps',
'amazon_warehouse.yaml'),
description='Full path to map yaml file to load'),
DeclareLaunchArgument(
'use_sim_time',
default_value='true',
description='Use simulation (Gazebo) clock if true'),
DeclareLaunchArgument(
'autostart',
default_value='true',
description='Automatically startup the nav2 stack'),
DeclareLaunchArgument(
'params_file',
default_value=os.path.join(bringup_dir, 'params',
'nav2_params_with_controller.yaml'),
description='Full path to the ROS2 parameters file to use'),
Node(package='nav2_map_server',
executable='map_server',
name='map_server',
output='screen',
parameters=[configured_params],
remappings=remappings),
Node(package='nav2_amcl',
executable='amcl',
name='amcl',
output='screen',
parameters=[configured_params],
remappings=remappings),
Node(package='nav2_lifecycle_manager',
executable='lifecycle_manager',
name='lifecycle_manager_localization',
output='screen',
parameters=[{
'use_sim_time': use_sim_time
}, {
'autostart': autostart
}, {
'node_names': lifecycle_nodes
}])
])
def generate_launch_description():
"""Launch example instrumented nodes."""
launch_description = LaunchDescription()
launch_description.add_action(DeclareLaunchArgument(
MEASUREMENT_PERIOD,
default_value=DEFAULT_MEASUREMENT_PERIOD_IN_MS,
description='The period (in ms) between each subsequent metrics measurement made'
' by the collector nodes'))
launch_description.add_action(DeclareLaunchArgument(
PUBLISH_PERIOD,
default_value=DEFAULT_PUBLISH_PERIOD_IN_MS,
description='The period (in ms) between each subsequent metrics message published'
' by the collector nodes'))
node_parameters = [
{MEASUREMENT_PERIOD: LaunchConfiguration(MEASUREMENT_PERIOD)},
{PUBLISH_PERIOD: LaunchConfiguration(PUBLISH_PERIOD)}]
# Collect, aggregate, and measure system CPU % used
system_cpu_node = LifecycleNode(
executable='linux_cpu_collector',
package='system_metrics_collector',
name='linux_system_cpu_collector',
namespace='',
output='screen',
parameters=node_parameters,
)
# Collect, aggregate, and measure system memory % used
system_memory_node = LifecycleNode(
executable='linux_memory_collector',
package='system_metrics_collector',
name='linux_system_memory_collector',
namespace='',
output='screen',
parameters=node_parameters,
)
# Instrument the listener demo to collect, aggregate, and publish it's CPU % + memory % used
listener_container = ComposableNodeContainer(
name='listener_container',
namespace='',
package='rclcpp_components',
executable='component_container',
composable_node_descriptions=[
ComposableNode(
package='demo_nodes_cpp',
plugin='demo_nodes_cpp::Listener',
name='listener'),
ComposableNode(
package='system_metrics_collector',
plugin='system_metrics_collector::LinuxProcessCpuMeasurementNode',
name='listener_process_cpu_node',
parameters=node_parameters,
),
ComposableNode(
package='system_metrics_collector',
plugin='system_metrics_collector::LinuxProcessMemoryMeasurementNode',
name='listener_process_memory_node',
parameters=node_parameters,
)
],
output='screen',
)
# Instrument the talker demo to collect, aggregate, and publish it's CPU % + memory % used
talker_container = ComposableNodeContainer(
name='talker_container',
namespace='',
package='rclcpp_components',
executable='component_container',
composable_node_descriptions=[
ComposableNode(
package='demo_nodes_cpp',
plugin='demo_nodes_cpp::Talker',
name='talker'),
ComposableNode(
package='system_metrics_collector',
plugin='system_metrics_collector::LinuxProcessCpuMeasurementNode',
name='talker_process_cpu_node',
parameters=node_parameters,
),
ComposableNode(
package='system_metrics_collector',
plugin='system_metrics_collector::LinuxProcessMemoryMeasurementNode',
name='talker_process_memory_node',
parameters=node_parameters,
)
],
output='screen',
)
launch_description.add_action(system_memory_node)
launch_description.add_action(system_cpu_node)
launch_description.add_action(listener_container)
launch_description.add_action(talker_container)
return launch_description
def generate_launch_description():
use_sim_time = LaunchConfiguration('use_sim_time')
package_dir = get_package_share_directory('webots_ros2_epuck')
webots = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(get_package_share_directory('webots_ros2_core'),
'launch', 'robot_launch.py')),
launch_arguments=[
('package', 'webots_ros2_epuck'),
('executable', 'driver'),
('world',
os.path.join(package_dir, 'worlds', 'rats_life_benchmark.wbt')),
],
condition=launch.conditions.IfCondition(use_sim_time))
# Launch Navigation2 without localization and without costmaps.
# As the launch file is intended for mapping comparison only (real vs. physical) we want strictly to follow the waypoints
# (without obstacle avoidance).
# This way, mapping quality is not compromised by different paths.
nav2 = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(get_package_share_directory('nav2_bringup'), 'launch',
'navigation_launch.py')),
launch_arguments=[('use_sim_time', use_sim_time),
('params_file',
os.path.join(package_dir, 'resource',
'nav2_rats_life_waypoints.yaml'))])
rviz = Node(
package='rviz2',
executable='rviz2',
name='rviz2',
arguments=['-d',
os.path.join(package_dir, 'resource', 'all.rviz')],
parameters=[{
'use_sim_time': use_sim_time
}],
output='screen')
mapper = Node(
package='webots_ros2_epuck',
executable='simple_mapper',
output='screen',
parameters=[{
'use_sim_time': use_sim_time,
'fill_map': True
}],
)
# Send the waypoints to Navigation2 package once the corresponding node is ready.
send_waypoints = ExecuteProcess(
# The goal has to be sent once the simulation is up and running.
# Therefore, we keep sending the goal until it is accepted.
cmd=[
'sleep 5;'
'while [ -z '
f'`ros2 action send_goal /FollowWaypoints nav2_msgs/action/FollowWaypoints \'{get_waypoints()}\' | grep accepted`'
']; do'
' sleep 3;'
'done'
],
shell=True)
return LaunchDescription([
webots, nav2, rviz, mapper, send_waypoints,
DeclareLaunchArgument(
'use_sim_time',
default_value='true',
description='Use simulation (Webots) clock if true')
])
def generate_launch_description():
relay_components = []
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="route_relay",
namespace="awapi",
parameters=[{
"input_topic": LaunchConfiguration("input_route"),
"output_topic": LaunchConfiguration("get_route"),
"type": "autoware_planning_msgs/msg/Route",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="predict_object_relay",
namespace="awapi",
parameters=[{
"input_topic":
LaunchConfiguration("input_object"),
"output_topic":
LaunchConfiguration("get_predicted_object"),
"type":
"autoware_perception_msgs/msg/DynamicObjectArray",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="nearest_traffic_light_relay",
namespace="awapi",
parameters=[{
"input_topic":
LaunchConfiguration("input_nearest_traffic_light_state"),
"output_topic":
LaunchConfiguration("get_nearest_traffic_light_status"),
"type":
"autoware_perception_msgs/msg/LookingTrafficLightState",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="ready_module_relay",
namespace="awapi",
parameters=[{
"input_topic":
LaunchConfiguration("input_path_change_ready"),
"output_topic":
LaunchConfiguration("get_path_change_ready"),
"type":
"autoware_planning_msgs/msg/PathChangeModule",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="force_available_relay",
namespace="awapi",
parameters=[{
"input_topic":
LaunchConfiguration("input_path_change_force_available"),
"output_topic":
LaunchConfiguration("get_path_change_force_available"),
"type":
"autoware_planning_msgs/msg/PathChangeModuleArray",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="running_modules_relay",
namespace="awapi",
parameters=[{
"input_topic":
LaunchConfiguration("input_path_change_running"),
"output_topic":
LaunchConfiguration("get_path_change_running"),
"type":
"autoware_planning_msgs/msg/PathChangeModuleArray",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="autoware_engage_relay",
namespace="awapi",
parameters=[{
"input_topic":
LaunchConfiguration("set_engage"),
"output_topic":
LaunchConfiguration("output_autoware_engage"),
"type":
"autoware_vehicle_msgs/msg/Engage",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="vehicle_engage_relay",
namespace="awapi",
parameters=[{
"input_topic":
LaunchConfiguration("set_engage"),
"output_topic":
LaunchConfiguration("output_vehicle_engage"),
"type":
"autoware_vehicle_msgs/msg/Engage",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="put_route_relay",
namespace="awapi",
parameters=[{
"input_topic": LaunchConfiguration("set_route"),
"output_topic": LaunchConfiguration("output_route"),
"type": "autoware_planning_msgs/msg/Route",
"durability": "transient_local",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="put_goal_relay",
namespace="awapi",
parameters=[{
"input_topic": LaunchConfiguration("set_goal"),
"output_topic": LaunchConfiguration("output_goal"),
"type": "geometry_msgs/msg/PoseStamped",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="lane_change_approval_relay",
namespace="awapi",
parameters=[{
"input_topic":
LaunchConfiguration("set_lane_change_approval"),
"output_topic":
LaunchConfiguration("output_lane_change_approval"),
"type":
"autoware_planning_msgs/msg/LaneChangeCommand",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="force_lane_change_relay",
namespace="awapi",
parameters=[{
"input_topic":
LaunchConfiguration("set_force_lane_change"),
"output_topic":
LaunchConfiguration("output_force_lane_change"),
"type":
"autoware_planning_msgs/msg/LaneChangeCommand",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="external_approval_relay",
namespace="awapi",
parameters=[{
"input_topic":
LaunchConfiguration("set_path_change_approval"),
"output_topic":
LaunchConfiguration("output_path_change_approval"),
"type":
"autoware_planning_msgs/msg/Approval",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="force_approval_relay",
namespace="awapi",
parameters=[{
"input_topic":
LaunchConfiguration("set_path_change_force"),
"output_topic":
LaunchConfiguration("output_path_change_force"),
"type":
"autoware_planning_msgs/msg/PathChangeModule",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="obstacle_avoid_approval_relay",
namespace="awapi",
parameters=[{
"input_topic":
LaunchConfiguration("set_obstacle_avoid_approval"),
"output_topic":
LaunchConfiguration("output_obstacle_avoid_approval"),
"type":
"autoware_planning_msgs/msg/EnableAvoidance",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="traffic_light_relay",
namespace="awapi",
parameters=[{
"input_topic":
LaunchConfiguration("input_traffic_light_state"),
"output_topic":
LaunchConfiguration("get_traffic_light_status"),
"type":
"autoware_perception_msgs/msg/TrafficLightStateArray",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="overwrite_traffic_light_state_relay",
namespace="awapi",
parameters=[{
"input_topic":
LaunchConfiguration("set_overwrite_traffic_light_state"),
"output_topic":
LaunchConfiguration("output_overwrite_traffic_light_state"),
"type":
"autoware_perception_msgs/msg/TrafficLightStateArray",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="speed_exceeded_relay",
namespace="awapi",
parameters=[{
"input_topic":
LaunchConfiguration("input_stop_speed_exceeded"),
"output_topic":
LaunchConfiguration("get_stop_speed_exceeded"),
"type":
"autoware_planning_msgs/msg/StopSpeedExceeded",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="crosswalk_status_relay",
namespace="awapi",
parameters=[{
"input_topic":
LaunchConfiguration("set_crosswalk_status"),
"output_topic":
LaunchConfiguration("input_external_crosswalk_status"),
"type":
"autoware_api_msgs/msg/CrosswalkStatus",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="intersection_status_relay",
namespace="awapi",
parameters=[{
"input_topic":
LaunchConfiguration("set_intersection_status"),
"output_topic":
LaunchConfiguration("input_external_intersection_status"),
"type":
"autoware_api_msgs/msg/IntersectionStatus",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="expand_stop_range_relay",
namespace="awapi",
parameters=[{
"input_topic":
LaunchConfiguration("set_expand_stop_range"),
"output_topic":
LaunchConfiguration("input_expand_stop_range"),
"type":
"autoware_planning_msgs/msg/ExpandStopRange",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
relay_components.append(
ComposableNode(
package="topic_tools",
plugin="topic_tools::RelayNode",
name="pose_initialization_request_relay",
namespace="awapi",
parameters=[{
"input_topic":
LaunchConfiguration("set_pose_initialization_request"),
"output_topic":
LaunchConfiguration("input_pose_initialization_request"),
"type":
"autoware_localization_msgs/msg/PoseInitializationRequest",
}],
extra_arguments=[{
"use_intra_process_comms":
LaunchConfiguration("use_intra_process")
}],
))
container = ComposableNodeContainer(
name="awapi_relay_container",
namespace="awapi",
package="rclcpp_components",
executable=LaunchConfiguration("container_executable"),
composable_node_descriptions=relay_components,
output="screen",
)
set_container_executable = SetLaunchConfiguration(
"container_executable",
"component_container",
condition=UnlessCondition(LaunchConfiguration("use_multithread")),
)
set_container_mt_executable = SetLaunchConfiguration(
"container_executable",
"component_container_mt",
condition=IfCondition(LaunchConfiguration("use_multithread")),
)
return launch.LaunchDescription(
[set_container_executable, set_container_mt_executable] + [container])
def generate_launch_description():
use_sim_time = LaunchConfiguration("use_sim_time")
robot_description = LaunchConfiguration("robot_description")
ground_gait = LaunchConfiguration("ground_gait")
realsense_simulation = LaunchConfiguration("realsense_simulation")
jointless = LaunchConfiguration("jointless")
xacro_path = PathJoinSubstitution([
get_package_share_directory("march_description"), "urdf",
robot_description
])
use_imu_data = LaunchConfiguration("use_imu_data")
imu_topic = LaunchConfiguration("imu_topic")
to_world_transform = LaunchConfiguration("to_world_transform")
simulation = LaunchConfiguration("simulation")
return LaunchDescription([
DeclareLaunchArgument(
"use_sim_time",
default_value="false",
description="Use simulation (Gazebo) clock if true",
),
DeclareLaunchArgument(
name="robot_description",
default_value="march4",
description="Which <robot_description>.xacro file to use. "
"This file must be available in the march_desrciption/urdf/ folder",
),
DeclareLaunchArgument(
name="use_imu_data",
default_value="False",
description=
"Whether the data from the physical imu should be used to"
"publish the rotation of the exoskeleton.",
),
DeclareLaunchArgument(
name="imu_topic",
default_value="/camera_front/imu/data",
description=
"The topic that should be used to determine the orientation",
),
DeclareLaunchArgument(
name="to_world_transform",
default_value="False",
description="Whether a transform from the world to base_link is "
"necessary, this is the case when you are "
"groundgaiting in rviz.",
),
DeclareLaunchArgument(
name="simulation",
default_value="False",
description="Whether the exoskeleton is ran physically or in "
"simulation.",
),
DeclareLaunchArgument(
name="realsense_simulation",
default_value="False",
description=
"Whether the simulation camera or the physical camera should be used",
),
DeclareLaunchArgument(
name="ground_gait",
default_value="False",
description="Whether the simulation should be simulating "
"ground_gaiting instead of airgaiting.",
),
DeclareLaunchArgument(
"balance",
default_value="False",
description="Whether balance is being used.",
),
DeclareLaunchArgument(
"jointless",
default_value="False",
description="If true, no joints will be actuated",
),
Node(
package="march_robot_state_publisher",
executable="march_robot_state_publisher_node",
name="robot_state_publisher",
namespace="march",
output="screen",
parameters=[{
"use_sim_time":
use_sim_time,
"robot_description":
Command([
"xacro ",
xacro_path,
".xacro",
" ground_gait:=",
ground_gait,
" realsense_simulation:=",
realsense_simulation,
" configuration:=",
("exoskeleton" if not simulation else "simulation"),
" jointless:=",
jointless,
]),
"use_imu_data":
use_imu_data,
"to_world_transform":
to_world_transform,
"imu_topic":
imu_topic,
"simulation":
simulation,
}],
),
])
def generate_launch_description():
pkg_bringup = get_package_share_directory('nanosaur_bringup')
pkg_description = get_package_share_directory('nanosaur_description')
pkg_control = get_package_share_directory('nanosaur_control')
# Load nanosaur configuration and check if are included extra parameters
# This feature is used to avoid pass configuration from docker
conf = load_config(os.path.join(pkg_bringup, 'param', 'robot.yml'))
# Load namespace from robot.yml
namespace_conf = os.getenv("HOSTNAME") if conf.get("multirobot",
False) else "nanosaur"
# Load cover_type
if "cover_type" in conf:
cover_type_conf = conf.get("cover_type", 'fisheye')
print(f"Load cover_type from robot.xml: {cover_type_conf}")
else:
cover_type_conf = os.getenv("NANOSAUR_COVER_TYPE", 'fisheye')
print(f"Load cover_type from ENV: {cover_type_conf}")
config_common_path = LaunchConfiguration('config_common_path')
namespace = LaunchConfiguration('namespace')
cover_type = LaunchConfiguration('cover_type')
declare_config_common_path_cmd = DeclareLaunchArgument(
'config_common_path',
default_value=os.path.join(pkg_bringup, 'param', 'nanosaur.yml'),
description='Path to the `nanosaur.yml` file.')
declare_namespace_cmd = DeclareLaunchArgument(
'namespace',
default_value=namespace_conf,
description=
'Enable a namespace for multiple robot. This namespace group all nodes and topics.'
)
declare_cover_type_cmd = DeclareLaunchArgument(
name='cover_type',
default_value=cover_type_conf,
description=
'Cover type to use. Options: pi, fisheye, realsense, zedmini.')
jtop_node = Node(package='jetson_stats_wrapper',
namespace=namespace,
executable='jtop',
name='jtop',
remappings=[('diagnostics', '/diagnostics')])
# System manager
system_manager = Node(package='ros2_system_manager',
namespace=namespace,
executable='system_manager',
name='system_manager')
nanosaur_base_node = Node(package='nanosaur_base',
namespace=namespace,
executable='nanosaur_base',
name='nanosaur_base',
respawn=True,
respawn_delay=5,
parameters=[config_common_path],
output='screen')
# include another launch file in nanosaur namespace
# https://docs.ros.org/en/foxy/How-To-Guides/Launch-file-different-formats.html
description_launch = GroupAction(actions=[
# push-ros-namespace to set namespace of included nodes
PushRosNamespace(namespace),
# Nanosaur description
IncludeLaunchDescription(PythonLaunchDescriptionSource(
[pkg_description, '/launch/description.launch.py']),
launch_arguments={'cover_type': cover_type
}.items())
])
# include another launch file in nanosaur namespace
twist_control_launch = GroupAction(actions=[
# push-ros-namespace to set namespace of included nodes
PushRosNamespace(namespace),
# nanosaur twist launch
IncludeLaunchDescription(
PythonLaunchDescriptionSource(
[pkg_control, '/launch/twist_control.launch.py']))
])
joy2eyes_node = Node(package='nanosaur_base',
namespace="teleop",
executable='joy2eyes',
name='joy2eyes',
remappings=[('eyes', f'/{namespace_conf}/eyes')],
output='screen')
system_manager_node = Node(package='ros2_system_manager',
namespace="teleop",
executable='joy2sm',
name='joy2sm',
parameters=[config_common_path],
remappings=[('shutdown',
f'/{namespace_conf}/shutdown')],
output='screen')
teleop_extra_node_actions = [
# push-ros-namespace to set namespace of included nodes
PushRosNamespace(namespace),
# nanosaur twist launch
system_manager_node
]
# Extra Debug packages
# - Eyes bridge
if conf.get("debug", False):
print("DEBUG variable exist - Load extra nodes")
teleop_extra_node_actions += [joy2eyes_node]
# include another launch file in nanosaur namespace
teleop_extra_nodes_launch = GroupAction(actions=teleop_extra_node_actions)
# https://answers.ros.org/question/306935/ros2-include-a-launch-file-from-a-launch-file/
# include another launch file in the chatter_ns namespace
teleop_launch = GroupAction(actions=[
# push-ros-namespace to set namespace of included nodes
PushRosNamespace(namespace),
# teleoperation launcher
IncludeLaunchDescription(PythonLaunchDescriptionSource(
[pkg_control, '/launch/teleop.launch.py']),
launch_arguments={
'joy_vel':
f"/{namespace_conf}/joy_vel",
'config_filepath':
os.path.join(pkg_control, 'config',
'ps3.nanosaur.yml')
}.items())
])
print(f"----- cover_type: {cover_type} -----")
# Define LaunchDescription variable and return it
ld = LaunchDescription()
# Namespace nanosaur
ld.add_action(declare_namespace_cmd)
# cover_type
ld.add_action(declare_cover_type_cmd)
# Nanosaur parameter yml file path
ld.add_action(declare_config_common_path_cmd)
# Nanosaur description launch
ld.add_action(description_launch)
# jtop node
ld.add_action(jtop_node)
# System manager
ld.add_action(system_manager)
# Nanusaur driver motors and display
ld.add_action(nanosaur_base_node)
# Twist control launcher
if conf.get("no_twist_mux", False):
print("Disable twist-mux")
else:
ld.add_action(twist_control_launch)
# teleoperation joystick nanosaur
# only if joystick is connected
if os.path.exists("/dev/input/js0"):
print("Enable Joystick")
# Teleoperation control
ld.add_action(teleop_launch)
# Run Joystick to system_manager node
ld.add_action(teleop_extra_nodes_launch)
return ld
def generate_launch_description(argv=sys.argv[1:]):
# Can be anything to fit your desired method of naming. Must match with client.
name1 = 'robot1'
name2 = 'robot2'
name3 = 'robot3'
name4 = 'robot4'
server_port1 = '13001'
server_port2 = '13002'
server_port3 = '13003'
server_port4 = '13004'
# Whether or not to use name as a prefix for incoming topics
use_name = 'true'
# Whether or not to encrypt and decrypt incoming and outgoing messages
use_encryption = 'true'
# Any 32 url-safe base64-encoded bytes object passed in as a string.
# This can be generated using the generate_key.py script in the main folder.
# Must match with client key.
encryption_key = 'VdzT2kwMacThZWkBigjbtte9iRjW8djEJ10JiemVwLM='
param_dir = LaunchConfiguration(
'param_dir',
default=os.path.join(
get_package_share_directory('rsb_server'),
'config',
'bringup.yaml'))
return LaunchDescription([
DeclareLaunchArgument(
'param_dir',
default_value=param_dir,
description='Full path to parameter file to load'),
launch_ros.actions.Node(
package="rsb_server",
executable="server",
name="server_node",
output="screen",
emulate_tty=True,
arguments=['-name', name1, '-p', server_port1, '-key', encryption_key, '-usename', use_name, '-encrypt', use_encryption],
parameters=[param_dir]),
launch_ros.actions.Node(
package="rsb_server",
executable="server",
name="server_node",
output="screen",
emulate_tty=True,
arguments=['-name', name2, '-p', server_port2, '-key', encryption_key, '-usename', use_name, '-encrypt', use_encryption],
parameters=[param_dir]),
launch_ros.actions.Node(
package="rsb_server",
executable="server",
name="server_node",
output="screen",
emulate_tty=True,
arguments=['-name', name3, '-p', server_port3, '-key', encryption_key, '-usename', use_name, '-encrypt', use_encryption],
parameters=[param_dir]),
launch_ros.actions.Node(
package="rsb_server",
executable="server",
name="server_node",
output="screen",
emulate_tty=True,
arguments=['-name', name4, '-p', server_port4, '-key', encryption_key, '-usename', use_name, '-encrypt', use_encryption],
parameters=[param_dir]),
])
def generate_launch_description():
xacro_path = os.path.join(get_package_share_directory('dsr_description2'),
'xacro')
drcf_path = os.path.join(get_package_share_directory('common2'),
'bin/DRCF')
# RViz2
rviz_config_file = get_package_share_directory(
'dsr_description2') + "/rviz/default.rviz"
rviz_node = Node(package='rviz2',
executable='rviz2',
name='rviz2',
output='log',
arguments=['-d', rviz_config_file])
#change_permission = ExecuteProcess(
# cmd=['chmod', '-R', '775', drcf_path],
# output='screen'
#)
# Run DRCF Emulator
DRCF_node = ExecuteProcess(cmd=['sh', [drcf_path, '/run_drcf.sh']],
output='screen',
condition=IfCondition(
PythonExpression([
"'",
LaunchConfiguration('mode'),
"' == 'virtual'"
])))
# Static TF
static_tf = Node(
package='tf2_ros',
executable='static_transform_publisher',
name='static_transform_publisher',
output='log',
arguments=['0.0', '0.0', '0.0', '0.0', '0.0', '0.0', 'base', 'base_0'])
# robot_state_publisher
robot_state_publisher = Node(
package='robot_state_publisher',
executable='robot_state_publisher',
name='robot_state_publisher',
#output='both',
output='screen',
parameters=[{
'robot_description':
Command([
'xacro', ' ', xacro_path, '/',
LaunchConfiguration('model'), '.urdf.xacro color:=',
LaunchConfiguration('color')
])
}])
# dsr_control2
dsr_control2 = Node(
package='dsr_control2',
executable='dsr_control_node2',
name='dsr_control_node2',
output='screen',
parameters=[
{
"name": LaunchConfiguration('name')
},
{
"rate": 100
},
{
"standby": 5000
},
{
"command": True
},
{
"host": LaunchConfiguration('host')
},
{
"port": LaunchConfiguration('port')
},
{
"mode": LaunchConfiguration('mode')
},
{
"model": LaunchConfiguration('model')
},
{
"gripper": "none"
},
{
"mobile": "none"
},
#parameters_file_path # 파라미터 설정을 동일이름으로 launch 파일과 yaml 파일에서 할 경우 yaml 파일로 셋팅된다.
])
# gazebo2
gazebo = IncludeLaunchDescription(
PythonLaunchDescriptionSource([
os.path.join(get_package_share_directory('gazebo_ros'), 'launch'),
'/gazebo.launch.py'
]), )
spawn_entity = Node(
package='gazebo_ros',
executable='spawn_entity.py',
arguments=['-topic', 'robot_description', '-entity', 'm1013'],
output='screen')
return LaunchDescription(args + [
#change_permission,
DRCF_node,
static_tf,
robot_state_publisher,
rviz_node,
gazebo,
spawn_entity,
dsr_control2,
])
def generate_launch_description():
use_sim_time = LaunchConfiguration('use_sim_time', default='true')
resolution = LaunchConfiguration('resolution', default='0.05')
publish_period_sec = LaunchConfiguration('publish_period_sec',
default='1.0')
pkg_gazebo_ros = get_package_share_directory('gazebo_ros')
pkg_working_gazebo = get_package_share_directory('urdf2')
# cartographer_config_dir = LaunchConfiguration('cartographer_config_dir',default=os.path.join('urdf_tutorial','config'))
# print("caerographer_config_dir:{}".format(cartographer_config_dir))
# configuration_basename = LaunchConfiguration('configuration_basename',default='myrobot_lds_4wd.lua')
# print("configuration_basename:{}".format(configuration_basename))
urdf_file_name = 'urdf/bot.urdf.xml'
print("urdf_file_name : {}".format(urdf_file_name))
urdf = os.path.join(get_package_share_directory('urdf2'), urdf_file_name)
# Gazebo launch
gazebo = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(pkg_gazebo_ros, 'launch', 'gazebo.launch.py'), ))
with open(urdf, 'r') as infp:
robot_desc = infp.read()
return LaunchDescription([
DeclareLaunchArgument(
'world',
# default_value='false',
default_value=[
os.path.join(pkg_working_gazebo, 'worlds', 'emptyworld.world'),
''
],
description='Use simulation (Gazebo) clock if true'),
DeclareLaunchArgument(
'use_sim_time',
default_value='true',
description='se simulation (Gazebo) clock if true'),
gazebo,
Node(package='robot_state_publisher',
executable='robot_state_publisher',
name='robot_state_publisher',
output='screen',
parameters=[{
'use_sim_time': use_sim_time,
'robot_description': robot_desc
}],
arguments=[urdf]),
Node(package='joint_state_publisher',
executable='joint_state_publisher',
name='joint_state_publisher',
parameters=[{
'use_sim_time': use_sim_time
}],
output='screen'),
Node(package='gazebo_ros',
executable='spawn_entity.py',
parameters=[{
'use_sim_time': use_sim_time
}],
arguments=['-topic', '/robot_description', '-entity', 'myrobot'],
output='screen'),
Node(package='cartographer_ros',
executable='cartographer_node',
name='cartographer_node',
output='screen',
parameters=[{
'use_sim_time': use_sim_time
}],
arguments=[
'-configuration_directory',
get_package_share_directory('urdf2') + '/config',
'-configuration_basename', 'myrobot_lds_4wd.lua'
]),
Node(package='cartographer_ros',
executable='occupancy_grid_node',
name='occupancy_grid_node',
output='screen',
parameters=[{
'use_sim_time': use_sim_time
}],
arguments=['-resolution', '0.05', '-publish_period_sec', '1.0']),
])
def generate_launch_description():
# Use a simpler urdf file: no forward camera, no barometer, no thrust, no drag
# Does contain a motion plugin, so the AUV will be pushed around in a repeating pattern
orca_description_dir = get_package_share_directory('orca_description')
urdf_file = os.path.join(orca_description_dir, 'urdf', 'slam_test.urdf')
# No fiducial markers
orca_gazebo_dir = get_package_share_directory('orca_gazebo')
world_file = os.path.join(orca_gazebo_dir, 'worlds', 'empty.world')
# ORB features vocabulary file
# This works well in simulation, but I'm sure how it will do in a marine environment
orb_slam_dir = get_package_share_directory('orb_slam2_ros')
orb_voc_file = os.path.join(orb_slam_dir, 'orb_slam2', 'Vocabulary', 'ORBvoc.txt')
# Orb-slam2 params
orca_bringup_dir = get_package_share_directory('orca_bringup')
slam_params_file = os.path.join(orca_bringup_dir, 'params', 'slam_test_params.yaml')
# Rviz config
rviz_cfg_file = os.path.join(orca_bringup_dir, 'cfg', 'slam_test_launch.rviz')
left_components = [
ComposableNode(
package='image_proc',
plugin='image_proc::RectifyNode',
name='left_rectify_node',
remappings=[
('image', '/stereo/left/image_raw'),
('camera_info', '/stereo/left/camera_info'),
('image_rect', '/stereo/left/image_rect')
],
),
]
right_components = [
ComposableNode(
package='image_proc',
plugin='image_proc::RectifyNode',
name='right_rectify_node',
remappings=[
('image', '/stereo/right/image_raw'),
('camera_info', '/stereo/right/camera_info'),
('image_rect', '/stereo/right/image_rect')
],
),
]
return LaunchDescription([
DeclareLaunchArgument(
'gzclient',
default_value='False',
description='Launch Gazebo UI?',
),
DeclareLaunchArgument(
'rviz',
default_value='True',
description='Launch rviz?',
),
DeclareLaunchArgument(
'rectify',
default_value='False',
description='Rectify nodes?',
),
# Launch gzserver
ExecuteProcess(
cmd=['gzserver',
'-s', 'libgazebo_ros_init.so', # Publish /clock
'-s', 'libgazebo_ros_factory.so', # Injection endpoint
world_file],
output='screen',
),
# Launch gzclient
ExecuteProcess(
cmd=['gzclient'],
output='screen',
condition=IfCondition(LaunchConfiguration('gzclient')),
),
# Launch rviz
ExecuteProcess(
cmd=['rviz2', '-d', rviz_cfg_file],
output='screen',
condition=IfCondition(LaunchConfiguration('rviz')),
),
# Replacement for base_controller: odom->base_link is static
ExecuteProcess(
cmd=['/opt/ros/foxy/lib/tf2_ros/static_transform_publisher',
'0', '0', '0', '0', '0', '0', 'odom', 'base_link',
'--ros-args', '-p', 'use_sim_time:=true'],
output='screen',
),
# Inject the urdf file
Node(
package='sim_fiducial',
executable='inject_entity.py',
output='screen',
arguments=[urdf_file, '0', '0', '0', '0', '0', '0'],
parameters=[{'use_sim_time': True}],
),
# Publish static transforms from the urdf
Node(
package='robot_state_publisher',
executable='robot_state_publisher',
output='screen',
name='robot_state_publisher',
arguments=[urdf_file],
parameters=[{'use_sim_time': True}],
),
ComposableNodeContainer(
name='left_container',
package='rclcpp_components',
executable='component_container',
namespace='',
composable_node_descriptions=left_components,
output='screen',
condition=IfCondition(LaunchConfiguration('rectify')),
),
ComposableNodeContainer(
name='right_container',
package='rclcpp_components',
executable='component_container',
namespace='',
composable_node_descriptions=right_components,
output='screen',
condition=IfCondition(LaunchConfiguration('rectify')),
),
# Run orb_slam2_ros_stereo (sans rectification)
Node(
package='orb_slam2_ros',
executable='orb_slam2_ros_stereo',
output='screen',
name='orb_slam2_stereo',
parameters=[slam_params_file, {
'voc_file': orb_voc_file,
}],
remappings=[
('/image_left/image_color_rect', '/stereo/left/image_raw'),
('/image_right/image_color_rect', '/stereo/right/image_raw'),
('/camera/camera_info', '/stereo/left/camera_info'),
],
condition=UnlessCondition(LaunchConfiguration('rectify')),
),
# Run orb_slam2_ros_stereo (mit rectification)
Node(
package='orb_slam2_ros',
executable='orb_slam2_ros_stereo',
output='screen',
name='orb_slam2_stereo',
parameters=[slam_params_file, {
'voc_file': orb_voc_file,
}],
remappings=[
('/image_left/image_color_rect', '/stereo/left/image_rect'),
('/image_right/image_color_rect', '/stereo/right/image_rect'),
('/camera/camera_info', '/stereo/left/camera_info'),
],
condition=IfCondition(LaunchConfiguration('rectify')),
),
# Run orb_slam2_localizer, a shim that publishes tf map->odom
Node(
package='orca_localize',
executable='orb_slam2_localizer',
output='screen',
name='orb_slam2_localizer',
parameters=[slam_params_file],
remappings=[
('/camera_pose', '/orb_slam2_stereo_node/pose'),
]),
])
def generate_launch_description():
ROBOT_MODEL = os.getenv('ROBOT_MODEL', 'lunar.1')
descriptions = [
DeclareLaunchArgument('imu', default_value='false'),
Node(package='imu',
executable='node',
parameters=[
LaunchConfiguration('imu_param_file',
default=os.path.join(
get_package_share_directory('imu'),
'param', ROBOT_MODEL + '.yaml'))
],
condition=IfCondition(LaunchConfiguration('imu'))),
DeclareLaunchArgument('motor', default_value='false'),
Node(package='motor',
executable='node',
parameters=[
LaunchConfiguration('motor_param_file',
default=os.path.join(
get_package_share_directory('motor'),
'param', ROBOT_MODEL + '.yaml'))
],
condition=IfCondition(LaunchConfiguration('motor'))),
DeclareLaunchArgument('lidar', default_value='false'),
Node(package='lidar',
executable='delta_lidar_node',
parameters=[
LaunchConfiguration('lidar_param_file',
default=os.path.join(
get_package_share_directory('lidar'),
'param', ROBOT_MODEL + '.yaml'))
],
condition=IfCondition(LaunchConfiguration('lidar'))),
DeclareLaunchArgument('joystick', default_value='false'),
Node(package='joystick_controller',
executable='node',
parameters=[
LaunchConfiguration(
'joystick_param_file',
default=os.path.join(
get_package_share_directory('joystick_controller'),
'param', ROBOT_MODEL + '.yaml'))
],
condition=IfCondition(LaunchConfiguration('joystick'))),
DeclareLaunchArgument('camera', default_value='false'),
Node(package='camera',
executable='node',
condition=IfCondition(LaunchConfiguration('camera'))),
DeclareLaunchArgument('localization', default_value='false'),
Node(package='robot_localization',
executable='ekf_node',
name='ekf_filter_node',
parameters=[
os.path.join(get_package_share_directory('robot'), 'param',
'robot_localization.yaml')
],
condition=IfCondition(LaunchConfiguration('localization')))
]
bridge_launch_dir = LaunchConfiguration(
'bridge_launch_dir',
default=os.path.join(get_package_share_directory('rosbridge_server'),
'launch'))
descriptions.append(
IncludeLaunchDescription(FrontendLaunchDescriptionSource(
[bridge_launch_dir, '/rosbridge_websocket_launch.xml']),
launch_arguments=[('max_message_size',
'10000000')]))
return LaunchDescription(descriptions)
def generate_launch_description():
# Get the launch directory
nav2_bringup_dir = get_package_share_directory('nav2_bringup')
cooking_dir = get_package_share_directory('plansys2_cooking_example')
cooking_launch_dir = os.path.join(cooking_dir, 'launch')
# Create the launch configuration variables
namespace = LaunchConfiguration('namespace')
use_namespace = LaunchConfiguration('use_namespace')
map_yaml_file = LaunchConfiguration('map')
use_sim_time = LaunchConfiguration('use_sim_time')
params_file = LaunchConfiguration('params_file')
default_bt_xml_file = LaunchConfiguration('default_bt_xml_file')
autostart = LaunchConfiguration('autostart')
cmd_vel_topic = LaunchConfiguration('cmd_vel_topic')
# Launch configuration variables specific to simulation
rviz_config_file = LaunchConfiguration('rviz_config_file')
use_rviz = LaunchConfiguration('use_rviz')
# Declare the launch arguments
declare_namespace_cmd = DeclareLaunchArgument(
'namespace', default_value='', description='Top-level namespace')
declare_use_namespace_cmd = DeclareLaunchArgument(
'use_namespace',
default_value='false',
description='Whether to apply a namespace to the navigation stack')
declare_map_yaml_cmd = DeclareLaunchArgument(
'map',
default_value=os.path.join(cooking_dir, 'maps', 'map.yaml'),
description='Full path to map file to load')
declare_use_sim_time_cmd = DeclareLaunchArgument(
'use_sim_time',
default_value='false',
description='Use simulation (Gazebo) clock if true')
declare_params_file_cmd = DeclareLaunchArgument(
'params_file',
default_value=os.path.join(cooking_dir, 'params',
'nav2_cooking_tiago_params.yaml'),
description=
'Full path to the ROS2 parameters file to use for all launched nodes')
# declare_params_file_cmd = DeclareLaunchArgument(
# 'params_file',
# default_value=os.path.join(nav2_bringup_dir, 'params', 'nav2_params.yaml'),
# description='Full path to the ROS2 parameters file to use for all launched nodes')
declare_bt_xml_cmd = DeclareLaunchArgument(
'default_bt_xml_file',
default_value=os.path.join(
get_package_share_directory('nav2_bt_navigator'), 'behavior_trees',
'navigate_w_replanning_and_recovery.xml'),
description='Full path to the behavior tree xml file to use')
declare_autostart_cmd = DeclareLaunchArgument(
'autostart',
default_value='true',
description='Automatically startup the nav2 stack')
declare_rviz_config_file_cmd = DeclareLaunchArgument(
'rviz_config_file',
default_value=os.path.join(nav2_bringup_dir, 'rviz',
'nav2_default_view.rviz'),
description='Full path to the RVIZ config file to use')
declare_use_rviz_cmd = DeclareLaunchArgument(
'use_rviz', default_value='True', description='Whether to start RVIZ')
declare_cmd_vel_topic_cmd = DeclareLaunchArgument(
'cmd_vel_topic',
default_value='nav_vel',
description='Command velocity topic')
start_rviz_cmd = Node(condition=IfCondition(use_rviz),
package='rviz2',
executable='rviz2',
arguments=['-d', rviz_config_file],
output='log',
remappings=[('/tf', 'tf'),
('/tf_static', 'tf_static'),
('goal_pose', 'goal_pose'),
('/clicked_point', 'clicked_point'),
('/initialpose', 'initialpose')])
exit_event_handler = RegisterEventHandler(
event_handler=OnProcessExit(target_action=start_rviz_cmd,
on_exit=EmitEvent(event=Shutdown(
reason='rviz exited'))))
bringup_cmd = IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(cooking_launch_dir, 'nav2_bringup_launch.py')),
launch_arguments={
'namespace': namespace,
'use_namespace': use_namespace,
'map': map_yaml_file,
'use_sim_time': use_sim_time,
'params_file': params_file,
'bt_xml_file':
default_bt_xml_file,
'autostart': autostart,
'cmd_vel_topic': cmd_vel_topic
}.items())
# contextual_cmd = IncludeLaunchDescription(
# PythonLaunchDescriptionSource(os.path.join(cooking_launch_dir, 'nav2_contextual_launch.py')),
# launch_arguments={'next_wp': '0'}.items())
# Create the launch description and populate
ld = LaunchDescription()
# Declare the launch options
ld.add_action(declare_namespace_cmd)
ld.add_action(declare_use_namespace_cmd)
ld.add_action(declare_map_yaml_cmd)
ld.add_action(declare_use_sim_time_cmd)
ld.add_action(declare_params_file_cmd)
ld.add_action(declare_bt_xml_cmd)
ld.add_action(declare_autostart_cmd)
ld.add_action(declare_rviz_config_file_cmd)
ld.add_action(declare_use_rviz_cmd)
ld.add_action(declare_cmd_vel_topic_cmd)
# Add any conditioned actions
ld.add_action(start_rviz_cmd)
# Add other nodes and processes we need
ld.add_action(exit_event_handler)
# ld.add_action(contextual_cmd)
# Add the actions to launch all of the navigation nodes
ld.add_action(bringup_cmd)
return ld
def generate_launch_description():
composable_nodes = [
ComposableNode(
package='stereo_image_proc',
plugin='stereo_image_proc::DisparityNode',
parameters=[{
'approximate_sync':
LaunchConfiguration('approximate_sync'),
'use_system_default_qos':
LaunchConfiguration('use_system_default_qos'),
'stereo_algorithm':
LaunchConfiguration('stereo_algorithm'),
'prefilter_size':
LaunchConfiguration('prefilter_size'),
'prefilter_cap':
LaunchConfiguration('prefilter_cap'),
'correlation_window_size':
LaunchConfiguration('correlation_window_size'),
'min_disparity':
LaunchConfiguration('min_disparity'),
'disparity_range':
LaunchConfiguration('disparity_range'),
'texture_threshold':
LaunchConfiguration('texture_threshold'),
'speckle_size':
LaunchConfiguration('speckle_size'),
'speckle_range':
LaunchConfiguration('speckle_range'),
'disp12_max_diff':
LaunchConfiguration('disp12_max_diff'),
'uniqueness_ratio':
LaunchConfiguration('uniqueness_ratio'),
'P1':
LaunchConfiguration('P1'),
'P2':
LaunchConfiguration('P2'),
'full_dp':
LaunchConfiguration('full_dp'),
}],
remappings=[
('left/image_rect',
[LaunchConfiguration('left_namespace'), '/image_rect']),
('left/camera_info',
[LaunchConfiguration('left_namespace'), '/camera_info']),
('right/image_rect',
[LaunchConfiguration('right_namespace'), '/image_rect']),
('right/camera_info',
[LaunchConfiguration('right_namespace'), '/camera_info']),
]),
ComposableNode(
package='stereo_image_proc',
plugin='stereo_image_proc::PointCloudNode',
parameters=[{
'approximate_sync':
LaunchConfiguration('approximate_sync'),
'avoid_point_cloud_padding':
LaunchConfiguration('avoid_point_cloud_padding'),
'use_color':
LaunchConfiguration('use_color'),
'use_system_default_qos':
LaunchConfiguration('use_system_default_qos'),
}],
remappings=[
('left/camera_info',
[LaunchConfiguration('left_namespace'), '/camera_info']),
('right/camera_info',
[LaunchConfiguration('right_namespace'), '/camera_info']),
('left/image_rect_color',
[LaunchConfiguration('left_namespace'), '/image_rect_color']),
]),
]
return LaunchDescription([
DeclareLaunchArgument(
name='approximate_sync',
default_value='False',
description=
'Whether to use approximate synchronization of topics. Set to true if '
'the left and right cameras do not produce exactly synced timestamps.'
),
DeclareLaunchArgument(
name='avoid_point_cloud_padding',
default_value='False',
description='Avoid alignment padding in the generated point cloud.'
'This reduces bandwidth requirements, as the point cloud size is halved.'
'Using point clouds without alignment padding might degrade performance '
'for some algorithms.'),
DeclareLaunchArgument(
name='use_color',
default_value='True',
description='Generate point cloud with rgb data.'),
DeclareLaunchArgument(
name='use_system_default_qos',
default_value='False',
description=
'Use the RMW QoS settings for the image and camera info subscriptions.'
),
DeclareLaunchArgument(
name='launch_image_proc',
default_value='True',
description=
'Whether to launch debayer and rectify nodes from image_proc.'),
DeclareLaunchArgument(name='left_namespace',
default_value='left',
description='Namespace for the left camera'),
DeclareLaunchArgument(name='right_namespace',
default_value='right',
description='Namespace for the right camera'),
DeclareLaunchArgument(
name='container',
default_value='',
description=
('Name of an existing node container to load launched nodes into. '
'If unset, a new container will be created.')),
# Stereo algorithm parameters
DeclareLaunchArgument(
name='stereo_algorithm',
default_value='0',
description=
'Stereo algorithm: Block Matching (0) or Semi-Global Block Matching (1)'
),
DeclareLaunchArgument(
name='prefilter_size',
default_value='9',
description='Normalization window size in pixels (must be odd)'),
DeclareLaunchArgument(name='prefilter_cap',
default_value='31',
description='Bound on normalized pixel values'),
DeclareLaunchArgument(
name='correlation_window_size',
default_value='15',
description='SAD correlation window width in pixels (must be odd)'
),
DeclareLaunchArgument(
name='min_disparity',
default_value='0',
description='Disparity to begin search at in pixels'),
DeclareLaunchArgument(
name='disparity_range',
default_value='64',
description=
'Number of disparities to search in pixels (must be a multiple of 16)'
),
DeclareLaunchArgument(
name='texture_threshold',
default_value='10',
description=
'Filter out if SAD window response does not exceed texture threshold'
),
DeclareLaunchArgument(
name='speckle_size',
default_value='100',
description='Reject regions smaller than this size in pixels'),
DeclareLaunchArgument(
name='speckle_range',
default_value='4',
description=
'Maximum allowed difference between detected disparities'),
DeclareLaunchArgument(
name='disp12_max_diff',
default_value='0',
description=
'Maximum allowed difference in the left-right disparity check in pixels '
'(Semi-Global Block Matching only)'),
DeclareLaunchArgument(
name='uniqueness_ratio',
default_value='15.0',
description=
'Filter out if best match does not sufficiently exceed the next-best match'
),
DeclareLaunchArgument(
name='P1',
default_value='200.0',
description=
'The first parameter ccontrolling the disparity smoothness '
'(Semi-Global Block Matching only)'),
DeclareLaunchArgument(
name='P2',
default_value='400.0',
description=
'The second parameter ccontrolling the disparity smoothness '
'(Semi-Global Block Matching only)'),
DeclareLaunchArgument(
name='full_dp',
default_value='False',
description=
'Run the full variant of the algorithm (Semi-Global Block Matching only)'
),
ComposableNodeContainer(
condition=LaunchConfigurationEquals('container', ''),
package='rclcpp_components',
executable='component_container',
name='stereo_image_proc_container',
namespace='',
composable_node_descriptions=composable_nodes,
),
LoadComposableNodes(
condition=LaunchConfigurationNotEquals('container', ''),
composable_node_descriptions=composable_nodes,
target_container=LaunchConfiguration('container'),
),
# If a container name is not provided,
# set the name of the container launched above for image_proc nodes
SetLaunchConfiguration(condition=LaunchConfigurationEquals(
'container', ''),
name='container',
value='stereo_image_proc_container'),
GroupAction(
[
PushRosNamespace(LaunchConfiguration('left_namespace')),
IncludeLaunchDescription(PythonLaunchDescriptionSource([
FindPackageShare('image_proc'),
'/launch/image_proc.launch.py'
]),
launch_arguments={
'container':
LaunchConfiguration('container')
}.items()),
],
condition=IfCondition(LaunchConfiguration('launch_image_proc')),
),
GroupAction(
[
PushRosNamespace(LaunchConfiguration('right_namespace')),
IncludeLaunchDescription(PythonLaunchDescriptionSource([
FindPackageShare('image_proc'),
'/launch/image_proc.launch.py'
]),
launch_arguments={
'container':
LaunchConfiguration('container')
}.items()),
],
condition=IfCondition(LaunchConfiguration('launch_image_proc')),
)
])
def generate_launch_description():
"""
Launch all nodes defined in the architecture for Milestone 3 of the AVP 2020 Demo.
More details about what is included can
be found at https://gitlab.com/autowarefoundation/autoware.auto/AutowareAuto/-/milestones/25.
"""
avp_demo_pkg_prefix = get_package_share_directory('autoware_auto_avp_demo')
euclidean_cluster_param_file = os.path.join(
avp_demo_pkg_prefix, 'param/euclidean_cluster.param.yaml')
ray_ground_classifier_param_file = os.path.join(
avp_demo_pkg_prefix, 'param/ray_ground_classifier.param.yaml')
rviz_cfg_path = os.path.join(avp_demo_pkg_prefix, 'config/ms3.rviz')
scan_downsampler_param_file = os.path.join(
avp_demo_pkg_prefix, 'param/scan_downsampler_ms3.param.yaml')
recordreplay_planner_param_file = os.path.join(
avp_demo_pkg_prefix, 'param/recordreplay_planner.param.yaml')
lanelet2_map_provider_param_file = os.path.join(
avp_demo_pkg_prefix, 'param/lanelet2_map_provider.param.yaml')
lane_planner_param_file = os.path.join(
avp_demo_pkg_prefix, 'param/lane_planner.param.yaml')
parking_planner_param_file = os.path.join(
avp_demo_pkg_prefix, 'param/parking_planner.param.yaml')
object_collision_estimator_param_file = os.path.join(
avp_demo_pkg_prefix, 'param/object_collision_estimator.param.yaml')
behavior_planner_param_file = os.path.join(
avp_demo_pkg_prefix, 'param/behavior_planner.param.yaml')
point_cloud_fusion_pkg_prefix = get_package_share_directory(
'point_cloud_fusion')
avp_web_interface_pkg_prefix = get_package_share_directory(
'avp_web_interface')
web_files_root = os.path.join(avp_web_interface_pkg_prefix, 'web')
# Arguments
euclidean_cluster_param = DeclareLaunchArgument(
'euclidean_cluster_param_file',
default_value=euclidean_cluster_param_file,
description='Path to config file for Euclidean Clustering'
)
ray_ground_classifier_param = DeclareLaunchArgument(
'ray_ground_classifier_param_file',
default_value=ray_ground_classifier_param_file,
description='Path to config file for Ray Ground Classifier'
)
with_rviz_param = DeclareLaunchArgument(
'with_rviz',
default_value='True',
description='Launch RVIZ2 in addition to other nodes'
)
scan_downsampler_param = DeclareLaunchArgument(
'scan_downsampler_param_file',
default_value=scan_downsampler_param_file,
description='Path to config file for lidar scan downsampler'
)
recordreplay_planner_param = DeclareLaunchArgument(
'recordreplay_planner_param_file',
default_value=recordreplay_planner_param_file,
description='Path to config file for record/replay planner'
)
lanelet2_map_provider_param = DeclareLaunchArgument(
'lanelet2_map_provider_param_file',
default_value=lanelet2_map_provider_param_file,
description='Path to parameter file for Lanelet2 Map Provider'
)
lane_planner_param = DeclareLaunchArgument(
'lane_planner_param_file',
default_value=lane_planner_param_file,
description='Path to parameter file for lane planner'
)
parking_planner_param = DeclareLaunchArgument(
'parking_planner_param_file',
default_value=parking_planner_param_file,
description='Path to paramter file for parking planner'
)
object_collision_estimator_param = DeclareLaunchArgument(
'object_collision_estimator_param_file',
default_value=object_collision_estimator_param_file,
description='Path to paramter file for object collision estimator'
)
behavior_planner_param = DeclareLaunchArgument(
'behavior_planner_param_file',
default_value=behavior_planner_param_file,
description='Path to paramter file for behavior planner'
)
# Nodes
euclidean_clustering = Node(
package='euclidean_cluster_nodes',
node_executable='euclidean_cluster_node_exe',
node_namespace='perception',
parameters=[LaunchConfiguration('euclidean_cluster_param_file')],
remappings=[
("points_in", "points_nonground")
]
)
# point cloud fusion runner to fuse front and rear lidar
point_cloud_fusion = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(point_cloud_fusion_pkg_prefix,
'launch/vlp16_sim_lexus_pc_fusion.launch.py'))
)
ray_ground_classifier = Node(
package='ray_ground_classifier_nodes',
node_executable='ray_ground_classifier_cloud_node_exe',
node_namespace='perception',
parameters=[LaunchConfiguration('ray_ground_classifier_param_file')],
remappings=[("points_in", "/lidars/points_fused")]
)
rviz2 = Node(
package='rviz2',
node_executable='rviz2',
node_name='rviz2',
arguments=['-d', str(rviz_cfg_path)],
condition=IfCondition(LaunchConfiguration('with_rviz')),
remappings=[("initialpose", "/localization/initialpose"),
("goal_pose", "/planning/goal_pose")],
)
scan_downsampler = Node(
package='voxel_grid_nodes',
node_executable='voxel_grid_node_exe',
node_namespace='lidars',
node_name='voxel_grid_cloud_node',
parameters=[LaunchConfiguration('scan_downsampler_param_file')],
remappings=[
("points_in", "points_fused"),
("points_downsampled", "points_fused_downsampled")
]
)
recordreplay_planner = Node(
package='recordreplay_planner_node',
node_executable='recordreplay_planner_node_exe',
node_name='recordreplay_planner',
node_namespace='planning',
parameters=[LaunchConfiguration('recordreplay_planner_param_file')],
remappings=[
('vehicle_state', '/vehicle/vehicle_kinematic_state'),
('planned_trajectory', '/planning/trajectory'),
('obstacle_bounding_boxes', '/perception/lidar_bounding_boxes'),
]
)
lanelet2_map_provider = Node(
package='lanelet2_map_provider',
node_executable='lanelet2_map_provider_exe',
node_namespace='had_maps',
parameters=[LaunchConfiguration('lanelet2_map_provider_param_file')]
)
lanelet2_map_visualizer = Node(
package='lanelet2_map_provider',
node_executable='lanelet2_map_visualizer_exe',
node_namespace='had_maps'
)
global_planner = Node(
package='lanelet2_global_planner_node',
node_name='lanelet2_global_planner_node',
node_namespace='planning',
node_executable='lanelet2_global_planner_node_exe',
remappings=[('HAD_Map_Client', '/had_maps/HAD_Map_Service'),
('vehicle_kinematic_state', '/vehicle/vehicle_kinematic_state')]
)
lane_planner = Node(
package='lane_planner_node',
node_name='lane_planner_node',
node_namespace='planning',
node_executable='lane_planner_node_exe',
parameters=[LaunchConfiguration('lane_planner_param_file')],
remappings=[('HAD_Map_Service', '/had_maps/HAD_Map_Service')]
)
parking_planner = Node(
package='parking_planner_node',
node_name='parking_planner_node',
node_namespace='planning',
node_executable='parking_planner_node_exe',
parameters=[LaunchConfiguration('parking_planner_param_file')],
remappings=[('HAD_Map_Service', '/had_maps/HAD_Map_Service')]
)
object_collision_estimator = Node(
package='object_collision_estimator_node',
node_name='object_collision_estimator_node',
node_namespace='planning',
node_executable='object_collision_estimator_node_exe',
parameters=[LaunchConfiguration('object_collision_estimator_param_file')],
remappings=[
('obstacle_topic', '/perception/lidar_bounding_boxes'),
]
)
behavior_planner = Node(
package='behavior_planner_node',
node_name='behavior_planner_node',
node_namespace='planning',
node_executable='behavior_planner_node_exe',
parameters=[LaunchConfiguration('behavior_planner_param_file')],
output='screen',
remappings=[
('HAD_Map_Service', '/had_maps/HAD_Map_Service'),
('vehicle_state', '/vehicle/vehicle_kinematic_state'),
('route', 'global_path'),
('vehicle_state_report', '/vehicle/state_report'),
('vehicle_state_command', '/vehicle/state_command')
]
)
web_bridge = Node(
package='rosbridge_server',
node_name='rosbridge_server_node',
node_namespace='gui',
node_executable='rosbridge_websocket'
)
web_server = ExecuteProcess(
cmd=["python3", "-m", "http.server", "8000"],
cwd=web_files_root
)
return LaunchDescription([
euclidean_cluster_param,
ray_ground_classifier_param,
scan_downsampler_param,
with_rviz_param,
recordreplay_planner_param,
lanelet2_map_provider_param,
lane_planner_param,
parking_planner_param,
object_collision_estimator_param,
behavior_planner_param,
euclidean_clustering,
ray_ground_classifier,
scan_downsampler,
recordreplay_planner,
point_cloud_fusion,
lanelet2_map_provider,
lanelet2_map_visualizer,
global_planner,
lane_planner,
parking_planner,
object_collision_estimator,
behavior_planner,
rviz2,
web_server,
web_bridge,
])
def generate_launch_description():
# Get the launch directory
exp_bringup_dir = get_package_share_directory('social_nav2_exp_bringup')
social_bringup_dir = get_package_share_directory('social_nav2_bringup')
launch_dir = os.path.join(social_bringup_dir, 'launch')
# Declare the launch options
scene_file = LaunchConfiguration('scene_file')
simulation_factor = LaunchConfiguration('simulation_factor')
frame_id = LaunchConfiguration('frame_id')
# Create the launch configuration variables
namespace = LaunchConfiguration('namespace')
frame_id_cmd = DeclareLaunchArgument('frame_id',
default_value='map',
description='Reference frame')
social_nav_bringup_cmd = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(launch_dir, 'tb3_house_simulation_launch.py')))
social_goal_updater_cmd = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(
get_package_share_directory('social_nav2_goal_updaters'),
'launch', 'social_goal_updaters_launch.py')))
distance_to_agent_cmd = Node(package='measuring_tools',
executable='distance_to_agent_node',
name='distance_to_agent_node',
output='screen',
arguments=["agent_3"])
robot_cost_cmd = Node(package='measuring_tools',
executable='robot_cost_node',
name='robot_cost_node',
output='screen')
path_cmd = Node(package='measuring_tools',
executable='path_pub_node',
name='path_pub_node',
output='screen')
topics_2_csv_cmd = Node(package='social_nav2_csv',
executable='topics_2_csv',
name='topics_2_csv',
output='screen')
social_nav_bringup_cmd = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(launch_dir, 'social_nav_launch.py')))
approach_sim = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(exp_bringup_dir, 'launch', 'approach_sim_launch.py')))
# Create the launch description and populate
ld = LaunchDescription()
ld.add_action(frame_id_cmd)
ld.add_action(robot_cost_cmd)
ld.add_action(distance_to_agent_cmd)
ld.add_action(path_cmd)
ld.add_action(topics_2_csv_cmd)
ld.add_action(social_goal_updater_cmd)
ld.add_action(approach_sim)
ld.add_action(social_nav_bringup_cmd)
return ld
def generate_launch_description():
share_dir_path = os.path.join(get_package_share_directory('dynamixel_hardware_interface'))
xacro_path = os.path.join(
share_dir_path,
'config',
'urdf',
'2dof_robot_arm_robot.urdf.xacro')
doc = xacro.process_file(xacro_path)
robot_description = {"robot_description": doc.toxml()}
robot_state_publisher = Node(
package='robot_state_publisher',
executable='robot_state_publisher',
output='both',
parameters=[robot_description])
view_model = LaunchConfiguration('view_model', default=False)
view_model_arg = DeclareLaunchArgument(
'view_model', default_value=view_model,
description="if true, launch Autoware with given rviz configuration.")
rviz = Node(
package='rviz2',
executable='rviz2',
name='rviz2',
output={
'stderr': 'log',
'stdout': 'log',
},
condition=IfCondition(view_model),
arguments=[
'-d', str(
Path(get_package_share_directory('dynamixel_hardware_interface')) /
'config' /
'2dof_robot_arm.rviz')])
controller_config = os.path.join(
get_package_share_directory("dynamixel_hardware_interface"),
"config",
"controllers",
"controllers_2dof_robot_arm.yaml"
)
control_node = Node(
package="controller_manager",
executable="ros2_control_node",
parameters=[robot_description, controller_config],
output={
"stdout": "screen",
"stderr": "screen",
},
)
return launch.LaunchDescription(
[
robot_state_publisher,
view_model_arg,
rviz,
control_node,
ExecuteProcess(
cmd=[
"ros2",
"control",
"load_start_controller",
"joint_state_controller"],
output="screen",
shell=True,
),
ExecuteProcess(
cmd=[
"ros2",
"control",
"load_configure_controller",
"velocity_controller"],
output="screen",
shell=True,
),
ExecuteProcess(
cmd=[
"ros2",
"control",
"load_configure_controller",
"joint_trajectory_controller"],
output="screen",
shell=True,
)
]
)
def generate_launch_description():
nav2_bringup_dir = get_package_share_directory('nav2_bringup')
nav2_launch_dir = os.path.join(nav2_bringup_dir, 'launch')
package_dir = get_package_share_directory('robots')
slam = LaunchConfiguration('slam')
namespace = LaunchConfiguration('namespace')
use_namespace = LaunchConfiguration('use_namespace')
map_yaml_file = LaunchConfiguration('map')
use_sim_time = LaunchConfiguration('use_sim_time')
params_file = LaunchConfiguration('params_file')
default_bt_xml_filename = LaunchConfiguration('default_bt_xml_filename')
autostart = LaunchConfiguration('autostart')
declare_namespace_cmd = DeclareLaunchArgument(
'namespace', default_value='', description='Top-level namespace')
declare_use_namespace_cmd = DeclareLaunchArgument(
'use_namespace',
default_value='false',
description='Whether to apply a namespace to the navigation stack')
declare_slam_cmd = DeclareLaunchArgument('slam',
default_value='False',
description='Whether run a SLAM')
declare_map_yaml_cmd = DeclareLaunchArgument(
'map',
default_value=os.path.join(package_dir, 'worlds', 'apartment.yaml'),
description='Full path to map file to load')
declare_use_sim_time_cmd = DeclareLaunchArgument(
'use_sim_time',
default_value='true',
description='Use simulation (Gazebo) clock if true')
declare_params_file_cmd = DeclareLaunchArgument(
'params_file',
default_value=os.path.join(package_dir, 'params', 'nav2_params.yaml'),
description=
'Full path to the ROS2 parameters file to use for all launched nodes')
declare_bt_xml_cmd = DeclareLaunchArgument(
'default_bt_xml_filename',
default_value=os.path.join(
get_package_share_directory('nav2_bt_navigator'), 'behavior_trees',
'navigate_w_replanning_and_recovery.xml'),
description='Full path to the behavior tree xml file to use')
declare_autostart_cmd = DeclareLaunchArgument(
'autostart',
default_value='true',
description='Automatically startup the nav2 stack')
webots = IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(get_package_share_directory('webots_ros2_core'), 'launch',
'robot_launch.py')),
launch_arguments={
'executable':
'webots_differential_drive_node',
'world':
os.path.join(
package_dir, 'worlds',
'complete_apartment.wbt'),
'node_parameters':
os.path.join(package_dir, 'resource',
'tiago.yaml'),
'use_sim_time':
use_sim_time
}.items())
head2camera = launch_ros.actions.Node(
package='tf2_ros',
executable='static_transform_publisher',
arguments=[
'0.0', '0.0', '0.00', '.0', '0.0', '3.1415', 'head_2_link',
'camera'
],
parameters=[{
'use_sim_time': use_sim_time
}],
)
head2rangefinder = launch_ros.actions.Node(
package='tf2_ros',
executable='static_transform_publisher',
arguments=[
'0.0', '0.0', '0.00', '0.0', '0.0', '3.1415', 'head_2_link',
'range-finder'
],
parameters=[{
'use_sim_time': use_sim_time
}])
baselink2bf = launch_ros.actions.Node(
package='tf2_ros',
executable='static_transform_publisher',
arguments=[
'0.0', '0.0', '0.00', '0.0', '0.0', '0.0', 'base_link',
'base_footprint'
],
parameters=[{
'use_sim_time': use_sim_time
}])
# Rviz node
use_rviz = launch.substitutions.LaunchConfiguration('rviz', default=False)
rviz_config = os.path.join(get_package_share_directory('robots'),
'resource', 'odometry.rviz')
rviz = launch_ros.actions.Node(
package='rviz2',
executable='rviz2',
output='screen',
arguments=['--display-config=' + rviz_config],
condition=launch.conditions.IfCondition(use_rviz),
parameters=[{
'use_sim_time': use_sim_time
}])
pointcloud_xyz = launch_ros.actions.ComposableNodeContainer(
name='container',
namespace='',
package='rclcpp_components',
executable='component_container',
composable_node_descriptions=[
# Driver itself
launch_ros.descriptions.ComposableNode(
package='depth_image_proc',
plugin='depth_image_proc::PointCloudXyzrgbNode',
name='point_cloud_xyz_node',
remappings=[('rgb/camera_info', '/camera/camera_info'),
('rgb/image_rect_color', '/camera/image_raw'),
('depth_registered/image_rect',
'/range_finder/image_depth'),
('points', '/depth_registered/points')],
parameters=[{
'use_sim_time': use_sim_time
}]),
],
parameters=[{
'use_sim_time': use_sim_time
}],
output='screen',
)
nav2_bringup_cmd = IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(nav2_launch_dir, 'bringup_launch.py')),
launch_arguments={
'namespace': namespace,
'use_namespace':
use_namespace,
'slam': slam,
'map': map_yaml_file,
'use_sim_time':
use_sim_time,
'params_file': params_file,
'default_bt_xml_filename':
default_bt_xml_filename,
'autostart': autostart
}.items())
ld = LaunchDescription()
ld.add_action(declare_namespace_cmd)
ld.add_action(declare_use_namespace_cmd)
ld.add_action(declare_slam_cmd)
ld.add_action(declare_map_yaml_cmd)
ld.add_action(declare_use_sim_time_cmd)
ld.add_action(declare_params_file_cmd)
ld.add_action(declare_bt_xml_cmd)
ld.add_action(declare_autostart_cmd)
ld.add_action(baselink2bf)
ld.add_action(webots)
ld.add_action(nav2_bringup_cmd)
return ld
def generate_launch_description():
# Get the launch directory
bringup_dir = '.'
# Create the launch configuration variables
namespace = LaunchConfiguration('namespace')
use_namespace = LaunchConfiguration('use_namespace')
rviz_config_file = LaunchConfiguration('rviz_config')
# Declare the launch arguments
declare_namespace_cmd = DeclareLaunchArgument(
'namespace',
default_value='navigation',
description=(
'Top-level namespace. The value will be used to replace the '
'<robot_namespace> keyword on the rviz config file.'))
declare_use_namespace_cmd = DeclareLaunchArgument(
'use_namespace',
default_value='false',
description='Whether to apply a namespace to the navigation stack')
declare_rviz_config_file_cmd = DeclareLaunchArgument(
'rviz_config',
default_value=os.path.join(bringup_dir, 'rviz',
'nav2_default_view.rviz'),
description='Full path to the RVIZ config file to use')
# Launch rviz
start_rviz_cmd = Node(condition=UnlessCondition(use_namespace),
package='rviz2',
executable='rviz2',
name='rviz2',
arguments=['-d', rviz_config_file],
output='screen')
namespaced_rviz_config_file = rviz_config_file
start_namespaced_rviz_cmd = Node(
condition=IfCondition(use_namespace),
package='rviz2',
executable='rviz2',
name='rviz2',
namespace=namespace,
arguments=['-d', namespaced_rviz_config_file],
output='screen',
remappings=[('/tf', 'tf'), ('/tf_static', 'tf_static'),
('/goal_pose', 'goal_pose'),
('/clicked_point', 'clicked_point'),
('/initialpose', 'initialpose')])
exit_event_handler = RegisterEventHandler(
condition=UnlessCondition(use_namespace),
event_handler=OnProcessExit(
target_action=start_rviz_cmd,
on_exit=EmitEvent(event=Shutdown(reason='rviz exited'))))
exit_event_handler_namespaced = RegisterEventHandler(
condition=IfCondition(use_namespace),
event_handler=OnProcessExit(
target_action=start_namespaced_rviz_cmd,
on_exit=EmitEvent(event=Shutdown(reason='rviz exited'))))
# Create the launch description and populate
ld = LaunchDescription()
# Declare the launch options
ld.add_action(declare_namespace_cmd)
ld.add_action(declare_use_namespace_cmd)
ld.add_action(declare_rviz_config_file_cmd)
# Add any conditioned actions
ld.add_action(start_rviz_cmd)
ld.add_action(start_namespaced_rviz_cmd)
# Add other nodes and processes we need
ld.add_action(exit_event_handler)
ld.add_action(exit_event_handler_namespaced)
return ld
def generate_launch_description():
namespace = LaunchConfiguration('namespace')
map_yaml_file = LaunchConfiguration('map')
use_sim_time = LaunchConfiguration('use_sim_time')
params_file = LaunchConfiguration('params_file')
use_remappings = LaunchConfiguration('use_remappings')
# TODO(orduno) Remove once `PushNodeRemapping` is resolved
# https://github.com/ros2/launch_ros/issues/56
remappings = [((namespace, '/tf'), '/tf'),
((namespace, '/tf_static'), '/tf_static'),
('/tf', 'tf'),
('/tf_static', 'tf_static')]
# Create our own temporary YAML files that include substitutions
param_substitutions = {
'use_sim_time': use_sim_time,
'yaml_filename': map_yaml_file}
configured_params = RewrittenYaml(
source_file=params_file,
root_key=namespace,
param_rewrites=param_substitutions,
convert_types=True)
return LaunchDescription([
# Set env var to print messages to stdout immediately
SetEnvironmentVariable('RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1'),
DeclareLaunchArgument(
'namespace',
default_value='',
description='Top-level namespace'),
DeclareLaunchArgument(
'map',
description='Full path to map yaml file to load'),
DeclareLaunchArgument(
'use_sim_time', default_value='false',
description='Use simulation (Gazebo) clock if true'),
DeclareLaunchArgument(
'params_file',
description='Full path to the ROS2 parameters file to use'),
DeclareLaunchArgument(
'use_remappings',
default_value='false',
description='Arguments to pass to all nodes launched by the file'),
Node(
package='nav2_map_server',
node_executable='map_server',
node_name='map_server',
output='screen',
parameters=[configured_params],
use_remappings=IfCondition(use_remappings),
remappings=remappings),
Node(
package='nav2_amcl',
node_executable='amcl',
node_name='amcl',
output='screen',
parameters=[configured_params],
use_remappings=IfCondition(use_remappings),
remappings=remappings),
])
def generate_launch_description():
tf_exchange_dir = get_package_share_directory('tf_exchange')
#rviz_config_file = LaunchConfiguration('rviz_config')
#map_yaml_file = LaunchConfiguration('map')
bringup_dir = get_package_share_directory('nav2_bringup')
slam = LaunchConfiguration('slam')
declare_map_yaml_cmd = DeclareLaunchArgument(
'map',
default_value=os.path.join(bringup_dir, 'maps',
'turtlebot3_world.yaml'),
description='Full path to map file to load')
declare_robot_name = DeclareLaunchArgument('robot_name',
default_value='robot1')
declare_base_frame = DeclareLaunchArgument('base_frame',
default_value='base_link')
declare_x_pose = DeclareLaunchArgument(
'x_pose',
default_value=launch.substitutions.TextSubstitution(text='0.0'))
declare_y_pose = DeclareLaunchArgument(
'y_pose',
default_value=launch.substitutions.TextSubstitution(text='0.0'))
declare_z_pose = DeclareLaunchArgument(
'z_pose',
default_value=launch.substitutions.TextSubstitution(text='0.0'))
declare_yaw_pose = DeclareLaunchArgument(
'yaw_pose',
default_value=launch.substitutions.TextSubstitution(text='0.0'))
declare_use_rviz_cmd = DeclareLaunchArgument(
'use_rviz', default_value='True', description='Whether to start RVIZ')
declare_rviz_config_file_cmd = DeclareLaunchArgument(
'rviz_config',
default_value=os.path.join(
get_package_share_directory('robot_spawner_pkg'), 'custom.rviz'),
description='Full path to the RVIZ config file to use.')
declare_slam_cmd = DeclareLaunchArgument('slam',
default_value='False',
description='Whether run a SLAM')
declare_behaviour_cmd = DeclareLaunchArgument(
'behaviour',
default_value='True',
description='Whether run the default behaviour.')
tf_exchange = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(tf_exchange_dir, 'tf_exchange.launch.py')),
launch_arguments={
'namespace': LaunchConfiguration('robot_name'),
'robot_name': LaunchConfiguration('robot_name'),
'base_frame': LaunchConfiguration('base_frame')
#'params_file': [LaunchConfiguration('robot_name'), launch.substitutions.TextSubstitution(text='_params_file')]
}.items())
spawner = launch_ros.actions.Node(
package='robot_spawner_pkg',
executable='nav2_gazebo_spawner',
output='screen',
arguments=[
'--robot_name',
LaunchConfiguration('robot_name'),
'--robot_namespace',
LaunchConfiguration('robot_name'),
'--turtlebot_type',
launch.substitutions.EnvironmentVariable('TURTLEBOT3_MODEL'),
'-x',
LaunchConfiguration('x_pose'),
'-y',
LaunchConfiguration('y_pose'),
'-z',
LaunchConfiguration('z_pose'),
'-yaw',
LaunchConfiguration('yaw_pose'),
])
rviz = IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(bringup_dir, 'launch', 'rviz_launch.py')),
condition=IfCondition(
LaunchConfiguration('use_rviz')),
launch_arguments={
'namespace':
LaunchConfiguration('robot_name'),
'use_namespace':
'true',
'use_sim_time':
'true'
}.items()) #,
#'rviz_config': rviz_config_file}.items())
namespace = LaunchConfiguration('robot_name')
use_sim_time = TextSubstitution(text='True')
autostart = 'True'
params_file = os.path.join(
get_package_share_directory('robot_spawner_pkg'),
'nav2_multirobot_params_1.yaml')
urdf = os.path.join(get_package_share_directory('turtlebot3_description'),
'urdf', 'turtlebot3_burger.urdf')
bringup_cmd_group = GroupAction([
launch_ros.actions.PushRosNamespace(namespace=namespace),
launch_ros.actions.Node(
package='robot_state_publisher',
executable='robot_state_publisher',
name='robot_state_publisher',
#namespace=namespace,
output='screen',
parameters=[{
'use_sim_time': use_sim_time
}],
arguments=[urdf],
remappings=[('/tf', 'tf'), ('/tf_static', 'tf_static')]),
IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(bringup_dir, 'launch', 'slam_launch.py')),
condition=IfCondition(slam),
launch_arguments={
'namespace': namespace,
'use_sim_time': use_sim_time,
'autostart': autostart,
'params_file': params_file
}.items()),
IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(bringup_dir, 'launch', 'localization_launch.py')),
condition=IfCondition(
PythonExpression(['not ', slam])),
launch_arguments={
'namespace': namespace,
'map': LaunchConfiguration('map'),
'use_sim_time': use_sim_time,
'autostart': autostart,
'params_file': params_file,
'use_lifecycle_mgr': 'false'
}.items())
])
drive = launch_ros.actions.Node(
executable='turtlebot3_drive',
condition=IfCondition(LaunchConfiguration('behaviour')),
package='turtlebot3_gazebo',
namespace=LaunchConfiguration('robot_name'),
)
ld = LaunchDescription()
ld.add_action(declare_map_yaml_cmd)
ld.add_action(declare_robot_name)
ld.add_action(declare_base_frame)
ld.add_action(declare_x_pose)
ld.add_action(declare_y_pose)
ld.add_action(declare_z_pose)
ld.add_action(declare_yaw_pose)
ld.add_action(declare_use_rviz_cmd)
ld.add_action(declare_slam_cmd)
ld.add_action(declare_behaviour_cmd)
ld.add_action(declare_rviz_config_file_cmd)
ld.add_action(spawner)
ld.add_action(rviz)
ld.add_action(bringup_cmd_group)
ld.add_action(tf_exchange)
ld.add_action(drive)
return ld
def set_configurable_parameters(parameters):
return dict([(param['name'], LaunchConfiguration(param['name']))
for param in parameters])
def generate_launch_description():
"""
Launch a minimal joystick + LGSVL demo.
The joystick_vehicle_interface and the lgsvl_interface
are modified via parameter remapping to use VehicleControlCommand as an output.
The vehicle can be controlled by manipulating the left joystick of the gamepad.
"""
# --------------------------------- Params -------------------------------
# In combination 'raw', 'basic' and 'high_level' control
# in what mode of control comands to operate in,
# only one of them can be active at a time with a value
control_command_param = DeclareLaunchArgument(
'control_command',
default_value="raw", # use "raw", "basic" or "high_level"
description='command control mode topic name')
# Default joystick translator params
joy_translator_param = DeclareLaunchArgument(
'joy_translator_param',
default_value=[
get_share_file('joystick_vehicle_interface',
'param/logitech_f310.default.param.yaml')
],
description='Path to config file for joystick translator')
# Default lgsvl_interface params
lgsvl_interface_param = DeclareLaunchArgument(
'lgsvl_interface_param',
default_value=[
get_share_file('lgsvl_interface', 'param/lgsvl.param.yaml')
],
description='Path to config file for lgsvl interface')
# -------------------------------- Nodes-----------------------------------
# Include Joystick launch
joystick_launch_file_path = get_share_file(
'joystick_vehicle_interface',
'launch/joystick_vehicle_interface.launch.py')
joystick = IncludeLaunchDescription(
PythonLaunchDescriptionSource(joystick_launch_file_path),
launch_arguments={
"joy_translator_param":
LaunchConfiguration("joy_translator_param"),
"control_command": LaunchConfiguration('control_command')
}.items())
# Include LGSVL interface launch
lgsvl_launch_file_path = get_share_file('lgsvl_interface',
'launch/lgsvl.launch.py')
lgsvl = IncludeLaunchDescription(
PythonLaunchDescriptionSource(lgsvl_launch_file_path),
launch_arguments={
"lgsvl_interface_param":
LaunchConfiguration("lgsvl_interface_param"),
"control_command": LaunchConfiguration('control_command')
}.items())
return LaunchDescription([
control_command_param, joy_translator_param, lgsvl_interface_param,
joystick, lgsvl
])
def generate_launch_description():
if (os.getenv('ROS_DISTRO') == "dashing") or (os.getenv('ROS_DISTRO')
== "eloquent"):
return LaunchDescription(
declare_configurable_parameters(configurable_parameters) + [
# Realsense
launch_ros.actions.Node(
condition=IfCondition(
PythonExpression(
[LaunchConfiguration('config_file'), " == ''"])),
package='realsense2_camera',
node_namespace=LaunchConfiguration("camera_name"),
node_name=LaunchConfiguration("camera_name"),
node_executable='realsense2_camera_node',
prefix=['stdbuf -o L'],
parameters=[
set_configurable_parameters(configurable_parameters)
],
output='screen',
arguments=[
'--ros-args', '--log-level',
LaunchConfiguration('log_level')
],
),
launch_ros.actions.Node(
condition=IfCondition(
PythonExpression(
[LaunchConfiguration('config_file'), " != ''"])),
package='realsense2_camera',
node_namespace=LaunchConfiguration("camera_name"),
node_name=LaunchConfiguration("camera_name"),
node_executable='realsense2_camera_node',
prefix=['stdbuf -o L'],
parameters=[
set_configurable_parameters(configurable_parameters),
PythonExpression([LaunchConfiguration("config_file")])
],
output='screen',
arguments=[
'--ros-args', '--log-level',
LaunchConfiguration('log_level')
],
),
])
else:
return LaunchDescription(
declare_configurable_parameters(configurable_parameters) + [
# Realsense
launch_ros.actions.Node(
condition=IfCondition(
PythonExpression(
[LaunchConfiguration('config_file'), " == ''"])),
package='realsense2_camera',
namespace=LaunchConfiguration("camera_name"),
name=LaunchConfiguration("camera_name"),
executable='realsense2_camera_node',
parameters=[
set_configurable_parameters(configurable_parameters)
],
remappings=[
('/camera/odom/sample', '/mammoth/odom'),
],
output='screen',
arguments=[
'--ros-args', '--log-level',
LaunchConfiguration('log_level')
],
emulate_tty=True,
),
launch_ros.actions.Node(
condition=IfCondition(
PythonExpression(
[LaunchConfiguration('config_file'), " != ''"])),
package='realsense2_camera',
namespace=LaunchConfiguration("camera_name"),
name=LaunchConfiguration("camera_name"),
executable='realsense2_camera_node',
parameters=[
set_configurable_parameters(configurable_parameters),
PythonExpression([LaunchConfiguration("config_file")])
],
remappings=[
('/camera/odom/sample', '/mammoth/odom'),
],
output='screen',
arguments=[
'--ros-args', '--log-level',
LaunchConfiguration('log_level')
],
emulate_tty=True,
),
])
def generate_launch_description():
# Declare arguments
declared_arguments = []
declared_arguments.append(
DeclareLaunchArgument(
"runtime_config_package",
default_value="ros2_control_demo_bringup",
description=
'Package with the controller\'s configuration in "config" folder. \
Usually the argument is not set, it enables use of a custom setup.',
))
declared_arguments.append(
DeclareLaunchArgument(
"controllers_file",
default_value="rrbot_controllers.yaml",
description="YAML file with the controllers configuration.",
))
declared_arguments.append(
DeclareLaunchArgument(
"description_package",
default_value="rrbot_description",
description=
"Description package with robot URDF/xacro files. Usually the argument \
is not set, it enables use of a custom description.",
))
declared_arguments.append(
DeclareLaunchArgument(
"description_file",
description="URDF/XACRO description file with the robot.",
))
declared_arguments.append(
DeclareLaunchArgument(
"prefix",
default_value='""',
description="Prefix of the joint names, useful for \
multi-robot setup. If changed than also joint names in the controllers' configuration \
have to be updated.",
))
declared_arguments.append(
DeclareLaunchArgument(
"use_sim",
default_value="false",
description="Start robot in Gazebo simulation.",
))
declared_arguments.append(
DeclareLaunchArgument(
"use_fake_hardware",
default_value="true",
description=
"Start robot with fake hardware mirroring command to its states.",
))
declared_arguments.append(
DeclareLaunchArgument(
"fake_sensor_commands",
default_value="false",
description=
"Enable fake command interfaces for sensors used for simple simulations. \
Used only if 'use_fake_hardware' parameter is true.",
))
declared_arguments.append(
DeclareLaunchArgument("slowdown",
default_value="3.0",
description="Slowdown factor of the RRbot."))
declared_arguments.append(
DeclareLaunchArgument(
"robot_controller",
default_value="forward_position_controller",
description="Robot controller to start.",
))
declared_arguments.append(
DeclareLaunchArgument(
"start_rviz",
default_value="true",
description="Start RViz2 automatically with this launch file.",
))
# Initialize Arguments
runtime_config_package = LaunchConfiguration("runtime_config_package")
controllers_file = LaunchConfiguration("controllers_file")
description_package = LaunchConfiguration("description_package")
description_file = LaunchConfiguration("description_file")
prefix = LaunchConfiguration("prefix")
use_sim = LaunchConfiguration("use_sim")
use_fake_hardware = LaunchConfiguration("use_fake_hardware")
fake_sensor_commands = LaunchConfiguration("fake_sensor_commands")
slowdown = LaunchConfiguration("slowdown")
robot_controller = LaunchConfiguration("robot_controller")
start_rviz = LaunchConfiguration("start_rviz")
# Get URDF via xacro
robot_description_content = Command([
PathJoinSubstitution([FindExecutable(name="xacro")]),
" ",
PathJoinSubstitution(
[FindPackageShare(description_package), "urdf", description_file]),
" ",
"prefix:=",
prefix,
" ",
"use_sim:=",
use_sim,
" ",
"use_fake_hardware:=",
use_fake_hardware,
" ",
"fake_sensor_commands:=",
fake_sensor_commands,
" ",
"slowdown:=",
slowdown,
])
robot_description = {"robot_description": robot_description_content}
robot_controllers = PathJoinSubstitution([
FindPackageShare(runtime_config_package),
"config",
controllers_file,
])
rviz_config_file = PathJoinSubstitution(
[FindPackageShare(description_package), "config", "rrbot.rviz"])
control_node = Node(
package="controller_manager",
executable="ros2_control_node",
parameters=[robot_description, robot_controllers],
output={
"stdout": "screen",
"stderr": "screen",
},
)
robot_state_pub_node = Node(
package="robot_state_publisher",
executable="robot_state_publisher",
output="both",
parameters=[robot_description],
)
rviz_node = Node(
package="rviz2",
executable="rviz2",
name="rviz2",
output="log",
arguments=["-d", rviz_config_file],
condition=IfCondition(start_rviz),
)
joint_state_broadcaster_spawner = Node(
package="controller_manager",
executable="spawner.py",
arguments=[
"joint_state_broadcaster", "--controller-manager",
"/controller_manager"
],
)
robot_controller_spawner = Node(
package="controller_manager",
executable="spawner.py",
arguments=[robot_controller, "-c", "/controller_manager"],
)
nodes = [
control_node,
robot_state_pub_node,
rviz_node,
joint_state_broadcaster_spawner,
robot_controller_spawner,
]
return LaunchDescription(declared_arguments + nodes)
def generate_launch_description():
# Get the launch directory
bringup_dir = get_package_share_directory('nav2_bringup')
tb3_dir = get_package_share_directory('workshop_ros2_navigation')
launch_dir = os.path.join(bringup_dir, 'launch')
# Create the launch configuration variables
namespace = LaunchConfiguration('namespace')
map_yaml_file = LaunchConfiguration('map')
use_sim_time = LaunchConfiguration('use_sim_time')
params_file = LaunchConfiguration('params_file')
bt_xml_file = LaunchConfiguration('bt_xml_file')
autostart = LaunchConfiguration('autostart')
use_remappings = LaunchConfiguration('use_remappings')
# Launch configuration variables specific to simulation
rviz_config_file = LaunchConfiguration('rviz_config_file')
use_simulator = LaunchConfiguration('use_simulator')
use_robot_state_pub = LaunchConfiguration('use_robot_state_pub')
use_rviz = LaunchConfiguration('use_rviz')
headless = LaunchConfiguration('headless')
world = LaunchConfiguration('world')
# TODO(orduno) Remove once `PushNodeRemapping` is resolved
# https://github.com/ros2/launch_ros/issues/56
remappings = [((namespace, '/tf'), '/tf'),
((namespace, '/tf_static'), '/tf_static'), ('/tf', 'tf'),
('/tf_static', 'tf_static')]
# Declare the launch arguments
declare_namespace_cmd = DeclareLaunchArgument(
'namespace', default_value='', description='Top-level namespace')
declare_map_yaml_cmd = DeclareLaunchArgument(
'map',
default_value=os.path.join(tb3_dir, 'map', 'map.yaml'),
#default_value=os.path.join(bringup_dir, 'maps', 'turtlebot3_world.yaml'),
description='Full path to map file to load')
declare_use_sim_time_cmd = DeclareLaunchArgument(
'use_sim_time',
default_value='false',
description='Use simulation (Gazebo) clock if true')
declare_params_file_cmd = DeclareLaunchArgument(
'params_file',
default_value=os.path.join(tb3_dir, 'param', 'burger.yaml'),
description=
'Full path to the ROS2 parameters file to use for all launched nodes')
declare_bt_xml_cmd = DeclareLaunchArgument(
'bt_xml_file',
default_value=os.path.join(
get_package_share_directory('nav2_bt_navigator'), 'behavior_trees',
'navigate_w_replanning_and_recovery.xml'),
description='Full path to the behavior tree xml file to use')
declare_autostart_cmd = DeclareLaunchArgument(
'autostart',
default_value='false',
description='Automatically startup the nav2 stack')
declare_use_remappings_cmd = DeclareLaunchArgument(
'use_remappings',
default_value='false',
description='Arguments to pass to all nodes launched by the file')
declare_rviz_config_file_cmd = DeclareLaunchArgument(
'rviz_config_file',
default_value=os.path.join(bringup_dir, 'rviz',
'nav2_default_view.rviz'),
description='Full path to the RVIZ config file to use')
declare_use_simulator_cmd = DeclareLaunchArgument(
'use_simulator',
default_value='False',
description='Whether to start the simulator')
declare_use_robot_state_pub_cmd = DeclareLaunchArgument(
'use_robot_state_pub',
default_value='False',
description='Whether to start the robot state publisher')
declare_use_rviz_cmd = DeclareLaunchArgument(
'use_rviz', default_value='True', description='Whether to start RVIZ')
declare_simulator_cmd = DeclareLaunchArgument(
'headless',
default_value='False',
description='Whether to execute gzclient)')
declare_world_cmd = DeclareLaunchArgument(
'world',
# TODO(orduno) Switch back once ROS argument passing has been fixed upstream
# https://github.com/ROBOTIS-GIT/turtlebot3_simulations/issues/91
# default_value=os.path.join(get_package_share_directory('turtlebot3_gazebo'),
# 'worlds/turtlebot3_worlds/waffle.model'),
default_value=os.path.join(bringup_dir, 'worlds', 'waffle.model'),
description='Full path to world model file to load')
# Specify the actions
start_gazebo_server_cmd = ExecuteProcess(
condition=IfCondition(use_simulator),
cmd=['gzserver', '-s', 'libgazebo_ros_init.so', world],
cwd=[launch_dir],
output='screen')
start_gazebo_client_cmd = ExecuteProcess(condition=IfCondition(
PythonExpression([use_simulator, ' and not ', headless])),
cmd=['gzclient'],
cwd=[launch_dir],
output='screen')
urdf = os.path.join(get_package_share_directory('turtlebot3_description'),
'urdf', 'turtlebot3_waffle.urdf')
start_robot_state_publisher_cmd = Node(
condition=IfCondition(use_robot_state_pub),
package='robot_state_publisher',
node_executable='robot_state_publisher',
node_name='robot_state_publisher',
output='screen',
parameters=[{
'use_sim_time': use_sim_time
}],
use_remappings=IfCondition(use_remappings),
remappings=remappings,
arguments=[urdf])
start_rviz_cmd = Node(condition=IfCondition(use_rviz),
package='rviz2',
node_executable='rviz2',
node_name='rviz2',
arguments=['-d', rviz_config_file],
output='screen',
use_remappings=IfCondition(use_remappings),
remappings=[('/tf', 'tf'),
('/tf_static', 'tf_static'),
('goal_pose', 'goal_pose'),
('/clicked_point', 'clicked_point'),
('/initialpose', 'initialpose')])
exit_event_handler = RegisterEventHandler(
event_handler=OnProcessExit(target_action=start_rviz_cmd,
on_exit=EmitEvent(event=Shutdown(
reason='rviz exited'))))
bringup_cmd = IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(launch_dir, 'nav2_bringup_launch.py')),
launch_arguments={
'namespace': namespace,
'map': map_yaml_file,
'use_sim_time': use_sim_time,
'params_file': params_file,
'bt_xml_file': bt_xml_file,
'autostart': autostart,
'use_remappings': use_remappings
}.items())
# Create the launch description and populate
ld = LaunchDescription()
# Declare the launch options
ld.add_action(declare_namespace_cmd)
ld.add_action(declare_map_yaml_cmd)
ld.add_action(declare_use_sim_time_cmd)
ld.add_action(declare_params_file_cmd)
ld.add_action(declare_bt_xml_cmd)
ld.add_action(declare_autostart_cmd)
ld.add_action(declare_use_remappings_cmd)
ld.add_action(declare_rviz_config_file_cmd)
ld.add_action(declare_use_simulator_cmd)
ld.add_action(declare_use_robot_state_pub_cmd)
ld.add_action(declare_use_rviz_cmd)
ld.add_action(declare_simulator_cmd)
ld.add_action(declare_world_cmd)
# Add any conditioned actions
ld.add_action(start_gazebo_server_cmd)
ld.add_action(start_gazebo_client_cmd)
ld.add_action(start_rviz_cmd)
# Add other nodes and processes we need
ld.add_action(exit_event_handler)
# Add the actions to launch all of the navigation nodes
ld.add_action(start_robot_state_publisher_cmd)
ld.add_action(bringup_cmd)
return ld
