def generate_launch_description():
keystroke_node = Node(package='keystroke',
node_executable='keystroke_listen',
output='screen',
node_name='keystroke_listen',
parameters=[{
'exit_on_esc': True
}],
arguments=['__log_level:=warn'])
twist_node = Node(package='keystroke',
node_executable='keystroke_arrows_to_twist',
output='screen',
node_name='arrows_to_twist',
parameters=[{
'publish_period': 0.1,
'linear_scale': 0.1,
'angular_scale': 0.2
}])
return LaunchDescription([
keystroke_node, twist_node,
RegisterEventHandler(event_handler=OnProcessExit(
target_action=keystroke_node,
on_exit=[EmitEvent(event=Shutdown())],
)),
RegisterEventHandler(event_handler=OnProcessExit(
target_action=twist_node,
on_exit=[EmitEvent(event=Shutdown())],
))
])
def generate_launch_description():
share_dir = get_package_share_directory('ros2_ouster')
parameter_file = LaunchConfiguration('params_file')
node_name = 'ouster_driver'
params_declare = DeclareLaunchArgument(
'params_file',
default_value=os.path.join(share_dir, 'params', 'os1.yaml'),
description='FPath to the ROS2 parameters file to use.')
driver_node = LifecycleNode(
package='ros2_ouster',
executable='ouster_driver',
name=node_name,
output='screen',
emulate_tty=True,
parameters=[parameter_file],
namespace='/',
)
configure_event = EmitEvent(event=ChangeState(
lifecycle_node_matcher=matches_action(driver_node),
transition_id=lifecycle_msgs.msg.Transition.TRANSITION_CONFIGURE,
))
activate_event = RegisterEventHandler(
OnStateTransition(
target_lifecycle_node=driver_node,
goal_state='inactive',
entities=[
LogInfo(
msg="[LifecycleLaunch] Ouster driver node is activating."),
EmitEvent(event=ChangeState(
lifecycle_node_matcher=matches_action(driver_node),
transition_id=lifecycle_msgs.msg.Transition.
TRANSITION_ACTIVATE,
)),
],
))
# TODO make lifecycle transition to shutdown before SIGINT
shutdown_event = RegisterEventHandler(
OnShutdown(on_shutdown=[
EmitEvent(event=ChangeState(
lifecycle_node_matcher=matches_node_name(node_name=node_name),
transition_id=lifecycle_msgs.msg.Transition.
TRANSITION_ACTIVE_SHUTDOWN,
)),
LogInfo(msg="[LifecycleLaunch] Ouster driver node is exiting."),
], ))
return LaunchDescription([
params_declare,
driver_node,
activate_event,
configure_event,
shutdown_event,
])
def _succeed(self, test_name, side_effect=None):
"""Mark test as a success and shutdown if all other tests have finished too."""
assert test_name in self.__tests
self.__tests[test_name] = 'succeeded'
if all(status != 'armed' for status in self.__tests.values()):
return [EmitEvent(event=Shutdown(reason='all tests finished'))]
if side_effect == 'shutdown':
return [EmitEvent(event=Shutdown(reason='shutdown after test'))]
return []
def generate_launch_description():
share_dir = get_package_share_directory('serial_driver')
node_name = 'serial_bridge_node'
params_declare = DeclareLaunchArgument(
'params_file',
default_value=os.path.join(share_dir, 'params', 'example.params.yaml'),
description='File path to the ROS2 parameters file to use')
bridge_node = LifecycleNode(
package='serial_driver',
executable='serial_bridge',
name=node_name,
namespace=TextSubstitution(text=''),
parameters=[LaunchConfiguration('params_file')],
output='screen',
)
configure_event_handler = RegisterEventHandler(
event_handler=OnProcessStart(
target_action=bridge_node,
on_start=[
EmitEvent(event=ChangeState(
lifecycle_node_matcher=matches_action(bridge_node),
transition_id=Transition.TRANSITION_CONFIGURE,
), ),
],
))
activate_event_handler = RegisterEventHandler(
event_handler=OnStateTransition(
target_lifecycle_node=bridge_node,
start_state='configuring',
goal_state='inactive',
entities=[
EmitEvent(event=ChangeState(
lifecycle_node_matcher=matches_action(bridge_node),
transition_id=Transition.TRANSITION_ACTIVATE,
), ),
],
))
shutdown_event_handler = RegisterEventHandler(event_handler=OnShutdown(
on_shutdown=[
EmitEvent(event=ChangeState(
lifecycle_node_matcher=matches_node_name(node_name),
transition_id=Transition.TRANSITION_ACTIVE_SHUTDOWN,
))
]))
return LaunchDescription([
params_declare,
bridge_node,
configure_event_handler,
activate_event_handler,
shutdown_event_handler,
])
def generate_launch_description():
# Get the launch directory
example_dir = get_package_share_directory('social_nav2_goal_updaters')
stdout_linebuf_envvar = SetEnvironmentVariable(
'RCUTILS_LOGGING_BUFFERED_STREAM', '1')
# Specify the actions
escort_cmd = LifecycleNode(package='social_nav2_goal_updaters',
executable='escort_goal_updater_node',
name='escort_goal_updater_node',
output='screen',
parameters=[])
follow_cmd = LifecycleNode(package='social_nav2_goal_updaters',
executable='follow_goal_updater_node',
name='follow_goal_updater_node',
output='screen',
parameters=[])
hri_cmd = LifecycleNode(package='social_nav2_goal_updaters',
executable='hri_goal_updater_node',
name='hri_goal_updater_node',
output='screen',
parameters=[])
emit_event_to_request_that_escort_configure_transition = EmitEvent(
event=ChangeState(
lifecycle_node_matcher=launch.events.matches_action(escort_cmd),
transition_id=lifecycle_msgs.msg.Transition.TRANSITION_CONFIGURE,
))
emit_event_to_request_that_follow_configure_transition = EmitEvent(
event=ChangeState(
lifecycle_node_matcher=launch.events.matches_action(follow_cmd),
transition_id=lifecycle_msgs.msg.Transition.TRANSITION_CONFIGURE,
))
emit_event_to_request_that_hri_configure_transition = EmitEvent(
event=ChangeState(
lifecycle_node_matcher=launch.events.matches_action(hri_cmd),
transition_id=lifecycle_msgs.msg.Transition.TRANSITION_CONFIGURE,
))
# Create the launch description and populate
ld = LaunchDescription()
# Set environment variables
ld.add_action(stdout_linebuf_envvar)
# Declare the launch options
ld.add_action(escort_cmd)
ld.add_action(follow_cmd)
ld.add_action(hri_cmd)
ld.add_action(emit_event_to_request_that_escort_configure_transition)
ld.add_action(emit_event_to_request_that_follow_configure_transition)
ld.add_action(emit_event_to_request_that_hri_configure_transition)
return ld
def generate_launch_description():
"""Generate launch description."""
test_params = os.path.join(
get_package_share_directory('canopen_chain_node'),
'test/config/chain_node_params.yaml'
)
chain_node = LifecycleNode(
node_name='canopen_chain',
package='canopen_chain_node',
node_executable='manual_composition',
output='screen',
parameters=[
test_params
]
)
ros2_web_bridge = ExecuteProcess(
cmd=['node', '/opt/ros2-web-bridge/bin/rosbridge.js'],
output='screen'
)
# Make the node take the 'configure' transition.
emit_event_request_that_chain_node_does_configure_transition = EmitEvent(
event=launch_ros.events.lifecycle.ChangeState(
lifecycle_node_matcher=launch.events.matches_action(chain_node),
transition_id=lifecycle_msgs.msg.Transition.TRANSITION_CONFIGURE,
)
)
# When the node reaches the 'inactive' state, make it 'activate'
register_event_handler_for_chain_node_reaches_inactive_state = launch.actions.RegisterEventHandler( # noqa
launch_ros.event_handlers.OnStateTransition(
target_lifecycle_node=chain_node, goal_state='inactive',
entities=[
EmitEvent(event=launch_ros.events.lifecycle.ChangeState(
lifecycle_node_matcher=launch.events.matches_action(chain_node),
transition_id=lifecycle_msgs.msg.Transition.TRANSITION_ACTIVATE,
)),
],
)
)
ld = launch.LaunchDescription()
# Register nodes and event handlers before starting 'configure' transition
ld.add_action(register_event_handler_for_chain_node_reaches_inactive_state)
ld.add_action(chain_node)
ld.add_action(ros2_web_bridge)
ld.add_action(emit_event_request_that_chain_node_does_configure_transition)
return ld
def generate_launch_description():
localization_benchmark_supervisor_node = Node(
package='localization_performance_modelling',
node_executable='localization_benchmark_supervisor',
node_name='localization_benchmark_supervisor',
output='screen',
emulate_tty=True,
parameters=[LaunchConfiguration('configuration')],
)
return LaunchDescription([
# Set env var to print messages to stdout immediately
SetEnvironmentVariable('RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1'),
DeclareLaunchArgument('configuration',
description='Configuration yaml file path'),
DeclareLaunchArgument('use_sim_time',
description='Use simulation/bag clock if true'),
localization_benchmark_supervisor_node,
Node(package='nav2_lifecycle_manager',
node_executable='lifecycle_manager',
node_name='lifecycle_manager',
output='screen',
parameters=[{
'use_sim_time': LaunchConfiguration('use_sim_time')
}, {
'node_names': [
'map_server', 'amcl', 'controller_server',
'planner_server', 'recoveries_server', 'bt_navigator',
'waypoint_follower'
]
}]),
RegisterEventHandler(event_handler=OnProcessExit(
target_action=localization_benchmark_supervisor_node,
on_exit=EmitEvent(event=Shutdown(reason='supervisor_finished')))),
])
def generate_launch_description():
return launch.LaunchDescription(
[
IncludeLaunchDescription(
PythonLaunchDescriptionSource(
[get_package_share_directory(robot), "/launch/nav-core.py"]
),
launch_arguments={
"namespace": robot,
"params_file": os.path.join(
get_package_share_directory(robot), "param", f"{robot}.yml"
),
}.items(),
)
for robot in robots
]
+ [
RegisterEventHandler(
event_handler=OnProcessExit(
on_exit=[
EmitEvent(event=Shutdown()),
]
)
)
]
)
def generate_launch_description():
teleop_config = Path(get_package_share_directory('openrover_demo'), 'config', 'teleop.yaml')
assert teleop_config.is_file()
nodes = [
Node(
package='keystroke', node_executable='keystroke_listen', output='screen',
arguments=['__log_level:=warn'],
parameters=[teleop_config]
),
Node(
package='keystroke', node_executable='keystroke_arrows_to_twist', output='screen',
arguments=['__log_level:=info'],
parameters=[teleop_config]
)]
events = [RegisterEventHandler(
event_handler=OnProcessExit(
target_action=n,
on_exit=[EmitEvent(event=Shutdown())]
)
) for n in nodes]
return LaunchDescription([
SetEnvironmentVariable('RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1'),
*nodes,
*events
])
def generate_launch_description():
return launch.LaunchDescription([
IncludeLaunchDescription(
PythonLaunchDescriptionSource(
[get_package_share_directory(robot), "/launch/interfaces.py"]),
launch_arguments={
"namespace":
robot,
"params_file":
os.path.join(get_package_share_directory(robot), "param",
f"{robot}.yml"),
}.items(),
) for robot in robots
] + [
GroupAction([
Node(
package="strategix",
executable="strategix",
output="screen",
),
])
] + [
RegisterEventHandler(event_handler=OnProcessExit(on_exit=[
EmitEvent(event=Shutdown()),
]))
])
def generate_launch_description():
return launch.LaunchDescription(
[
IncludeLaunchDescription(
PythonLaunchDescriptionSource(
[get_package_share_directory(robot), "/launch/interfaces.py"]
),
launch_arguments={
"namespace": robot,
"params_file": os.path.join(
get_package_share_directory(robot), "param", f"{robot}.yml"
),
}.items(),
)
for robot in robots
]
+ [
IncludeLaunchDescription(
PythonLaunchDescriptionSource(
[
get_package_share_directory("assurancetourix"),
"/launch/launch.py",
]
),
launch_arguments={
"namespace": "assurancetourix",
"params_file": os.path.join(
get_package_share_directory("assurancetourix"),
"param",
"assurancetourix.yml",
),
}.items(),
)
]
+ [
GroupAction(
[
Node(
package="strategix",
executable="strategix",
output="screen",
),
WebotsLauncher(
mode="realtime",
world="tools/simulation/worlds/cdr2022.wbt",
),
]
)
]
+ [
RegisterEventHandler(
event_handler=OnProcessExit(
on_exit=[
EmitEvent(event=Shutdown()),
]
)
)
]
)
def generate_launch_description():
set_tty_launch_config_action = launch.actions.SetLaunchConfiguration(
"emulate_tty", "True")
# Launch Description
ld = launch.LaunchDescription()
# Watchdog node
watchdog_node = LifecycleNode(package='sw_watchdog',
node_executable='simple_watchdog',
node_namespace='',
node_name='simple_docker_watchdog',
output='screen',
arguments=['220', '--publish', '--activate']
#arguments=['__log_level:=debug']
)
# Make the Watchdog node take the 'activate' transition
watchdog_activate_trans_event = EmitEvent(event=ChangeState(
lifecycle_node_matcher=launch.events.matches_action(watchdog_node),
transition_id=lifecycle_msgs.msg.Transition.TRANSITION_ACTIVATE,
))
# When the watchdog reaches the 'inactive' state from 'active', log message
# and restart monitored entity (via docker)
watchdog_inactive_handler = RegisterEventHandler(
OnStateTransition(
target_lifecycle_node=watchdog_node,
start_state='deactivating',
goal_state='inactive',
entities=[
# Log
LogInfo(msg="Watchdog transitioned to 'INACTIVE' state."),
# Restart the monitored entity
OpaqueFunction(function=docker_restart),
# Change state event (inactive -> active)
watchdog_activate_trans_event,
],
))
# When Shutdown is requested, clean up docker
shutdown_handler = RegisterEventHandler(
OnShutdown(
on_shutdown=[
# Log
LogInfo(msg="watchdog_in_docker was asked to shutdown."),
# Clean up docker
OpaqueFunction(function=docker_stop),
], ))
# Add the actions to the launch description.
# The order they are added reflects the order in which they will be executed
ld.add_action(set_tty_launch_config_action)
ld.add_action(OpaqueFunction(function=docker_run))
ld.add_action(watchdog_node)
ld.add_action(watchdog_inactive_handler)
ld.add_action(shutdown_handler)
return ld
def _fail(self, test_name, reason):
"""Mark test as a failure and shutdown, dropping the tests that are still in progress."""
assert test_name in self.__tests
self.__tests[test_name] = 'failed'
for test_name in self.__tests:
if self.__tests[test_name] == 'armed':
self.__tests[test_name] = 'dropped'
return [EmitEvent(event=Shutdown(reason=reason))]
def on_test_process_exit(event, context):
nonlocal action
nonlocal self
self.__test_returncodes[action] = event.returncode
if len(self.__test_returncodes) == len(self.__test_processes):
shutdown_event = Shutdown(
reason='all test processes finished')
return EmitEvent(event=shutdown_event)
def generate_launch_description():
params_file_path = os.path.join(
get_package_share_directory('qualisys_driver'), 'config',
'qualisys_driver_params.yaml')
stdout_linebuf_envvar = SetEnvironmentVariable(
'RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1')
# print('')
# print('params_file_path: ', params_file_path)
# print('')
driver_node = LifecycleNode(
node_name='qualisys_driver_node',
package='qualisys_driver',
node_executable='qualisys_driver_main',
output='screen',
parameters=[params_file_path],
)
# Make the driver node take the 'configure' transition
driver_configure_trans_event = EmitEvent(event=ChangeState(
lifecycle_node_matcher=launch.events.matchers.matches_action(
driver_node),
transition_id=lifecycle_msgs.msg.Transition.TRANSITION_CONFIGURE,
))
# Make the driver node take the 'activate' transition
driver_activate_trans_event = EmitEvent(event=ChangeState(
lifecycle_node_matcher=launch.events.matchers.matches_action(
driver_node),
transition_id=lifecycle_msgs.msg.Transition.TRANSITION_ACTIVATE,
))
# Create the launch description and populate
ld = LaunchDescription()
ld.add_action(stdout_linebuf_envvar)
ld.add_action(driver_node)
ld.add_action(driver_configure_trans_event)
ld.add_action(driver_activate_trans_event)
return ld
def launch_gtest(test_path):
"""Launch a gtest."""
ld = LaunchDescription([
GTest(path=str(test_path),
timeout=5.0,
on_exit=[EmitEvent(event=Shutdown())])
])
ls = LaunchService()
ls.include_launch_description(ld)
assert 0 == ls.run()
def generate_launch_description():
synchronization = LaunchConfiguration('synchronization')
package = LaunchConfiguration('package')
executable = LaunchConfiguration('executable')
world = LaunchConfiguration('world')
gui = LaunchConfiguration('gui')
mode = LaunchConfiguration('mode')
publish_tf = LaunchConfiguration('publish_tf')
node_parameters = LaunchConfiguration('node_parameters')
robot_name = LaunchConfiguration('robot_name')
node_name = LaunchConfiguration('node_name')
use_sim_time = LaunchConfiguration('use_sim_time')
# Webots
webots = WebotsLauncher(world=world, mode=mode, gui=gui)
# Driver node
controller = ControllerLauncher(
package=package,
executable=executable,
parameters=[
node_parameters, {
'synchronization': synchronization,
'use_joint_state_publisher': publish_tf
}
],
output='screen',
arguments=[
'--webots-robot-name', robot_name, '--webots-node-name', node_name
],
)
# Robot state publisher
robot_state_publisher = Node(
package='robot_state_publisher',
executable='robot_state_publisher',
output='screen',
parameters=[{
'robot_description': '<robot name=""><link name=""/></robot>',
'use_sim_time': use_sim_time
}],
condition=launch.conditions.IfCondition(publish_tf))
return LaunchDescription(ARGUMENTS + [
robot_state_publisher,
webots,
controller,
# Shutdown launch when Webots exits.
RegisterEventHandler(event_handler=launch.event_handlers.OnProcessExit(
target_action=webots,
on_exit=[EmitEvent(event=launch.events.Shutdown())],
))
])
def on_fixture_process_exit(event, context):
process_name = event.action.process_details['name']
allowed_to_exit = exit_allowed
if isinstance(exit_allowed, list):
allowed_to_exit = event.returncode in exit_allowed
if not context.is_shutdown and not allowed_to_exit:
rc = event.returncode if event.returncode else 1
self.__processes_rc[process_name] = rc
return EmitEvent(event=Shutdown(
reason='{} fixture process died!'.format(
process_name)))
def __init__(
self,
target_action,
log_file,
timeout=None,
**kwargs
) -> None:
"""
Construct a SystemMetricCollector action.
Parameters
----------
target_action : ExecuteProcess
ExecuteProcess (or Node) instance to collect metrics on
log_file : str or LaunchSubstitutionsType
Path to where the collected metrics should be written to
timeout : int or LaunchSubstitutionsType
Maximum time to run the metrics collector if the target process does
not exit
"""
# These Node/ExecuteProcess arguments are invalid in this context
# because we implicitly set them right here.
assert 'arguments' not in kwargs
assert 'package' not in kwargs
assert 'executable' not in kwargs
assert 'executable' not in kwargs
self.__pid_var_name = '__PROCESS_ID_%d' % id(self)
kwargs['package'] = 'buildfarm_perf_tests'
kwargs['executable'] = 'system_metric_collector'
kwargs['arguments'] = [
'--log', log_file,
'--process_pid', LocalSubstitution(self.__pid_var_name)]
if timeout is not None:
kwargs['arguments'] += [
'--timeout',
str(timeout) if isinstance(timeout, int) else timeout
]
super().__init__(**kwargs)
self.__target_start_handler = OnProcessStart(
target_action=target_action, on_start=self.__on_target_start)
self.__target_exit_handler = OnProcessExit(
target_action=target_action, on_exit=EmitEvent(
event=ShutdownProcess(
process_matcher=matches_action(self))))
def generate_rviz_launch_description(namespace="robot"):
# Get the launch directory
titan_dir = get_package_share_directory("titan")
rviz_config_file = os.path.join(titan_dir, "rviz", "namespaced_view.rviz")
use_namespace = "true"
namespaced_rviz_config_file = ReplaceString(
source_file=rviz_config_file,
replacements={"<robot_namespace>": ("/", namespace)},
)
start_namespaced_rviz_cmd = Node(
condition=IfCondition(use_namespace),
package="rviz2",
executable="rviz2",
name="rviz2",
namespace=namespace,
# TODO: FIX onload MUTEX ERROR
# 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_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()
# Add any conditioned actions
ld.add_action(start_namespaced_rviz_cmd)
# Add other nodes and processes we need
ld.add_action(exit_event_handler_namespaced)
return ld
def generate_launch_description():
# Webots
arguments = [
'--mode=realtime', '--world=' +
os.path.join(get_package_share_directory('webots_ros2_epuck'),
'worlds', 'epuck_world.wbt')
]
webots = Node(package='webots_ros2_core',
node_executable='webots_launcher',
arguments=arguments,
output='screen')
# Controller node
synchronization = LaunchConfiguration('synchronization', default=False)
controller = ControllerLauncher(package='webots_ros2_epuck',
node_executable='driver',
parameters=[{
'synchronization':
synchronization
}],
output='screen')
# Rviz node
use_rviz = LaunchConfiguration('rviz', default=False)
rviz_config = os.path.join(
get_package_share_directory('webots_ros2_epuck'), 'resource',
'all.rviz')
rviz = Node(package='rviz2',
node_executable='rviz2',
output='screen',
arguments=['--display-config=' + rviz_config],
condition=launch.conditions.IfCondition(use_rviz))
# Launch descriptor
launch_entities = [
webots,
controller,
rviz,
# Shutdown launch when Webots exits.
RegisterEventHandler(event_handler=launch.event_handlers.OnProcessExit(
target_action=webots,
on_exit=[EmitEvent(event=launch.events.Shutdown())],
))
]
return LaunchDescription(launch_entities)
def generate_launch_description():
# Get the launch directory
bringup_dir = get_package_share_directory('amazon_robot_bringup')
# 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', 'amazon_robot_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 = ReplaceString(
source_file=rviz_config_file,
replacements={'<robot_namespace>': ('/', namespace)})
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():
# Get the launch directory
social_bringup_dir = get_package_share_directory('social_nav2_bringup')
nav_bringup_dir = get_package_share_directory('nav2_bringup')
launch_dir = os.path.join(nav_bringup_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')
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')
# 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 = 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(social_bringup_dir, 'maps',
'turtlebot3_house.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_use_remappings_cmd = DeclareLaunchArgument(
'use_remappings',
default_value='false',
description='Arguments to pass to all nodes launched by the file')
declare_params_file_cmd = DeclareLaunchArgument(
'params_file',
default_value=os.path.join(social_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(
'bt_xml_file',
default_value=os.path.join(
get_package_share_directory('social_nav2_bringup'),
'behavior_trees', 'follow_point.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(social_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='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(social_bringup_dir, 'worlds',
'waffle_house.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', '-s',
'libgazebo_ros_factory.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(social_bringup_dir, 'urdf', 'turtlebot3_waffle.urdf')
start_robot_state_publisher_cmd = Node(
condition=IfCondition(use_robot_state_pub),
package='robot_state_publisher',
executable='robot_state_publisher',
name='robot_state_publisher',
namespace=namespace,
output='screen',
parameters=[{
'use_sim_time': use_sim_time
}],
remappings=remappings,
arguments=[urdf])
start_rviz_cmd = Node(
condition=IfCondition(use_rviz),
package='rviz2',
executable='rviz2',
name='rviz2',
arguments=['-d', rviz_config_file],
output='screen',
)
exit_event_handler = RegisterEventHandler(
event_handler=OnProcessExit(target_action=start_rviz_cmd,
on_exit=EmitEvent(event=Shutdown(
reason='rviz exited'))))
agent_spawner_cmd = Node(package='pedsim_gazebo_plugin',
executable='spawn_pedsim_agents.py',
name='spawn_pedsim_agents',
output='screen')
# 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_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(agent_spawner_cmd)
ld.add_action(start_rviz_cmd)
ld.add_action(exit_event_handler)
# Add the actions to launch all of the navigation nodes
ld.add_action(start_robot_state_publisher_cmd)
return ld
def generate_launch_description():
package_name = 'ifm3d_ros2'
node_namespace = 'ifm3d'
node_name = 'camera'
node_exe = 'camera_standalone'
# os.environ['RCUTILS_CONSOLE_OUTPUT_FORMAT'] = \
# "[{%s}] {%s} [{%s}]: {%s}\n({%s}() at {%s}:{%s})" % \
# ("severity", "time", "name", "message",
# "function_name", "file_name", "line_number")
os.environ['RCUTILS_CONSOLE_OUTPUT_FORMAT'] = \
"[{%s}] {%s} [{%s}]: {%s}" % ("severity", "time", "name", "message")
# XXX: This is a hack, there does not seem to be a nice way (or at least
# finding the docs is not obvious) to do this with the ROS2 launch api
#
# Basically, we are trying to allow for passing through the command line
# args to the launch file through to the node executable itself (like ROS
# 1).
#
# My assumption is that either:
# 1. This stuff exists somewhere in ROS2 and I don't know about it yet
# 2. This stuff will exist in ROS2 soon, so, this will likely get factored
# out (hopefully soon)
#
parameters = []
remaps = []
for arg in sys.argv:
if ':=' in arg:
split_arg = arg.split(sep=':=', maxsplit=1)
assert len(split_arg) == 2
if arg.startswith("ns"):
node_namespace = split_arg[1]
elif arg.startswith("node"):
node_name = split_arg[1]
elif arg.startswith("params"):
parameters.append(tuple(split_arg)[1])
else:
remaps.append(tuple(split_arg))
def add_prefix(tup):
assert len(tup) == 2
if node_namespace.startswith("/"):
prefix = "%s/%s" % (node_namespace, node_name)
else:
prefix = "/%s/%s" % (node_namespace, node_name)
retval = [None, None]
if not tup[0].startswith(prefix):
retval[0] = prefix + '/' + tup[0]
else:
retval[0] = tup[0]
if not tup[1].startswith(prefix):
retval[1] = prefix + '/' + tup[1]
else:
retval[1] = tup[1]
return tuple(retval)
remaps = list(map(add_prefix, remaps))
#------------------------------------------------------------
# Nodes
#------------------------------------------------------------
#
# Coord frame transform from camera_optical_link to camera_link
#
tf_node = \
ExecuteProcess(
cmd=['ros2', 'run', 'tf2_ros', 'static_transform_publisher',
'0', '0', '0', str(-pi/2.), '0', str(-pi/2.),
str(node_name + "_link"), str(node_name + "_optical_link")],
#output='screen',
log_cmd=True
)
#
# The camera component
#
camera_node = \
LifecycleNode(
package=package_name,
node_executable=node_exe,
node_namespace=node_namespace,
node_name=node_name,
output='screen',
parameters=parameters,
remappings=remaps,
log_cmd=True,
)
#------------------------------------------------------------
# Events we need to emit to induce state transitions
#------------------------------------------------------------
camera_configure_evt = \
EmitEvent(
event=ChangeState(
lifecycle_node_matcher = \
launch.events.matches_action(camera_node),
transition_id = lifecycle_msgs.msg.Transition.TRANSITION_CONFIGURE
)
)
camera_activate_evt = \
EmitEvent(
event=ChangeState(
lifecycle_node_matcher = \
launch.events.matches_action(camera_node),
transition_id = lifecycle_msgs.msg.Transition.TRANSITION_ACTIVATE
)
)
camera_cleanup_evt = \
EmitEvent(
event=ChangeState(
lifecycle_node_matcher = \
launch.events.matches_action(camera_node),
transition_id = lifecycle_msgs.msg.Transition.TRANSITION_CLEANUP
)
)
camera_shutdown_evt = EmitEvent(event=launch.events.Shutdown())
#------------------------------------------------------------
# These are the edges of the state machine graph we want to autonomously
# manage
#------------------------------------------------------------
#
# unconfigured -> configuring -> inactive
#
camera_node_unconfigured_to_inactive_handler = \
RegisterEventHandler(
OnStateTransition(
target_lifecycle_node = camera_node,
start_state = 'configuring',
goal_state = 'inactive',
entities = [
LogInfo(msg = "Emitting 'TRANSITION_ACTIVATE' event"),
camera_activate_evt,
],
)
)
#
# active -> deactivating -> inactive
#
camera_node_active_to_inactive_handler = \
RegisterEventHandler(
OnStateTransition(
target_lifecycle_node = camera_node,
start_state = 'deactivating',
goal_state = 'inactive',
entities = [
LogInfo(msg = "Emitting 'TRANSITION_CLEANUP' event"),
camera_cleanup_evt,
],
)
)
#
# inactive -> cleaningup -> unconfigured
#
camera_node_inactive_to_unconfigured_handler = \
RegisterEventHandler(
OnStateTransition(
target_lifecycle_node = camera_node,
start_state = 'cleaningup',
goal_state = 'unconfigured',
entities = [
LogInfo(msg = "Emitting 'TRANSITION_CONFIGURE' event"),
camera_configure_evt,
],
)
)
#
# * -> errorprocessing -> unconfigured
#
camera_node_errorprocessing_to_unconfigured_handler = \
RegisterEventHandler(
OnStateTransition(
target_lifecycle_node = camera_node,
start_state = 'errorprocessing',
goal_state = 'unconfigured',
entities = [
LogInfo(msg = "Emitting 'TRANSITION_CONFIGURE' event"),
camera_configure_evt,
],
)
)
#
# * -> shuttingdown -> finalized
#
camera_node_shuttingdown_to_finalized_handler = \
RegisterEventHandler(
OnStateTransition(
target_lifecycle_node = camera_node,
start_state = 'shuttingdown',
goal_state = 'finalized',
entities = [
LogInfo(msg = "Emitting 'SHUTDOWN' event"),
camera_shutdown_evt,
],
)
)
#------------------------------------------------------------
# Now, add all the actions to a launch description and return it
#------------------------------------------------------------
ld = LaunchDescription()
ld.add_action(camera_node_unconfigured_to_inactive_handler)
ld.add_action(camera_node_active_to_inactive_handler)
ld.add_action(camera_node_inactive_to_unconfigured_handler)
ld.add_action(camera_node_errorprocessing_to_unconfigured_handler)
ld.add_action(camera_node_shuttingdown_to_finalized_handler)
ld.add_action(tf_node)
ld.add_action(camera_node)
ld.add_action(camera_configure_evt)
return ld
def generate_launch_description():
# 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
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')
# Launch configuration variables specific to simulation
rviz_config_file = LaunchConfiguration('rviz_config_file')
use_simulator = LaunchConfiguration('use_simulator')
simulator = LaunchConfiguration('simulator')
world = LaunchConfiguration('world')
# Declare the launch arguments
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_cmd = DeclareLaunchArgument(
'params_file',
default_value=os.path.join(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(
'bt_xml_file',
default_value=os.path.join(get_package_prefix('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_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='True',
description='Whether to start the simulator')
declare_simulator_cmd = DeclareLaunchArgument(
'simulator',
default_value='gazebo',
description='The simulator to use (gazebo or gzserver)')
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_cmd = ExecuteProcess(
condition=IfCondition(use_simulator),
cmd=[simulator, '-s', 'libgazebo_ros_init.so', world],
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(
package='robot_state_publisher',
node_executable='robot_state_publisher',
node_name='robot_state_publisher',
output='screen',
parameters=[{
'use_sim_time': use_sim_time
}],
arguments=[urdf])
# TODO(orduno) RVIZ crashing if launched as a node: https://github.com/ros2/rviz/issues/442
# Launching as node works after applying the change described on the github issue.
# start_rviz_cmd = Node(
# package='rviz2',
# node_executable='rviz2',
# node_name='rviz2',
# arguments=['-d', rviz_config_file],
# output='screen')
start_rviz_cmd = ExecuteProcess(cmd=[
os.path.join(get_package_prefix('rviz2'), 'lib/rviz2/rviz2'),
['-d', rviz_config_file]
],
cwd=[launch_dir],
output='screen')
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={
'map': map_yaml_file,
'use_sim_time': use_sim_time,
'params_file': params_file,
'bt_xml_file': bt_xml_file,
'autostart': autostart
}.items())
# Create the launch description and populate
ld = LaunchDescription()
# Declare the launch options
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_simulator_cmd)
ld.add_action(declare_simulator_cmd)
ld.add_action(declare_world_cmd)
# Add any actions to launch in simulation (conditioned on 'use_simulator')
ld.add_action(start_gazebo_cmd)
# Add other nodes and processes we need
ld.add_action(start_rviz_cmd)
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
def generate_launch_description():
# use: 'zed' for "ZED" camera - 'zedm' for "ZED mini" camera
camera_model = 'zed'
# URDF file to be loaded by Robot State Publisher
urdf = os.path.join(get_package_share_directory('stereolabs_zed'), 'urdf',
camera_model + '.urdf')
# ZED Configurations to be loaded by ZED Node
config_common = os.path.join(get_package_share_directory('stereolabs_zed'),
'config', 'common.yaml')
config_camera = os.path.join(get_package_share_directory('stereolabs_zed'),
'config', camera_model + '.yaml')
# Set LOG format
os.environ[
'RCUTILS_CONSOLE_OUTPUT_FORMAT'] = '{time}: [{name}] [{severity}]\t{message}'
# Launch Description
ld = launch.LaunchDescription()
# Prepare the ZED node
zed_node = LifecycleNode(
node_namespace='zed', # must match the namespace in config -> YAML
node_name='zed_node', # must match the node name in config -> YAML
package='stereolabs_zed',
node_executable='zed_wrapper_node',
output='screen',
parameters=[
config_common, # Common parameters
config_camera, # Camera related parameters
])
# Prepare the Robot State Publisher node
rsp_node = Node(node_name='zed_state_publisher',
package='robot_state_publisher',
node_executable='robot_state_publisher',
output='screen',
arguments=[urdf, 'robot_description:=zed_description'])
# Make the ZED node take the 'configure' transition
zed_configure_trans_event = EmitEvent(event=ChangeState(
lifecycle_node_matcher=launch.events.matches_action(zed_node),
transition_id=lifecycle_msgs.msg.Transition.TRANSITION_CONFIGURE,
))
# Make the ZED node take the 'activate' transition
zed_activate_trans_event = EmitEvent(event=ChangeState(
lifecycle_node_matcher=launch.events.matches_action(zed_node),
transition_id=lifecycle_msgs.msg.Transition.TRANSITION_ACTIVATE,
))
# Shutdown event
shutdown_event = EmitEvent(event=launch.events.Shutdown())
# When the ZED node reaches the 'inactive' state from 'unconfigured', make it take the 'activate' transition and start the Robot State Publisher
zed_inactive_from_unconfigured_state_handler = RegisterEventHandler(
OnStateTransition(
target_lifecycle_node=zed_node,
start_state='configuring',
goal_state='inactive',
entities=[
# Log
LogInfo(
msg=
"'ZED' reached the 'INACTIVE' state, start the 'Robot State Publisher' node and 'activating'."
),
# Robot State Publisher
rsp_node,
# Change State event ( inactive -> active )
zed_activate_trans_event,
],
))
# When the ZED node reaches the 'inactive' state from 'active', it has been deactivated and it will wait for a manual activation
zed_inactive_from_active_state_handler = RegisterEventHandler(
OnStateTransition(
target_lifecycle_node=zed_node,
start_state='deactivating',
goal_state='inactive',
entities=[
# Log
LogInfo(
msg=
"'ZED' reached the 'INACTIVE' state from 'ACTIVE' state. Waiting for manual activation..."
)
],
))
# When the ZED node reaches the 'active' state, log a message.
zed_active_state_handler = RegisterEventHandler(
OnStateTransition(
target_lifecycle_node=zed_node,
goal_state='active',
entities=[
# Log
LogInfo(msg="'ZED' reached the 'ACTIVE' state"),
],
))
# When the ZED node reaches the 'finalized' state, log a message and exit.
zed_finalized_state_handler = RegisterEventHandler(
OnStateTransition(
target_lifecycle_node=zed_node,
goal_state='finalized',
entities=[
# Log
LogInfo(
msg=
"'ZED' reached the 'FINALIZED' state. Killing the node..."
),
shutdown_event,
],
))
# Add the actions to the launch description.
# The order they are added reflects the order in which they will be executed.
ld.add_action(zed_inactive_from_unconfigured_state_handler)
ld.add_action(zed_inactive_from_active_state_handler)
ld.add_action(zed_active_state_handler)
ld.add_action(zed_finalized_state_handler)
ld.add_action(zed_node)
ld.add_action(zed_configure_trans_event)
return ld
def generate_launch_description():
# Get the launch directory
pkg_dir = get_package_share_directory('clean_up')
nav_dir = get_package_share_directory('gb_navigation')
manipulation_dir = get_package_share_directory('gb_manipulation')
gb_world_model_dir = get_package_share_directory('gb_world_model')
world_config_dir = os.path.join(gb_world_model_dir, 'config')
namespace = LaunchConfiguration('namespace')
dope_params_file = LaunchConfiguration('dope_params_file')
declare_dope_params_cmd = DeclareLaunchArgument(
'dope_params_file',
default_value=os.path.join(get_package_share_directory('dope_launch'),
'config', 'config_pose.yaml'),
description='Full path to the TF Pose Estimation parameters file to use'
)
declare_namespace_cmd = DeclareLaunchArgument('namespace',
default_value='',
description='Namespace')
stdout_linebuf_envvar = SetEnvironmentVariable(
'RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1')
gb_manipulation_cmd = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(get_package_share_directory('gb_manipulation'),
'launch', 'gb_manipulation_launch.py')))
gb_navigation_cmd = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(get_package_share_directory('gb_navigation'),
'launch', 'nav2_tiago_launch.py')))
plansys2_cmd = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(get_package_share_directory('plansys2_bringup'),
'launch', 'plansys2_bringup_launch_monolithic.py')),
launch_arguments={
'model_file':
pkg_dir + '/pddl/domain.pddl:' + nav_dir + '/pddl/domain.pddl'
}.items())
dope_cmd = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(get_package_share_directory('dope_launch'), 'launch',
'dope_launch.py')),
launch_arguments={'dope_params_file': dope_params_file}.items())
# Specify the actions
clean_up_executor_cmd = LifecycleNode(package='clean_up',
executable='cleanup_executor_node',
name='cleanup_executor_node')
emit_event_to_request_that_clean_up_executor_configure_transition = EmitEvent(
event=ChangeState(
lifecycle_node_matcher=launch.events.matches_action(
clean_up_executor_cmd),
transition_id=lifecycle_msgs.msg.Transition.TRANSITION_CONFIGURE,
))
emit_event_to_request_that_clean_up_executor_activate_transition = EmitEvent(
event=ChangeState(
lifecycle_node_matcher=launch.events.matches_action(
clean_up_executor_cmd),
transition_id=lifecycle_msgs.msg.Transition.TRANSITION_ACTIVATE,
))
on_configure_clean_up_executor_handler = RegisterEventHandler(
OnStateTransition(
target_lifecycle_node=clean_up_executor_cmd,
goal_state='inactive',
entities=[
emit_event_to_request_that_clean_up_executor_activate_transition
]))
# Specify the dependencies
vision_cmd = LifecycleNode(package='clean_up',
executable='vision_sim_node',
name='vision')
emit_event_to_request_that_vision_configure_transition = EmitEvent(
event=ChangeState(
lifecycle_node_matcher=launch.events.matches_action(vision_cmd),
transition_id=lifecycle_msgs.msg.Transition.TRANSITION_CONFIGURE,
))
attention_manager_cmd = Node(package='gb_attention',
executable='attention_server',
output='screen')
wm_cmd = Node(package='gb_world_model',
executable='world_model_main',
output='screen',
parameters=[world_config_dir + '/world.yml'])
ld = LaunchDescription()
# Set environment variables
ld.add_action(stdout_linebuf_envvar)
ld.add_action(declare_namespace_cmd)
ld.add_action(declare_dope_params_cmd)
# Declare the launch options
# Event handlers
ld.add_action(on_configure_clean_up_executor_handler)
ld.add_action(gb_manipulation_cmd)
ld.add_action(gb_navigation_cmd)
ld.add_action(plansys2_cmd)
ld.add_action(clean_up_executor_cmd)
ld.add_action(vision_cmd)
ld.add_action(emit_event_to_request_that_vision_configure_transition)
ld.add_action(
emit_event_to_request_that_clean_up_executor_configure_transition)
ld.add_action(attention_manager_cmd)
ld.add_action(wm_cmd)
ld.add_action(dope_cmd)
return ld
def generate_launch_description():
namespace = LaunchConfiguration('namespace')
use_sim_time = LaunchConfiguration('use_sim_time')
params_file = LaunchConfiguration('params_file')
bt_xml_file = LaunchConfiguration('bt_xml_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,
'bt_xml_filename': bt_xml_file,
}
configured_params = RewrittenYaml(source_file=params_file,
root_key=namespace,
param_rewrites=param_substitutions,
convert_types=True)
return LaunchDescription([
DeclareLaunchArgument('namespace',
default_value='',
description='Top-level namespace'),
DeclareLaunchArgument('use_sim_time',
default_value='false',
description='Use simulation/bag clock if true'),
DeclareLaunchArgument(
'params_file',
description='Full path to the ROS2 parameters file to use'),
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'),
DeclareLaunchArgument(
'use_remappings',
default_value='false',
description='Arguments to pass to all nodes launched by the file'),
Node(
package='nav2_controller',
node_executable='controller_server',
output='log',
parameters=[configured_params],
use_remappings=IfCondition(use_remappings),
remappings=remappings,
on_exit=EmitEvent(event=Shutdown(reason='nav2_controller_error'))),
Node(package='nav2_planner',
node_executable='planner_server',
node_name='planner_server',
output='log',
parameters=[configured_params],
use_remappings=IfCondition(use_remappings),
remappings=remappings,
on_exit=EmitEvent(event=Shutdown(reason='nav2_planner_error'))),
Node(
package='nav2_recoveries',
node_executable='recoveries_server',
node_name='recoveries_server',
output='log',
parameters=[{
'use_sim_time': use_sim_time
}],
use_remappings=IfCondition(use_remappings),
remappings=remappings,
on_exit=EmitEvent(event=Shutdown(reason='nav2_recoveries_error'))),
Node(package='nav2_bt_navigator',
node_executable='bt_navigator',
node_name='bt_navigator',
output='log',
parameters=[configured_params],
use_remappings=IfCondition(use_remappings),
remappings=remappings,
on_exit=EmitEvent(event=Shutdown(
reason='nav2_bt_navigator_error'))),
Node(package='nav2_waypoint_follower',
node_executable='waypoint_follower',
node_name='waypoint_follower',
output='log',
parameters=[configured_params],
use_remappings=IfCondition(use_remappings),
remappings=remappings,
on_exit=EmitEvent(event=Shutdown(
reason='nav2_waypoint_follower_error'))),
])
def generate_launch_description():
# Get the launch directory
nav2_bringup_dir = get_package_share_directory('nav2_bringup')
marathon_dir = get_package_share_directory('marathon_ros2_bringup')
marathon_launch_dir = os.path.join(marathon_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')
bt_xml_file = LaunchConfiguration('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')
# 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_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(marathon_dir, 'maps/aulario', '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(marathon_dir, 'params',
'nav2_marathon_teb_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(
'bt_xml_file',
default_value=os.path.join(
get_package_share_directory('marathon_ros2_bringup'),
'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',
node_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(marathon_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': bt_xml_file,
'autostart': autostart,
'cmd_vel_topic': cmd_vel_topic
}.items())
marathon_cmd = IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(marathon_launch_dir, 'nav2_marathon_launch.py')),
launch_arguments={
'total_distance_sum': '0.25',
'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(marathon_cmd)
# Add the actions to launch all of the navigation nodes
ld.add_action(bringup_cmd)
return ld
def generate_launch_description():
# 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
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')
simulator = LaunchConfiguration('simulator')
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'), ('/scan', 'scan'),
('/tf', 'tf'), ('/tf_static', 'tf_static'),
('/cmd_vel', 'cmd_vel'), ('/map', 'map')]
# 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(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_cmd = DeclareLaunchArgument(
'params_file',
default_value=os.path.join(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(
'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='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(
'simulator',
default_value='gazebo',
description='The simulator to use (gazebo or gzserver)')
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_cmd = ExecuteProcess(
condition=IfCondition(use_simulator),
cmd=[simulator, '-s', 'libgazebo_ros_init.so', world],
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_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