def generate_launch_description():
ld = LaunchDescription()
# environment variables
DRONE_DEVICE_ID = os.getenv('DRONE_DEVICE_ID')
# arguments
ld.add_action(
DeclareLaunchArgument("rplidar_mode", default_value="outdoor"))
ld.add_action(
DeclareLaunchArgument("serial_port", default_value="/dev/rplidar"))
# mode select for rplidar
# ----------------------
# Sensitivity: optimized for longer ranger, better sensitivity but weak environment elimination
# Boost: optimized for sample rate
# Stability: for light elimination performance, but shorter range and lower sample rate
rplidar_mode = PythonExpression([
'"Stability" if "outdoor" == "',
LaunchConfiguration("rplidar_mode"), '" else "Sensitivity"'
])
#namespace declarations
namespace = DRONE_DEVICE_ID
# frame names
fcu_frame = DRONE_DEVICE_ID + "/fcu" # the same definition is in static_tf_launch.py file
rplidar_frame = DRONE_DEVICE_ID + "/rplidar" # the same definition is in static_tf_launch.py file
garmin_frame = DRONE_DEVICE_ID + "/garmin" # the same definition is in static_tf_launch.py file
ld.add_action(
Node(
namespace=namespace,
package='rplidar_ros2',
executable='rplidar',
name='rplidar',
parameters=[{
'serial_port': LaunchConfiguration("serial_port"),
'serial_baudrate': 256000, # A3
'frame_id': rplidar_frame,
'inverted': False,
'angle_compensate': True,
'scan_mode': rplidar_mode,
}],
output='screen',
), ),
ld.add_action(
IncludeLaunchDescription(
PythonLaunchDescriptionSource(
[ThisLaunchFileDir(), '/static_tf_launch.py'])), ),
return ld
def generate_launch_description():
gazebo = IncludeLaunchDescription(
PythonLaunchDescriptionSource([
os.path.join(get_package_share_directory('gazebo_ros'), 'launch'),
'/gazebo.launch.py'
]), )
gazebo_ros2_control_demos_path = os.path.join(
get_package_share_directory('gazebo_ros2_control_demos'))
xacro_file = os.path.join(gazebo_ros2_control_demos_path, 'urdf',
'effort_based_velocity.urdf')
doc = xacro.parse(open(xacro_file))
xacro.process_doc(doc)
params = {'robot_description': doc.toxml()}
node_robot_state_publisher = Node(package='robot_state_publisher',
executable='robot_state_publisher',
output='screen',
parameters=[params])
spawn_entity = Node(
package='gazebo_ros',
executable='spawn_entity.py',
arguments=['-topic', 'robot_description', '-entity', 'cartpole'],
output='screen')
load_joint_state_broadcaster = ExecuteProcess(cmd=[
'ros2', 'control', 'load_start_controller', 'joint_state_broadcaster'
],
output='screen')
load_effort_controller = ExecuteProcess(
cmd=[
'ros2', 'control', 'load_start_controller',
'effort_based_velocity_controller'
],
output='screen',
)
return LaunchDescription([
RegisterEventHandler(event_handler=OnProcessExit(
target_action=spawn_entity,
on_exit=[load_joint_state_broadcaster],
)),
RegisterEventHandler(event_handler=OnProcessExit(
target_action=load_joint_state_broadcaster,
on_exit=[load_effort_controller],
)),
gazebo,
node_robot_state_publisher,
spawn_entity,
])
def generate_launch_description():
"""Launch the example.launch.py launch file."""
return LaunchDescription([
LogInfo(msg=[
'Including launch file located at: ',
ThisLaunchFileDir(), '/example.launch.py'
]),
IncludeLaunchDescription(
PythonLaunchDescriptionSource(
[ThisLaunchFileDir(), '/example.launch.py'])),
])
def generate_launch_description():
ld = LaunchDescription()
# Specify the actions
bringup_cmd_group = GroupAction(
[IncludeLaunchDescription(
PythonLaunchDescriptionSource(os.path.join(
get_package_share_directory('cpp_pubsub'),
'launch',
'cpp_topic.launch.py'))),
IncludeLaunchDescription(
PythonLaunchDescriptionSource(os.path.join(
get_package_share_directory('py_pubsub'),
'py_topic.launch.py'))), # launch file for py in main share dir
]
)
# Add the actions to launch all of the navigation nodes
ld.add_action(bringup_cmd_group)
return ld
def generate_launch_description():
# Get gazebo_ros package path
sim_share_path = get_package_share_directory('arm_simulation')
# Launch param server
params_server = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(sim_share_path, 'launch',
'params_server.launch.py')), )
# Launch arm spawner
arm_spawner = IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(sim_share_path, 'launch', 'gazebo_spawn_arm.launch.py')),
launch_arguments={
'gym': 'True',
'gui': 'False'
}.items())
# Launch forward kinematics service
lobot_desc_share_path = get_package_share_directory('lobot_description')
arm_urdf_path = os.path.join(lobot_desc_share_path,
'robots/arm_standalone.urdf')
return LaunchDescription([params_server, arm_spawner])
def generate_launch_description():
base_launch = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
[ThisLaunchFileDir(), "/rrbot.launch.py"]),
launch_arguments={
"controllers_file": "rrbot_controllers_array.yaml",
"robot_controller": "rrbot_controller",
}.items(),
)
return LaunchDescription([base_launch])
def generate_launch_description():
return LaunchDescription([
IncludeLaunchDescription(
PythonLaunchDescriptionSource(
[ThisLaunchFileDir(), '/rplidar_s1_tcp.launch.py'])),
Node(
package='rviz2',
node_executable='rviz2',
output='screen',
arguments=['-d', [ThisLaunchFileDir(), '/../rviz/rplidar.rviz']],
)
])
def include(self,
package,
launch_file,
launch_dir=None,
launch_arguments=None):
'''
Include another launch file
'''
launch_file = self.find(package, launch_file, launch_dir)
self.entity(
IncludeLaunchDescription(AnyLaunchDescriptionSource(launch_file),
launch_arguments=launch_arguments))
def generate_launch_description():
gazebo = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
[PathJoinSubstitution([FindPackageShare("gazebo_ros"), "launch", "gazebo.launch.py"])]
),
launch_arguments={"verbose": "false"}.items(),
)
# Get URDF via xacro
robot_description_content = Command(
[
PathJoinSubstitution([FindExecutable(name="xacro")]),
" ",
PathJoinSubstitution(
[
FindPackageShare("ar3_description"),
"urdf",
"ar3_system_position_only.urdf.xacro",
]
),
" use_sim:=true",
]
)
robot_description = {"robot_description": robot_description_content}
node_robot_state_publisher = Node(
package="robot_state_publisher",
executable="robot_state_publisher",
output="screen",
parameters=[robot_description],
)
spawn_entity = Node(
package="gazebo_ros",
executable="spawn_entity.py",
arguments=["-topic", "robot_description", "-entity", "ar3_system_position"],
output="screen",
)
spawn_controller = Node(
package="controller_manager",
executable="spawner",
arguments=["joint_state_broadcaster"],
output="screen",
)
return LaunchDescription(
[
gazebo,
node_robot_state_publisher,
spawn_entity,
spawn_controller,
]
)
def generate_launch_description():
teleop_joy_launch = os.path.join(
get_package_share_directory('teleop_twist_joy'), 'launch')
napp_teleop_joy = GroupAction([
IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(teleop_joy_launch, 'teleop-launch.py')),
launch_arguments={'joy_config':
'xbox'}.items()),
])
ld = LaunchDescription()
ld.add_action(napp_teleop_joy)
return ld
def generate_launch_description():
# Load Directories
pkg_gazebo_ros = get_package_share_directory('gazebo_ros')
marta_launch_dir = os.path.join(
get_package_share_directory('marta_launch'), 'launch')
rover_config_dir = os.path.join(
get_package_share_directory('rover_config'))
# Create urdf file from xacro and gazebo file from the package rover_config
pkg_rover_config = get_package_share_directory('rover_config')
xacro_model = os.path.join(pkg_rover_config, 'urdf', 'marta.xacro')
urdf_model = to_urdf(xacro_model)
world = LaunchConfiguration('world')
world_1 = os.path.join(rover_config_dir, 'worlds', 'turtlebot3_houses',
'waffle.model')
world_2 = os.path.join(pkg_gazebo_ros, 'worlds', 'empty.world')
world_3 = os.path.join(rover_config_dir, 'worlds', 'empty_worlds',
'world_only.model')
declare_world_cmd = DeclareLaunchArgument('world',
default_value=[world_3, ''],
description='SDF world file')
# Gazebo launch
# Starts the gzserver (handles computations) and gzclient (handles visualization)
gazebo = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(pkg_gazebo_ros, 'launch', 'gazebo.launch.py')), )
# Spawn rover
spawn_rover_cmd = Node(package='gazebo_ros',
executable='spawn_entity.py',
name='spawn_entity',
namespace=namespace_,
output='screen',
emulate_tty=True,
arguments=[
'-entity', 'marta', '-x', '-1.5', '-y', '-0.5',
'-z', '1', '-file', urdf_model,
'-reference_frame', 'world'
])
return LaunchDescription([
# Launch Arguments
declare_world_cmd,
gazebo,
# spawn_rover_cmd,
])
def generate_launch_description():
map_yaml_file = os.getenv('TEST_MAP')
world = os.getenv('TEST_WORLD')
bt_navigator_xml = os.path.join(
get_package_share_directory('nav2_bt_navigator'), 'behavior_trees',
os.getenv('BT_NAVIGATOR_XML'))
bringup_dir = get_package_share_directory('nav2_bringup')
params_file = os.path.join(bringup_dir, 'params', 'nav2_params.yaml')
# Replace the `use_astar` setting on the params file
param_substitutions = {'GridBased.use_astar': os.getenv('ASTAR')}
configured_params = RewrittenYaml(source_file=params_file,
root_key='',
param_rewrites=param_substitutions,
convert_types=True)
return LaunchDescription([
SetEnvironmentVariable('RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1'),
# Launch gazebo server for simulation
ExecuteProcess(cmd=[
'gzserver', '-s', 'libgazebo_ros_init.so', '--minimal_comms', world
],
output='screen'),
# TODO(orduno) Launch the robot state publisher instead
# using a local copy of TB3 urdf file
Node(package='tf2_ros',
node_executable='static_transform_publisher',
output='screen',
arguments=[
'0', '0', '0', '0', '0', '0', 'base_footprint', 'base_link'
]),
Node(
package='tf2_ros',
node_executable='static_transform_publisher',
output='screen',
arguments=['0', '0', '0', '0', '0', '0', 'base_link',
'base_scan']),
IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(bringup_dir, 'launch', 'bringup_launch.py')),
launch_arguments={
'namespace': '',
'use_namespace': 'False',
'map': map_yaml_file,
'use_sim_time': 'True',
'params_file': configured_params,
'bt_xml_file': bt_navigator_xml,
'autostart': 'True'
}.items()),
])
def generate_launch_description():
robot_description_content = Command([
PathJoinSubstitution([FindExecutable(name='xacro')]),
" ",
PathJoinSubstitution([
FindPackageShare('gazebo_ros2_control_demos'), 'urdf',
'test_gripper_mimic_joint.xacro.urdf'
]),
])
robot_description = {"robot_description": robot_description_content}
node_robot_state_publisher = Node(package='robot_state_publisher',
executable='robot_state_publisher',
output='screen',
parameters=[robot_description])
gazebo = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
[FindPackageShare("gazebo_ros"), "/launch",
"/gazebo.launch.py"]), )
spawn_entity = Node(
package='gazebo_ros',
executable='spawn_entity.py',
arguments=['-topic', 'robot_description', '-entity', 'gripper'],
output='screen')
load_joint_state_controller = ExecuteProcess(cmd=[
'ros2', 'control', 'load_controller', '--set-state', 'start',
'joint_state_broadcaster'
],
output='screen')
load_gripper_controller = ExecuteProcess(cmd=[
'ros2', 'control', 'load_controller', '--set-state', 'start',
'gripper_controller'
],
output='screen')
return LaunchDescription([
RegisterEventHandler(event_handler=OnProcessExit(
target_action=spawn_entity,
on_exit=[load_joint_state_controller],
)),
RegisterEventHandler(event_handler=OnProcessExit(
target_action=load_joint_state_controller,
on_exit=[load_gripper_controller],
)),
gazebo,
node_robot_state_publisher,
spawn_entity,
])
def generate_launch_description():
return LaunchDescription([
Node(
name = 'gym_node',
package = 'gym_duckietown_ros2_agent',
executable = 'rosagent',
output = 'screen'
),
Node(
name = 'view_node',
package = 'rqt_image_view',
executable = 'rqt_image_view',
#parameters = ['/lane_controller/corrected_image/compressed'],
output = 'screen'
),
Node(
name = 'line_center_node',
package = 'line_detect_center',
executable = 'line_detect_center',
output = 'screen'
),
Node(
name = 'line_right_node',
package = 'line_detect_right',
executable = 'line_detect_right',
output = 'screen'
),
Node(
name = 'lanectrl_node',
package = 'lane_controller',
executable = 'lane_controller',
output = 'screen'
),
Node(
name = 'statemachine_node',
package = 'statemachine',
executable = 'statemachine',
output = 'screen'
),
IncludeLaunchDescription(PythonLaunchDescriptionSource([get_package_share_directory('apriltag_ros'), '/launch/tag_16h5_all.launch.py'])),
])
def launch(shutdown_pipe, package_name, launch_file_name, launch_arguments,
debug):
"""Launch a ROS system."""
event_loop = asyncio.new_event_loop()
asyncio.set_event_loop(event_loop)
# based on ros2launch/command/launch.py:main
if package_name is None:
single_file = True
else:
single_file = False
get_package_prefix(package_name)
path = None
launch_arguments = []
if single_file:
if os.path.exists(package_name):
path = package_name
else:
raise ValueError(package_name)
if launch_file_name is not None:
launch_arguments.append(launch_file_name)
else:
try:
path = get_share_file_path_from_package(package_name=package_name,
file_name=launch_file_name)
except PackageNotFoundError as exc:
raise RuntimeError("Package '{}' not found: {}".format(
package_name, exc))
except (FileNotFoundError, MultipleLaunchFilesError) as exc:
raise RuntimeError(str(exc))
launch_arguments.extend(launch_arguments)
launch_service = LaunchService(argv=launch_arguments, debug=debug)
launch_description = LaunchDescription([
IncludeLaunchDescription(
AnyLaunchDescriptionSource(path),
launch_arguments={},
),
])
launch_service.include_launch_description(launch_description)
finished = False
def shutdown():
while not finished and not shutdown_pipe.poll(1):
pass
launch_service.shutdown()
t = threading.Thread(target=shutdown)
t.start()
launch_service.run(shutdown_when_idle=True)
finished = True
t.join()
event_loop.close()
def generate_launch_description():
return LaunchDescription([
DeclareLaunchArgument('namespace', default_value=''),
DeclareLaunchArgument('team', default_value='ijnek'),
DeclareLaunchArgument('unum', default_value='2'),
DeclareLaunchArgument('x', default_value='0.0'),
DeclareLaunchArgument('y', default_value='0.0'),
DeclareLaunchArgument('theta', default_value='0.0'),
Node(package='rcss3d_nao',
executable='rcss3d_nao',
namespace=LaunchConfiguration('namespace'),
parameters=[{
'team': LaunchConfiguration('team'),
'unum': LaunchConfiguration('unum'),
'x': LaunchConfiguration('x'),
'y': LaunchConfiguration('y'),
'theta': LaunchConfiguration('theta')
}]),
IncludeLaunchDescription(
PythonLaunchDescriptionSource([
get_package_share_directory('nao_state_publisher'), '/launch',
'/nao_state_publisher_launch.py'
]),
launch_arguments={
'namespace': LaunchConfiguration('namespace'),
}.items(),
),
Node(package='static_pose_publisher',
executable='static_pose_publisher',
namespace=LaunchConfiguration('namespace'),
parameters=[{
'x': LaunchConfiguration('x'),
'y': LaunchConfiguration('y'),
'theta': LaunchConfiguration('theta')
}]),
Node(
package='nao_ik',
executable='ik_node',
namespace=LaunchConfiguration('namespace'),
),
Node(
package='crouch',
executable='crouch_node',
namespace=LaunchConfiguration('namespace'),
),
Node(
package='kick',
executable='kick_node',
namespace=LaunchConfiguration('namespace'),
),
])
def generate_launch_description():
# Get the launch directory
example_dir = get_package_share_directory('plansys2_multidomain_example')
stdout_linebuf_envvar = SetEnvironmentVariable(
'RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1')
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_1/domain_1.pddl:' +
example_dir + '/pddl_2/domain_2.pddl'
}.items())
# Specify the actions
move_cmd = Node(
package='plansys2_multidomain_example',
node_executable='move_action_node',
node_name='move_action_node',
output='screen',
parameters=[])
charge_cmd = Node(
package='plansys2_multidomain_example',
node_executable='charge_action_node',
node_name='charge_action_node',
output='screen',
parameters=[])
ask_charge_cmd = Node(
package='plansys2_multidomain_example',
node_executable='ask_charge_action_node',
node_name='ask_charge_action_node',
output='screen',
parameters=[]) # Create the launch description and populate
ld = LaunchDescription()
# Set environment variables
ld.add_action(stdout_linebuf_envvar)
# Declare the launch options
ld.add_action(plansys2_cmd)
ld.add_action(move_cmd)
ld.add_action(charge_cmd)
ld.add_action(ask_charge_cmd)
return ld
def include_launch(
package: str,
name: str,
cond: Optional[str] = None,
**kwargs,
):
share = get_package_share_directory(package)
launch_path = os.path.join(share, 'launch', name)
return IncludeLaunchDescription(
PythonLaunchDescriptionSource(launch_path),
condition=IfCondition(LaunchConfiguration(cond)) if cond else None,
**kwargs
)
def generate_launch_description():
return LaunchDescription([
IncludeLaunchDescription(
PythonLaunchDescriptionSource(
[ThisLaunchFileDir(), "/start_turtlesim.launch.py"])),
Node(
package="dg_tutorial_with_turtlesim",
node_executable="dgm_main_turtlesim_multiprocess",
output="screen",
prefix=['xterm -e gdb -ex=r --args'],
# prefix=['xterm -hold -e'],
),
])
def generate_launch_description():
"""Launch the example.launch.py launch file."""
return LaunchDescription([
LogInfo(msg=[
'Including launch file located at: ',
ThisLaunchFileDir(), '/example.launch.py'
]),
IncludeLaunchDescription(
PythonLaunchDescriptionSource(
[ThisLaunchFileDir(), '/example.launch.py']),
launch_arguments={'node_prefix': 'FOO'}.items(),
),
])
def generate_launch_description():
# Launch Arguments
use_sim_time = LaunchConfiguration('use_sim_time', default=True)
config_rviz2 = LaunchConfiguration('config_rviz2', default=os.path.join(get_package_share_directory('ign_moveit2'),
'launch', 'rviz.rviz'))
return LaunchDescription([
# Launch Arguments
DeclareLaunchArgument(
'use_sim_time',
default_value=use_sim_time,
description="If true, use simulated clock"),
DeclareLaunchArgument(
'config_rviz2',
default_value=config_rviz2,
description="Path to config for RViz2"),
# MoveIt2 move_group action server with necessary ROS2 <-> Ignition bridges
IncludeLaunchDescription(
PythonLaunchDescriptionSource(
[os.path.join(get_package_share_directory('ign_moveit2'),
'launch', 'ign_moveit2.launch.py')]),
launch_arguments=[('use_sim_time', use_sim_time),
('config_rviz2', config_rviz2)]),
# Launch world
IncludeLaunchDescription(
PythonLaunchDescriptionSource(
[os.path.join(get_package_share_directory('ign_moveit2'),
'launch', 'examples', 'worlds', 'world_panda_throw.launch.py')]),
launch_arguments=[('use_sim_time', use_sim_time)]),
# Python example script (object throwing)
Node(name='ign_moveit2_example_throw',
package='ign_moveit2',
executable='example_throw.py',
output='screen',
parameters=[{'use_sim_time': use_sim_time}])
])
def generate_launch_description():
# Path
gazebo_launch_dir = os.path.join(
get_package_share_directory('neuronbot2_gazebo'), 'launch')
nb2slam_launch_dir = os.path.join(
get_package_share_directory('neuronbot2_slam'), 'launch')
# Parameters
use_sim_time = LaunchConfiguration('use_sim_time', default='True')
open_rviz = LaunchConfiguration('open_rviz', default='True')
## mememan_world.model / phenix_world.model
world_model = LaunchConfiguration('world_model',
default='mememan_world.model')
neuron_app_bringup = GroupAction([
IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(gazebo_launch_dir, 'neuronbot2_world.launch.py')),
launch_arguments={
'use_sim_time': use_sim_time,
'world_model': world_model
}.items()),
IncludeLaunchDescription(PythonLaunchDescriptionSource(
os.path.join(nb2slam_launch_dir, 'gmapping_launch.py')),
launch_arguments={
'use_sim_time': use_sim_time,
'open_rviz': open_rviz
}.items()),
])
# Run mouse teleop
mouse_teleop = Node(package='mouse_teleop',
executable='mouse_teleop',
remappings=[('mouse_vel', 'cmd_vel')],
output='screen')
ld = LaunchDescription()
ld.add_action(neuron_app_bringup)
ld.add_action(mouse_teleop)
return ld
def generate_launch_description():
pkg_share = FindPackageShare("robot_tennis_description").find("robot_tennis_description")
xacro_path = os.path.join(pkg_share,"urdf","robot.urdf.xacro")
gazebo_path = os.path.join(get_package_share_directory('gazebo_ros'), "launch")
gazebo_node = IncludeLaunchDescription(PythonLaunchDescriptionSource([gazebo_path, '/gazebo.launch.py']))
robot_state_publisher_node = Node(package='robot_state_publisher',executable='robot_state_publisher',parameters= [{"robot_description" : Command(["xacro"," ", xacro_path])}])
spawn_entity = Node(package='gazebo_ros', executable='spawn_entity.py',arguments=['-entity', 'robot_tennis','-topic','/robot_description'])
catcher_ctrl_node = Node(package='catcher_control',executable='ctrl')
return LaunchDescription([catcher_ctrl_node,robot_state_publisher_node,gazebo_node,spawn_entity])
def generate_launch_description():
config_rviz2 = os.path.join(get_package_share_directory('ecard'), 'config',
'rgbd_gaze', 'calibration', 'rviz2.rviz')
return LaunchDescription([
IncludeLaunchDescription(
PythonLaunchDescriptionSource([
os.path.join(get_package_share_directory('ecard'), 'launch',
'rs', 'rs_face_d415.launch.py')
]), ),
IncludeLaunchDescription(
PythonLaunchDescriptionSource([
os.path.join(get_package_share_directory('ecard'), 'launch',
'rgbd_gaze', 'calibration_eyeball.launch.py')
]), ),
IncludeLaunchDescription(PythonLaunchDescriptionSource([
os.path.join(get_package_share_directory('ecard'), 'launch',
'rviz2.launch.py')
]),
launch_arguments=[('config_rviz2',
config_rviz2)]),
])
def generate_launch_description():
pkg_bringup = launch_ros.substitutions.FindPackageShare(
package='nanosaur_bringup').find('nanosaur_bringup')
pkg_description = launch_ros.substitutions.FindPackageShare(
package='nanosaur_description').find('nanosaur_description')
pkg_camera = launch_ros.substitutions.FindPackageShare(
package='nanosaur_camera').find('nanosaur_camera')
nanosaur_dir = LaunchConfiguration('nanosaur_dir',
default=os.path.join(
pkg_bringup, 'param',
'nanosaur.yml'))
nanosaur_node = launch_ros.actions.Node(package='nanosaur_robot',
executable='nanosaur',
name='nanosaur',
parameters=[nanosaur_dir],
output='screen')
return launch.LaunchDescription([
DeclareLaunchArgument(
'nanosaur_dir',
default_value=nanosaur_dir,
description='Full path to nanosaur parameter file to load'),
# https://answers.ros.org/question/306935/ros2-include-a-launch-file-from-a-launch-file/
IncludeLaunchDescription(
PythonLaunchDescriptionSource(
[pkg_description, '/launch/description.launch.py'])),
# Camera launch
IncludeLaunchDescription(
PythonLaunchDescriptionSource(
[pkg_camera, '/launch/camera.launch.py'])),
# Launch nanusaur driver
nanosaur_node
])
# EOF
def generate_launch_description():
use_sim_time = LaunchConfiguration('use_sim_time', default='true')
# world_file_name = 'amazon_warehouse.world'
# world = os.path.join(get_package_share_directory('amazon_robot_gazebo'), 'worlds', world_file_name)
# launch_file_dir = os.path.join(get_package_share_directory('amazon_robot_gazebo'), 'launch')
world_file_name = 'amazon_warehouse/amazon_robot.model'
world = os.path.join(get_package_share_directory('amazon_robot_gazebo'), 'worlds', world_file_name)
launch_file_dir = os.path.join(get_package_share_directory('amazon_robot_gazebo'), 'launch')
# sdf_file_name = 'amazon_robot2/model.sdf'
# sdf = os.path.join(
# get_package_share_directory('amazon_robot_gazebo'),
# 'models',
# sdf_file_name)
# urdf_file_name = 'amazon_warehouse_robot.urdf.xacro'
# urdf = os.path.join(
# get_package_share_directory('amazon_robot_description'),
# 'urdf',
# urdf_file_name)
# xml = open(sdf, 'r').read()
# xml = xml.replace('"', '\\"')
# swpan_args = '{name: \"amazon_robot\", xml: \"' + xml + '\" }'
return LaunchDescription([
ExecuteProcess(
cmd=['gazebo', '--verbose', world, '-s', 'libgazebo_ros_init.so'],
output='screen'),
# ExecuteProcess(
# cmd=['ros2', 'param', 'set', '/gazebo', 'use_sim_time', use_sim_time],
# output='screen'),
IncludeLaunchDescription(
PythonLaunchDescriptionSource([launch_file_dir, '/robot_state_publisher.py']),
launch_arguments={'use_sim_time': use_sim_time}.items(),
),
# ExecuteProcess(
# cmd=['ros2', 'service', 'call', '/spawn_entity', 'gazebo_msgs/SpawnEntity', swpan_args],
# output='screen'),
])
def generate_launch_description():
use_sim_time = LaunchConfiguration('use_sim_time', default='true')
sdf_dir = os.path.join(
get_package_share_directory('megarover_samples_ros2'),
'models/vmegarover')
sdf_file = os.path.join(sdf_dir, 'vmegarover.sdf')
launch_file_dir = os.path.join(
get_package_share_directory('megarover_samples_ros2'), 'launch')
pkg_gazebo_ros = get_package_share_directory('gazebo_ros')
return LaunchDescription([
IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(pkg_gazebo_ros, 'launch', 'gazebo.launch.py')), ),
Node(package='gazebo_ros',
executable='spawn_entity.py',
name='spawn_entity',
output='screen',
arguments=[
'-entity',
'vmegarover',
'-x',
'0',
'-y',
'0',
'-z',
'1',
'-file',
sdf_file,
]),
IncludeLaunchDescription(
PythonLaunchDescriptionSource(
[launch_file_dir, '/robot_state_publisher.launch.py']),
launch_arguments={'use_sim_time': use_sim_time}.items(),
),
])
def generate_launch_description():
# Include the default rplidar_ros launch file with default parameters.
# If you need to customize any rplidar parameters uncomment and use the
# the launch config below.
rplidar_launchDescription = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(get_package_share_directory('rplidar_ros'), 'launch',
'rplidar.launch.py')),
launch_arguments={}.items())
# This launch action (node) was copied from rplidar.launch.py
# rplidar_launchDescription = Node(
# name='rplidar_node',
# package='rplidar_ros',
# executable='rplidar_composition',
# output='screen',
# parameters=[{
# 'serial_port': '/dev/ttyUSB0',
# 'serial_baudrate': 115200, # A1 / A2
# # 'serial_baudrate': 256000, # A3
# 'frame_id': 'laser',
# 'inverted': False,
# 'angle_compensate': True
# }],
# )
gbot_ros2_no_lidar_launchDescription = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(get_package_share_directory('gbot_core'), 'launch',
'gbot_ros2_no_lidar.launch.py')),
launch_arguments={}.items())
ld = LaunchDescription()
ld.add_action(rplidar_launchDescription)
ld.add_action(gbot_ros2_no_lidar_launchDescription)
return ld
def generate_launch_description():
docking_launch_dir = os.path.join(get_package_share_directory('apriltag_docking'), 'launch')
neuron_app_bringup = GroupAction([
IncludeLaunchDescription(
PythonLaunchDescriptionSource([docking_launch_dir, '/autodock_gazebo.launch.py']),
),
])
ld = LaunchDescription()
ld.add_action(neuron_app_bringup)
return ld
def generate_launch_description():
return LaunchDescription([
SetEnvironmentVariable('RCUTILS_CONSOLE_STDOUT_LINE_BUFFERED', '1'),
#Launch from Same Package
#Launch Rviz
IncludeLaunchDescription(PythonLaunchDescriptionSource([ThisLaunchFileDir(), '/rviz.launch.py'])),
#Launch SLAM
#TODO
#Launch Controller
IncludeLaunchDescription(PythonLaunchDescriptionSource([ThisLaunchFileDir(), '/controller.launch.py'])),
IncludeLaunchDescription(PythonLaunchDescriptionSource([ThisLaunchFileDir(), '/localization.launch.py'])),
IncludeLaunchDescription(PythonLaunchDescriptionSource([ThisLaunchFileDir(), '/slam.launch.py'])),
#Pull from different packages
#IncludeLaunchDescription(
# PythonLaunchDescriptionSource(os.path.join(launch_dir,
# 'bringup_launch.py')),
# launch_arguments={
# 'map': "/home/ros/willmap.yaml"}.items()),
#IncludeLaunchDescription(PythonLaunchDescriptionSource(os.path.join(launch_dir, 'localization_launch.py')),
])
