def generate_test_description(executable, ready_fn):
command = [executable]
# Execute python files using same python used to start this test
env = dict(os.environ)
if command[0][-3:] == '.py':
command.insert(0, sys.executable)
env['PYTHONUNBUFFERED'] = '1'
launch_description = LaunchDescription()
test_context = {}
for replacement_name, (replacement_value, cli_argument) in TEST_CASES.items():
random_string = '%d_%s' % (
random.randint(0, 9999), time.strftime('%H_%M_%S', time.gmtime()))
launch_description.add_action(
ExecuteProcess(
cmd=command + [cli_argument.format(**locals())],
name='name_maker_' + replacement_name, env=env
)
)
test_context[replacement_name] = replacement_value.format(**locals())
launch_description.add_action(
OpaqueFunction(function=lambda context: ready_fn())
)
return launch_description, test_context
def generate_launch_description():
use_sim_time = LaunchConfiguration("use_sim_time")
slam_params_file = LaunchConfiguration("slam_params_file")
declare_use_sim_time_argument = DeclareLaunchArgument(
"use_sim_time",
default_value="true",
description="Use simulation/Gazebo clock")
declare_slam_params_file_cmd = DeclareLaunchArgument(
"slam_params_file",
default_value=os.path.join(
get_package_share_directory("sm_aws_warehouse_navigation"),
"params",
"mapper_params_online_sync.yaml",
),
description=
"Full path to the ROS2 parameters file to use for the slam_toolbox node",
)
start_sync_slam_toolbox_node = Node(
parameters=[slam_params_file, {
"use_sim_time": use_sim_time
}],
package="slam_toolbox",
executable="sync_slam_toolbox_node",
name="slam_toolbox",
output="screen",
)
ld = LaunchDescription()
ld.add_action(declare_use_sim_time_argument)
ld.add_action(declare_slam_params_file_cmd)
ld.add_action(start_sync_slam_toolbox_node)
return ld
def generate_launch_description():
message = LaunchConfiguration('message')
declare_message_cmd = DeclareLaunchArgument('message')
stdout_linebuf_envvar = SetEnvironmentVariable(
'RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1')
file_param_node_cmd = Node(package='parameters_ros2',
node_executable='simple_param_node',
output='screen',
parameters=[{
"number": 2,
"person_name": "luis",
"message": message
}])
ld = LaunchDescription()
ld.add_action(stdout_linebuf_envvar)
ld.add_action(declare_message_cmd)
ld.add_action(file_param_node_cmd)
return ld
def generate_launch_description():
ob = LaunchDescription()
gps_link_node = Node(
package="tf2_ros",
executable="static_transform_publisher",
output="screen",
arguments=["0", "0", "1.77", "0", "0", "0", "base_link", "gps_link"])
lidar_link_node = Node(package="tf2_ros",
executable="static_transform_publisher",
output="screen",
arguments=[
"1.92", "0", "0.36", "0", "0", "0", "base_link",
"lidar_link"
])
zed2_link_node = Node(package="tf2_ros",
executable="static_transform_publisher",
output="screen",
arguments=[
"1.8", "0.03", "1", "0", "0", "0", "base_link",
"zed2_link"
])
ment_link_node = Node(package="tf2_ros",
executable="static_transform_publisher",
output="screen",
arguments=[
"-0.1", "0", "0.88", "3.14", "0", "0",
"base_link", "ment_link"
])
imu_link_node = Node(package="tf2_ros",
executable="static_transform_publisher",
output="screen",
arguments=[
"1.8", "0.5", "1", "-1.57", "0", "0", "base_link",
"imu_link"
])
ob.add_action(gps_link_node)
ob.add_action(lidar_link_node)
ob.add_action(zed2_link_node)
ob.add_action(ment_link_node)
ob.add_action(imu_link_node)
return ob
def generate_launch_description():
# Get the launch directory
example_dir = get_package_share_directory('plansys2_patrol_navigation_example')
plansys2_cmd = IncludeLaunchDescription(
PythonLaunchDescriptionSource(os.path.join(
get_package_share_directory('plansys2_bringup'),
'launch',
'plansys2_bringup_launch_monolithic.py')),
launch_arguments={'model_file': example_dir + '/pddl/patrol.pddl'}.items()
)
fake_nav2_cmd = Node(
package='plansys2_bt_example',
executable='nav2_sim_node',
name='nav2_sim_node',
output='screen',
parameters=[])
# Specify the actions
move_cmd = Node(
package='plansys2_patrol_navigation_example',
executable='move_action_node',
name='move_action_node',
output='screen',
parameters=[])
patrol_cmd = Node(
package='plansys2_patrol_navigation_example',
executable='patrol_action_node',
name='patrol_action_node',
output='screen',
parameters=[])
# Create the launch description and populate
ld = LaunchDescription()
# Declare the launch options
ld.add_action(plansys2_cmd)
ld.add_action(fake_nav2_cmd)
ld.add_action(move_cmd)
ld.add_action(patrol_cmd)
return ld
def generate_launch_description():
ld = LaunchDescription()
rviz_config_dir = os.path.join(
get_package_share_directory('interestingness_ros2'), 'intere.rviz')
assert os.path.exists(rviz_config_dir)
interestingness_node = Node(
package="interestingness_ros2",
executable="live_detector",
parameters=[
{
"image-topic": ["/rs_front/color/image"]
},
{
"model-save":
'/home/li/CMU_RISS/my_ws2/src/interestingness_ros2/saves/vgg16.pt.SubTF.n100usage.mse'
},
{
"crop-size": 320
},
{
"num-interest": 10
},
{
"skip-frames": 1
},
{
"window-size": 1
},
{
"save-flag": "test"
},
{
"rr": 3250
},
{
"wr": 5
},
])
rviz_node = Node(package='rviz2',
executable='rviz2',
name='rviz2',
output='screen',
arguments=['-d', rviz_config_dir])
marker_node = Node(package='interestingness_ros2',
executable='interest_marker',
name='interest_marker',
parameters=[
{
"min-level": 0.2
},
])
ld.add_action(interestingness_node)
ld.add_action(rviz_node)
ld.add_action(marker_node)
return ld
def generate_launch_description():
ld = LaunchDescription()
use_sim_time = LaunchConfiguration('use_sim_time', default='false')
package_name = 'robot_sim'
urdf_name = "robot.urdf"
package_path = FindPackageShare(package=package_name).find(package_name)
urdf_path = os.path.join(package_path, 'urdf', urdf_name)
param_path = os.path.join(package_path, 'param', 'params.yaml')
launch_path = os.path.join(package_path, 'launch')
with open(urdf_path, 'r') as urdf:
robot_desc = urdf.read()
info = LogInfo(msg=['Execute Robot Sim'])
robot_sim_node = Node(package=package_name,
executable='robot_sim',
parameters=[param_path],
output='screen')
robot_state_publisher_node = Node(package='robot_state_publisher',
executable='robot_state_publisher',
name='robot_state_publisher',
output='screen',
arguments=[urdf_path],
parameters=[{
'use_sim_time':
use_sim_time,
'robot_description':
robot_desc
}])
rviz_launch = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(launch_path, 'rviz2.launch.py')))
ld.add_action(info)
ld.add_action(robot_sim_node)
ld.add_action(robot_state_publisher_node)
ld.add_action(rviz_launch)
return ld
def generate_launch_description():
ld = LaunchDescription()
use_sim_time_cfg = LaunchConfiguration('use_sim_time', default='true')
robot_name_in_model = 'robot_gazebo'
package_name = 'robot_gazebo'
urdf_name = "robot.urdf"
package_path = FindPackageShare(package=package_name).find(package_name)
urdf_path = os.path.join(package_path, 'urdf', urdf_name)
launch_path = os.path.join(package_path, 'launch')
print('\033[92m' + "spawn_entity: Use urdf dir: " + urdf_path + '\033[0m')
gazebo_world_path = os.path.join(package_path, 'worlds/migong.world')
use_sim_time_arg = DeclareLaunchArgument(
'use_sim_time',
default_value='true',
description='Use simulation (Gazebo) clock if true')
# Start Gazebo server
start_gazebo_cmd = ExecuteProcess(cmd=[
'gazebo', '--verbose', '-s', 'libgazebo_ros_factory.so',
gazebo_world_path
],
additional_env={
'GAZEBO_MODEL_PATH':
os.path.join(package_path, 'meshes')
},
output='screen')
# Launch the robot
spawn_entity_node = Node(
package='gazebo_ros',
executable='spawn_entity.py',
arguments=['-entity', robot_name_in_model, '-file', urdf_path],
output='screen')
robot_state_publisher_launch = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(launch_path, 'robot_state_publisher.launch.py')),
launch_arguments={
'use_sim_time': use_sim_time_cfg,
'urdf_path': urdf_path
}.items())
ld.add_action(use_sim_time_arg)
ld.add_action(start_gazebo_cmd)
ld.add_action(robot_state_publisher_launch)
ld.add_action(spawn_entity_node)
return ld
def 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 generate_launch_description():
use_sim_time = LaunchConfiguration('use_sim_time', default='false')
urdf_file = os.path.join(get_package_share_directory('gbot_core'), 'urdf',
'head_2d.urdf')
with open(urdf_file, 'r') as infp:
urdf = infp.read()
start_robot_state_publisher_node = Node(package='robot_state_publisher',
executable='robot_state_publisher',
name='robot_state_publisher_node',
output='screen',
parameters=[{
'use_sim_time':
use_sim_time,
'robot_description':
urdf
}])
cartographer_config_files_dir = os.path.join(
get_package_share_directory('gbot_core'), 'configuration_files')
start_cartographer_node = Node(package='cartographer_ros',
executable='cartographer_node',
name='cartographer_node',
output='screen',
parameters=[{
'use_sim_time': use_sim_time
}],
arguments=[
'-configuration_directory',
cartographer_config_files_dir,
'-configuration_basename',
'gbot_lidar_2d.lua'
])
# Additional node which converts Cartographer map into ROS occupancy grid map.
# Not used and can be skipped in this case
start_occupancy_grid_node = Node(package='cartographer_ros',
executable='occupancy_grid_node',
name='cartographer_occupancy_grid_node',
output='screen',
parameters=[{
'use_sim_time': use_sim_time
}],
arguments=['-resolution', '0.05'])
ld = LaunchDescription()
ld.add_action(start_robot_state_publisher_node)
ld.add_action(start_cartographer_node)
ld.add_action(start_occupancy_grid_node)
return ld
def generate_launch_description():
ld = LaunchDescription()
# add the sink node
total_nodes = int(work_nodes_count) + 2
sink_node_topic_name = topic_base + '_' + str(total_nodes -
2) + '_' + str(total_nodes -
1)
sink_node = Node(env=rmw_env_sub,
package='mp_latency',
namespace='ipc_lat',
executable=exe_sink,
output='screen',
arguments=[
test_duration, rely_type, pub_frequency,
str(total_nodes), sink_node_topic_name, rmw_sub_type,
config_name
],
name='sink')
ld.add_action(sink_node)
# add the work nodes
for n in range(1, (total_nodes - 1)):
this_node_name = 'work{}'.format(str(n))
from_node_topic_name = '{}_{}_{}'.format(topic_base, str(n - 1),
str(n))
to_node_topic_name = '{}_{}_{}'.format(topic_base, str(n), str(n + 1))
ld.add_action(
Node(package='mp_latency',
namespace='ipc_lat',
executable=exe_work,
output='screen',
arguments=[
test_duration, rely_type,
str(n), from_node_topic_name, to_node_topic_name
],
name=this_node_name))
# add the source node
source_node_topic_name = '{}_0_1'.format(topic_base)
ld.add_action(
Node(package='mp_latency',
namespace='ipc_lat',
executable=exe_source,
output='screen',
arguments=[
test_duration, rely_type, pub_frequency, '0',
source_node_topic_name, rmw_type
],
name='source'))
return ld
def generate_launch_description():
ld = LaunchDescription()
duckiebot_urdf = os.path.join(
get_package_share_directory('duckiebot_interface'), 'urdf',
'duckiebot.urdf')
robot_state_publisher_node = Node(package='robot_state_publisher',
node_name='robot_state_publisher',
node_executable='robot_state_publisher',
output='screen',
arguments=[duckiebot_urdf])
#start wheels driver node
wheels_driver_node = Node(package='dagu_car',
node_name='wheels_driver_node',
node_executable='wheels_driver_node',
output='screen')
#start LED emitter node
led_emitter_node_config = os.path.join(
get_package_share_directory('led_emitter'), 'config/led_emitter_node',
'LED_protocol.yaml')
led_emitter_node = Node(package='led_emitter',
node_name='led_emitter_node',
node_executable='led_emitter_node',
output='screen',
parameters=[led_emitter_node_config])
#start camera node
camera_node = Node(package='camera_driver',
node_name='camera_node',
node_executable='camera_node',
output='screen')
ld.add_action(robot_state_publisher_node)
ld.add_action(wheels_driver_node)
ld.add_action(led_emitter_node)
ld.add_action(camera_node)
return ld
def generate_launch_description():
ld = LaunchDescription()
# Set env var to print messages to stdout immediately
arg = SetEnvironmentVariable('RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1')
ld.add_action(arg)
driver_launch = IncludeLaunchDescription(
PythonLaunchDescriptionSource(launch_file_path=PathJoinSubstitution([
FindPackageShare('bluespace_ai_xsens_mti_driver'), 'launch',
'xsens_mti_node.launch.py'
]), ))
ld.add_action(driver_launch)
# Rviz2 node
rviz_config_path = os.path.join(
get_package_share_directory('bluespace_ai_xsens_mti_driver'), 'rviz',
'display.rviz')
rviz2_node = Node(
package='rviz2',
executable='rviz2',
name='xsens_rviz2',
output='screen',
arguments=[["-d"], [rviz_config_path]],
)
ld.add_action(rviz2_node)
# Robot State Publisher node
urdf_file_path = os.path.join(
get_package_share_directory('bluespace_ai_xsens_mti_driver'), 'urdf',
'MTi_6xx.urdf')
state_publisher_node = Node(
package='robot_state_publisher',
executable='robot_state_publisher',
name='xsens_state_publisher',
output='screen',
arguments=[urdf_file_path],
)
ld.add_action(state_publisher_node)
return ld
def generate_launch_description():
ld = LaunchDescription()
use_sim_time_cfg = LaunchConfiguration('use_sim_time', default='false')
package_name = 'robot'
urdf_name = "robot.urdf"
package_path = FindPackageShare(package=package_name).find(package_name)
launch_path = os.path.join(package_path, 'launch')
urdf_path = os.path.join(package_path, 'urdf', urdf_name)
params_path = os.path.join(package_path, 'config', 'params.yaml')
# 调用节点
start_robot = Node(package=package_name,
executable='robot',
parameters=[
params_path, {
'publish_odom_transform': True
}, {
'odom_frame': "/odom"
}
],
output='screen')
robot_state_publisher_launch = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(launch_path, 'robot_state_publisher.launch.py')),
launch_arguments={
'use_sim_time': use_sim_time_cfg,
'urdf_path': urdf_path
}.items())
rviz_launch = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(launch_path, 'rviz2.launch.py')))
# base_footprint_to_imu = Node(
# package='tf2_ros',
# executable='static_transform_publisher',
# arguments=['-0.035', '0', '0.95', '1.57', '0', '0', 'base_footprint', 'base_imu_link'],
# output='screen'
# )
ld.add_action(start_robot)
ld.add_action(robot_state_publisher_launch)
# ld.add_action(base_footprint_to_imu)
ld.add_action(rviz_launch)
return ld
def generate_launch_description():
# Create the launch configuration variables
model_file = LaunchConfiguration('model_file')
namespace = LaunchConfiguration('namespace')
params_file = LaunchConfiguration('params_file')
stdout_linebuf_envvar = SetEnvironmentVariable(
'RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1')
declare_model_file_cmd = DeclareLaunchArgument(
'model_file',
default_value='src/ros2_planning_system/'
'plansys2_domain_expert/test/pddl/domain_simple.pddl',
description='PDDL Model file')
declare_namespace_cmd = DeclareLaunchArgument(
'namespace',
default_value='',
description='Namespace')
# Specify the actions
domain_expert_cmd = Node(
package='plansys2_problem_expert',
node_executable='problem_expert_node',
node_name='problem_expert',
node_namespace=namespace,
output='screen',
parameters=[{'model_file': model_file}, params_file])
# Create the launch description and populate
ld = LaunchDescription()
# Set environment variables
ld.add_action(stdout_linebuf_envvar)
ld.add_action(declare_model_file_cmd)
ld.add_action(declare_namespace_cmd)
# Declare the launch options
ld.add_action(domain_expert_cmd)
return ld
def generate_launch_description():
# Get the launch directory
pkg_dir = get_package_share_directory('gb_manipulation')
namespace = LaunchConfiguration('namespace')
declare_namespace_cmd = DeclareLaunchArgument('namespace',
default_value='',
description='Namespace')
stdout_linebuf_envvar = SetEnvironmentVariable(
'RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1')
# Specify the actions
pick_1_cmd = Node(package='plansys2_bt_actions',
executable='bt_action_node',
name='pick_1',
namespace=namespace,
output='screen',
parameters=[
pkg_dir + '/config/params.yaml', {
'action_name':
'pick',
'bt_xml_file':
pkg_dir + '/behavior_trees_xml/pick.xml'
}
])
place_1_cmd = Node(package='plansys2_bt_actions',
executable='bt_action_node',
name='place_1',
namespace=namespace,
output='screen',
parameters=[
pkg_dir + '/config/params.yaml', {
'action_name':
'place',
'bt_xml_file':
pkg_dir + '/behavior_trees_xml/place.xml'
}
])
ld = LaunchDescription()
# Set environment variables
ld.add_action(stdout_linebuf_envvar)
ld.add_action(declare_namespace_cmd)
# Declare the launch options
ld.add_action(pick_1_cmd)
ld.add_action(place_1_cmd)
return ld
def generate_launch_description():
# Get the launch directory
bringup_dir = get_package_share_directory('plansys2_bringup')
config_dir = os.path.join(bringup_dir, 'params')
config_file = os.path.join(config_dir, 'plansys2_params.yaml')
# Create the launch configuration variables
model_file = LaunchConfiguration('model_file')
namespace = LaunchConfiguration('namespace')
stdout_linebuf_envvar = SetEnvironmentVariable(
'RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1')
declare_model_file_cmd = DeclareLaunchArgument(
'model_file', description='PDDL Model file')
declare_namespace_cmd = DeclareLaunchArgument('namespace',
default_value='',
description='Namespace')
plansys2_node_cmd = Node(package='plansys2_bringup',
node_executable='plansys2_node',
output='screen',
node_namespace=namespace,
parameters=[{
'model_file': model_file
}, config_file])
# Create the launch description and populate
ld = LaunchDescription()
# Set environment variables
ld.add_action(stdout_linebuf_envvar)
ld.add_action(declare_model_file_cmd)
ld.add_action(declare_namespace_cmd)
# Declare the launch options
ld.add_action(plansys2_node_cmd)
return ld
def generate_launch_description():
# parameter
dev = LaunchConfiguration('dev')
# sim = LaunchConfiguration('sim') # TODO : 現在未使用 シミュレータの切り替え用
# TODO : consai2r2_descriptionからのパラメータ読み込み
declare_dev_cmd = DeclareLaunchArgument('dev',
default_value='/dev/input/js0',
description='joystick device file')
start_joy_node_cmd = Node(package='joy',
node_executable='joy_node',
output='screen',
parameters=[{
'dev': dev
}])
start_teleop_node_cmd = Node(package='consai2r2_teleop',
node_executable='teleop_node',
output='screen')
start_sender_cmd = Node(
package='consai2r2_sender',
node_executable='sim_sender',
output='screen',
parameters=[
os.path.join(get_package_share_directory('consai2r2_sender'),
'config', 'grsim.yaml')
])
ld = LaunchDescription()
ld.add_action(declare_dev_cmd)
ld.add_action(start_joy_node_cmd)
ld.add_action(start_teleop_node_cmd)
ld.add_action(start_sender_cmd)
return ld
def generate_launch_description():
urdf_file_name = 'vehicle.urdf'
print("urdf_file_name : {}".format(urdf_file_name))
urdf_file = os.path.join(
get_package_share_directory('vehicle_model'),
'urdf',
urdf_file_name)
rviz_display_config_file = os.path.join(
get_package_share_directory('vehicle_model'),
'config',
'vehicle.rviz'
)
with open(urdf_file, 'r') as infp:
robot_description_file = infp.read();
ld = LaunchDescription();
robot_state_publisher = Node(
package='robot_state_publisher',
executable='robot_state_publisher',
parameters=[
{'use_sim_time': False},
{'robot_description': robot_description_file}
],
output='screen'
)
joint_state_publisher_gui = Node(
package='joint_state_publisher_gui',
executable='joint_state_publisher_gui',
output='screen'
)
rviz2 = Node(
package='rviz2',
executable='rviz2',
arguments=['-d', rviz_display_config_file],
output='screen'
)
ld.add_action(robot_state_publisher)
ld.add_action(joint_state_publisher_gui)
ld.add_action(rviz2)
return ld
def generate_launch_description():
ld = LaunchDescription()
arg = DeclareLaunchArgument("bagfile")
# this is a bad way to get the launch file
bag_file = sys.argv[-1]
bag_process = ExecuteProcess(
cmd=['ros2', 'bag', 'play', launch.substitutions.LaunchConfiguration("bagfile")]
)
ekf_node = Node(
package="robot_projects_ekf_localization",
executable="ekf_localization",
output={"both": "screen"},
parameters=[
{'filter_type':'ekf'}
]
)
vis_node = Node(
package="rviz2",
executable="rviz2",
arguments=["-d", os.path.join(get_package_share_directory("robot_projects_ekf_localization"), "config", "ekf_sim_world.rviz")],
output={"both": "screen"}
)
# get params file for eval node
parameters_file_name = "ekf_evaluate_params.yaml"
parameters_file_path = str(pathlib.Path(__file__).parents[1]) # get current path and go one level up
parameters_file_path += '/config/' + parameters_file_name
print(parameters_file_path)
eval_node = Node(
package="robot_projects_ekf_localization",
executable="ekf_evaluation",
parameters=[
parameters_file_path
]
)
ld.add_action(ekf_node)
ld.add_action(eval_node)
ld.add_action(bag_process)
ld.add_entity(vis_node)
ld.add_entity(arg)
return ld
def generate_launch_description():
# Webapp server node
ld = LaunchDescription()
remap_number_topic = ("number", "my_number")
atl_ide_webappserver_node = Node(
package="atl_blockly_ide_py_pkg",
executable="atl_ide_webappserver_node",
# name="my_number_publisher",
# remappings=[
# remap_number_topic
# ],
parameters=[{
"webapp_port": 8080
}, {
"atl_IDE_webappserver_install_dir":
os.path.join(get_package_share_directory('ide_bringup'),
'../../../../..', 'webapp_root/')
}])
atl_ide_python_code_executor_node = Node(
package="atl_blockly_ide_py_pkg",
executable="atl_ide_python_code_executor_node",
# name="my_number_publisher",
# remappings=[
# remap_number_topic
# ],
parameters=[{
"number_to_publish": 4
}])
atl_ide_session_manager_node = Node(
package="atl_blockly_ide_py_pkg",
executable="atl_ide_session_manager_node",
# name="my_number_publisher",
# remappings=[
# remap_number_topic
# ],
parameters=[{
"number_to_publish": 4
}])
ld.add_action(atl_ide_webappserver_node)
ld.add_action(atl_ide_python_code_executor_node)
ld.add_action(atl_ide_session_manager_node)
return ld
def generate_test_description():
launch_description = LaunchDescription()
# Set the output format to a "verbose" format that is expected by the executable output
launch_description.add_action(
SetEnvironmentVariable(
name='RCUTILS_CONSOLE_OUTPUT_FORMAT',
value='[{severity}] [{name}]: {message} '
'({function_name}() at {file_name}:{line_number})'))
executable = os.path.join(os.getcwd(), 'test_logging_long_messages')
if os.name == 'nt':
executable += '.exe'
process_name = 'test_logging_long_messages'
launch_description.add_action(
ExecuteProcess(cmd=[executable], name=process_name, output='screen'))
launch_description.add_action(launch_testing.actions.ReadyToTest())
return launch_description, {'process_name': process_name}
def generate_launch_description():
# launch paths
metrobot_description_dir = get_package_share_directory(
'metrobot_description')
metrobot_simulation_dir = get_package_share_directory(
'metrobot_simulation')
# Create the launch configuration variables
use_sim_time = LaunchConfiguration('use_sim_time', default='True')
launch_gazebo_cmd = IncludeLaunchDescription(
PythonLaunchDescriptionSource([
get_package_share_directory('gazebo_ros'),
'/launch/gazebo.launch.py'
]))
set_use_sim_time_cmd = ExecuteProcess(
cmd=['ros2', 'param', 'set', '/gazebo', 'use_sim_time', use_sim_time],
output='screen')
launch_robot_description_cmd = IncludeLaunchDescription(
PythonLaunchDescriptionSource([
metrobot_description_dir, '/launch/metrobot_description.launch.py'
]),
launch_arguments={'use_sim_time': use_sim_time}.items())
spawn_robot_cmd = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
[metrobot_simulation_dir, '/launch/spawn_metrobot.launch.py']))
ld = LaunchDescription()
ld.add_action(launch_gazebo_cmd)
ld.add_action(set_use_sim_time_cmd)
ld.add_action(launch_robot_description_cmd)
ld.add_action(spawn_robot_cmd)
return ld
def generate_launch_description():
# Create the launch description and populate
ld = LaunchDescription()
amazon_gazebo_package_dir = get_package_share_directory(
'amazon_robot_gazebo')
amazon_bringup_package_dir = get_package_share_directory(
'amazon_robot_bringup')
world = LaunchConfiguration('world')
# Our own gazebo world from CustomRobots
declare_world_cmd = DeclareLaunchArgument(
'world',
default_value=os.path.join(amazon_gazebo_package_dir, 'worlds',
'amazon_warehouse', 'amazon_robot.model'),
description='Full path to world model file to load')
# Default Nav2 actions
# Specify the actions
start_gazebo_server_cmd = ExecuteProcess(cmd=[
'gzserver', '--verbose', '-s', 'libgazebo_ros_factory.so', '-s',
'libgazebo_ros_force_system.so', world
],
output='screen')
start_gazebo_client_cmd = ExecuteProcess(cmd=['gzclient'], output='screen')
spawn_robot_cmd = IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(amazon_bringup_package_dir, 'launch',
'spawn_tb3_launch.py')),
launch_arguments={
'x_pose': '5',
'y_pose': '0',
'z_pose': '0.1',
'robot_name': 'test'
}.items())
ld.add_action(spawn_robot_cmd)
ld.add_action(declare_world_cmd)
ld.add_action(start_gazebo_server_cmd)
ld.add_action(start_gazebo_client_cmd)
return ld
def generate_launch_description():
ld = LaunchDescription()
use_sim_time_arg = DeclareLaunchArgument(
'use_sim_time',
default_value='true',
description='Use simulation (Gazebo) clock if true')
urdf_path_arg = DeclareLaunchArgument('urdf_path',
default_value='robot.urdf',
description='urdf_path')
ld.add_action(urdf_path_arg)
ld.add_action(use_sim_time_arg)
ld.add_action(OpaqueFunction(function=launch_setup))
return ld
def generate_launch_description():
# Get dir names
pkg_share = get_package_share_directory('diffbot2_description')
# Compute robot_description string
xacro_file = os.path.join(pkg_share, 'urdf/diffbot2.xacro')
robot_description = xacro.process(xacro_file)
# Launch description
launch_description = LaunchDescription()
# Define parameters
common_params = {
'robot_description': robot_description,
}
# Add nodes
launch_description.add_action(
launch.actions.DeclareLaunchArgument(
name='namespace', default_value='', description='Node namespace'
)
)
launch_description.add_action(
Node(
package='robot_state_publisher',
executable='robot_state_publisher',
name='robot_state_publisher',
output='screen',
namespace=LaunchConfiguration('namespace'),
parameters=[common_params],
)
)
launch_description.add_action(
Node(
package='joint_state_publisher',
executable='joint_state_publisher',
name='joint_state_publisher',
output='screen',
namespace=LaunchConfiguration('namespace'),
parameters=[common_params],
),
)
return launch_description
def generate_launch_description():
stdout_linebuf_envvar = SetEnvironmentVariable(
'RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1')
namespace = LaunchConfiguration('namespace')
params_file = LaunchConfiguration('params_file')
default_action_bt_xml_filename = LaunchConfiguration(
'default_action_bt_xml_filename')
declare_namespace_cmd = DeclareLaunchArgument('namespace',
default_value='',
description='Namespace')
declare_default_bt_file_cmd = DeclareLaunchArgument(
'default_action_bt_xml_filename',
default_value=os.path.join(
get_package_share_directory('plansys2_executor'), 'behavior_trees',
'plansys2_action_bt.xml'),
description='BT representing a PDDL action')
# Specify the actions
executor_cmd = Node(package='plansys2_executor',
node_executable='executor_node',
node_name='executor',
namespace=namespace,
output='screen',
parameters=[{
'default_action_bt_xml_filename':
default_action_bt_xml_filename
}, params_file])
# Create the launch description and populate
ld = LaunchDescription()
# Set environment variables
ld.add_action(stdout_linebuf_envvar)
ld.add_action(declare_namespace_cmd)
ld.add_action(declare_default_bt_file_cmd)
# Declare the launch options
ld.add_action(executor_cmd)
return ld
def generate_launch_description():
spawner_dir = get_package_share_directory('robot_spawner_pkg')
declare_robots_file_cmd = DeclareLaunchArgument(
'robots_file',
default_value=os.path.join(spawner_dir, 'tb3_swarmlab_arena.yaml'))
declare_base_frame_cmd = DeclareLaunchArgument(
'base_frame', default_value='base_footprint')
# Create the launch description and populate
ld = LaunchDescription()
# Add declarations for launch file arguments
ld.add_action(declare_robots_file_cmd)
ld.add_action(declare_base_frame_cmd)
# The opaque function is neccesary to resolve the context of the launch file and read the LaunchDescription param at runtime
ld.add_action(OpaqueFunction(function=initialize_robots))
return ld
def generate_launch_description():
ld = LaunchDescription([
LogInfo(msg = ['Launch ;'+PACKAGE_NAME]),
])
node = launch_ros.actions.LifecycleNode(
node_name = PACKAGE_NAME,
package = PACKAGE_NAME,
node_executable = NODE_EXECUTABLE,
node_namespace = NODE_NAMESPACE,
parameters=[],
output = 'screen',
)
# When the node reaches the 'inactive' state, make it to the 'activate'
evt_hwnd = launch.actions.RegisterEventHandler(
launch_ros.event_handlers.OnStateTransition(
target_lifecycle_node = node, goal_state='inactive',
entities=[
launch.actions.LogInfo(
msg = PACKAGE_NAME +
" reached the 'inactive' state, 'activating'."),
launch.actions.EmitEvent(
event=launch_ros.events.lifecycle.ChangeState(
lifecycle_node_matcher=launch.events.matches_action(node),
transition_id=lifecycle_msgs.msg.Transition.TRANSITION_ACTIVATE,
)),
],
)
)
# Make the node take the 'configure' transition.
emit_configure_transition = launch.actions.EmitEvent(
event=launch_ros.events.lifecycle.ChangeState(
lifecycle_node_matcher=launch.events.matches_action(node),
transition_id=lifecycle_msgs.msg.Transition.TRANSITION_CONFIGURE,
)
)
ld.add_action(evt_hwnd)
ld.add_action(node)
ld.add_action(emit_configure_transition)
return ld
def generate_launch_description():
# Substitution that can access launch configuration variables.
namespace = LaunchConfiguration('ns_variable')
# Action that declares a new launch argument.
declare_namespace_cmd = DeclareLaunchArgument(
'ns_variable', # variable name
default_value='new_ns', # default value
description='Top-level namespace') # description
# Action that executes a ROS node.
publisher_node = launch_ros.actions.Node(
package='tutorial_publisher', # package name
node_executable='talker', # executable file name
output='log', # output is selected of log, screen, both
node_name='publisher', # change node name
node_namespace=namespace, # add namespace
remappings=[((namespace, '/topic'), (namespace, '/new_topic'))
] # topic remapping
)
# Action that executes a ROS node.
subscriber_node = launch_ros.actions.Node(
package='tutorial_listener', # package name
node_executable='listener', # executable file name
output='log', # output is selected of log, screen, both
node_name='subscriber', # change node name
node_namespace=namespace, # add namespace
remappings=[((namespace, '/topic'), (namespace, '/new_topic'))
] # topic remapping
)
# Description of a launch-able system.
ld = LaunchDescription()
# Add an action to the LaunchDescription.
ld.add_action(declare_namespace_cmd)
ld.add_action(publisher_node)
ld.add_action(subscriber_node)
return ld
def generate_launch_description():
#this function gets the absolute shared path of the package
pkg_teleop = get_package_share_directory('teleop_twist_joy')
#uncomment these to view the output
#print(pkg_teleop)
#file_path= os.path.join(pkg_teleop, 'launch', 'teleop-launch.py'),
#print(file_path)
#ld=PythonLaunchDescriptionSource(file_path)
#print(ld)
#the include launch description function would launch a separate launch file in another package
launch_teleop = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(pkg_teleop, 'launch', 'teleop-launch.py'), ))
ld = LaunchDescription()
#run t1
t1 = Node(package='turtlesim',
namespace='turtlesim1',
executable='turtlesim_node',
name='sim')
#run t2
t2 = Node(package='turtlesim',
namespace='turtlesim2',
executable='turtlesim_node',
name='sim')
#run mimic
mimic = Node(package='turtlesim',
executable='mimic',
name='mimic',
remappings=[
('/input/pose', '/turtlesim1/turtle1/pose'),
('/output/cmd_vel', '/turtlesim2/turtle1/cmd_vel'),
])
ld.add_action(t1)
ld.add_action(t2)
ld.add_action(mimic)
ld.add_action(launch_teleop)
return ld
