The new driver for Universal Robots UR3, UR5 and UR10 robots with CB3 controllers and the e-series.

An example package with MoveIt2 configurations for UR robots.

Messages around the UR Dashboard server.

Provides controllers that use the speed scaling interface of Universal Robots.

Package for extracting the factory calibration from a UR robot and change it such that it can be used by ur_description to gain a correct URDF

Metapackage for universal robots

Implement the ROS middleware interface using GurumNetworks GurumDDS static code generation in C++.

Example files used as tutorials for MRPT ROS packages

ROS Path Planner with A* in TP-Space Engine

Reactive navigation for wheeled robots using MRPT navigation algorithms (TP-Space)

Nodes and programs to record and play MRPT rawlogs or to transform between rosbags and rawlogs.

Maintains a local obstacle map from recent sensor readings, including optional point cloud pipeline filtering or processing.

Package for robot 2D self-localization using dynamic or static (MRPT or ROS) maps. The interface is similar to amcl (https://wiki.ros.org/amcl) but supports different particle-filter algorithms, several grid maps at different heights, range-only localization, etc.

Tools related to the Mobile Robot Programming Toolkit (MRPT). Refer to https://wiki.ros.org/mrpt_navigation for further documentation.

Message, services, and actions, for other mrpt navigation packages.

C++ library to convert between custom mrpt_msgs messages and native MRPT classes

This package provides a ROS 2 node that publishes a static map for other nodes to use it. Unlike classic ROS 1 ``map_server``, this node can publish a range of different metric maps, not only occupancy grids.

YAML helper library common to MOLA modules

GUI for MOLA

CLI tools to manipulate trajectory files as a complement to the evo package

C++ library with algorithms for relocalization, global localization, or pose estimation given a large initial uncertainty

C++ library for searchable pose lists

ROS message, services, and actions used in other MOLA packages.

Advanced metric map classes, using the generic `mrpt::maps::CMetricMap` interface, for use in other MOLA odometry and SLAM modules.

Launcher app for MOLA systems

Fundamental C++ virtual interfaces and data types for the rest of MOLA modules

Offline RawDataSource from rosbag2 datasets

Offline RawDataSource from MRPT rawlog datasets

Offline RawDataSource from Paris LUCO (CT-ICP) odometry/SLAM datasets

Offline RawDataSource from MulRan datasets

Offline RawDataSource from Kitti odometry/SLAM datasets

Offline RawDataSource from Kitti-360 datasets

Offline RawDataSource from EUROC SLAM datasets

Demo and example launch files for MOLA

Bidirectional bridge ROS2-MOLA

Metapackage with all core open-sourced MOLA packages.

CLI tool to evaluate the KITTI odometry bechmark metrics to trajectory files

Provide CMake module to find GurumNetworks GurumDDS.

The control toolbox contains modules that are useful across all controllers.

Vendor pkg to install zenoh-cpp

Generic controller for forwarding commands.

Steering controller with tricycle kinematics. Rear fixed wheels are powering the vehicle and front wheel is steering.

Controller for a tricycle drive mobile base

transmission_interface contains data structures for representing mechanical transmissions, methods for propagating values between actuator and joint spaces and tooling to support this.

Package for steering robot configurations including odometry and interfaces.

self_test

3D testing framework for RViz.

Example plugin for RViz - documents and tests RViz plugin development

Library which provides the 3D rendering functionality in rviz.

Wrapper around ogre3d, it provides a fixed CMake module and an ExternalProject build of ogre.

Several default plugins for rviz to cover the basic functionality.

Common rviz API, used by rviz plugins and applications.

Wrapper around assimp, providing nothing but a dependency on assimp, on some systems. On others, it provides a fixed CMake module or even an ExternalProject build of assimp.

3D visualization tool for ROS.

Graphical frontend for interacting with joint_trajectory_controller instances.

Graphical frontend for interacting with the controller manager.

The ROS 2 command line tools for ROS2 Control.

Demo nodes for showing and testing functionalities of the ros2_control framework.

Metapackage for ros2_controllers related packages

The package provides shared test resources for ros2_control stack

Metapackage for ROS2 control related packages

A ROS 2 middleware implementation using zenoh-cpp

Package containing a prototype for lifecycle implementation

Package containing tools for dynamically loadable components

Adds action APIs for C++.

The ROS client library in C++.

Controller to publish readings of range sensors.

Generic position controller for forwarding position commands.

Broadcaster to publish cartesian states.

A set of tools for monitoring ROS2 Planning System

This package contains the tests package for the ROS2 Planning System

A terminal tool for monitor and manage the ROS2 Planning System

This package contains modules for developing PlanSys components in Python

This package contains the Problem Expert module for the ROS2 Planning System

This package contains the PDDL-based Planner module for the ROS2 Planning System

This package contains the PDDL-based Planner module for the ROS2 Planning System

This package contains a library for parsing PDDL domains and problems. This package derives from the work of Anders Jonsson, contained in https://github.com/wisdompoet/universal-pddl-parser.git with many modifications by Francisco Martin: * ROS2 packaging * Source code structure refactor * CMakeLists.txt for cmake compilation * Reading from String instead of files * Licensing

Messages and service files for the ROS2 Planning System

A controller/manager for the lifecycle nodes of the ROS2 Planning System

This package contains the Executor module for the ROS2 Planning System

This package contains the Domain Expert module for the ROS2 Planning System

This package contains the PDDL-based core for the ROS2 Planning System

This package contains the Problem Expert module for the ROS2 Planning System

Bringup scripts and configurations for the ROS2 Planning System

A fast and flexible implementation of Rigid Body Dynamics algorithms and their analytical derivatives.

Helper scripts and functionality to test industrial motion generation

MoveIt plugin to generate industrial trajectories PTP, LIN, CIRC and sequences thereof.

Controller based on PID implememenation from control_toolbox package.

The parallel_gripper_controller package

A generic, simple controller manager plugin for MoveIt.

SRDF-based plugins for MoveIt Setup Assistant

MoveIt Setup Steps for Simulation

C++ Interface for defining setup steps for MoveIt Setup Assistant

Core (meta) plugins for MoveIt Setup Assistant

MoveIt Setup Steps for ROS 2 Control

Generates a configuration package that makes it easy to use MoveIt

Various specialty plugins for MoveIt Setup Assistant

Provides real-time manipulator Cartesian and joint servoing.

moveit_runtime meta package contains MoveIt packages that are essential for its runtime (e.g. running MoveIt on robots).

Components of MoveIt connecting to MongoDB

Components of MoveIt that offer visualization

A trajectory cache for MoveIt 2 motion plans and cartesian plans.

Integration tests for moveit_ros

Components of MoveIt that offer interaction via interactive markers

Components of MoveIt that offer simpler remote (as from another ROS 2 node) interfaces to planning and execution

Planning components of MoveIt that use ROS

Components of MoveIt connecting to perception

Components of MoveIt connecting to occupancy map

The move_group node for MoveIt

ros_control controller manager interface for MoveIt

Enhanced tools for benchmarks in MoveIt

Components of MoveIt that use ROS

Mechanical, kinematic and visual description of the Pilz light weight arm PRBT.

PRBT support for Schunk pg70 gripper.

The prbt_ikfast_manipulator_plugin package

Python binding for MoveIt 2

Metapackage for MoveIt plugins.

STOMP Motion Planner for MoveIt

MoveIt interface to OMPL

The interface for using CHOMP within MoveIt

Meta package that installs all available planners for MoveIt

Package for all inverse kinematics solvers in MoveIt

Hybrid planning components of MoveIt 2

Core libraries used by MoveIt

Python library for loading moveit config parameters in launch files

Common support functionality used throughout MoveIt

Meta package that contains all essential packages of MoveIt 2

SE(3) pose and twist path data fusion estimator

SE(3) pose and twist path data fusion estimator

Metapackage with all state estimation packages MOLA packages.

LIDAR odometry system based on MOLA and MRPT components

Integrator of IMU angular velocity readings

Implementation of mecanum drive controller for 4 wheel drive.

Pinocchio-based implementation of ros2_control kinematics interface

Controller for executing joint-space trajectories on a group of joints

Broadcaster to publish joint state

Package with interfaces for handling of joint limits in controllers or in hardware. The package also implements Saturation Joint Limiter for position-velocity-acceleration set and other individual interfaces.

Controller to publish readings of IMU sensors.

ros2_control hardware interface testing

ros2_control hardware interface

gtsam

The gripper_controllers package

Controllers to interact with gpios.

ROS Foxglove Bridge

Generic controller for forwarding commands.

Controller to publish state of force-torque sensors.

*eprosima Fast DDS* (formerly Fast RTPS) is a C++ implementation of the DDS (Data Distribution Service) standard of the OMG (Object Management Group). eProsima Fast DDS implements the RTPS (Real Time Publish Subscribe) protocol, which provides publisher-subscriber communications over unreliable transports such as UDP, as defined and maintained by the Object Management Group (OMG) consortium. RTPS is also the wire interoperability protocol defined for the Data Distribution Service (DDS) standard. *eProsima Fast DDS* expose an API to access directly the RTPS protocol, giving the user full access to the protocol internals.

Bindings between Numpy and Eigen using Boost.Python

Generic controller for forwarding commands.

eCAL - enhanced Communication Abstraction Layer. A fast publish-subscribe cross-plattform middleware using Shared Memory and UDP.

Controller for a differential-drive mobile base.

diagnostics

diagnostic_updater contains tools for easily updating diagnostics. it is commonly used in device drivers to keep track of the status of output topics, device status, etc.

diagnostic_common_diagnostics

diagnostic_aggregator

Messages and services for the controller manager.

Description of controller_manager

Description of controller_interface

An extension of the Flexible Collision Library.

chomp_motion_planner

Steering controller with bicycle kinematics. Rear fixed wheel is powering the vehicle and front wheel is steering.

The autoware_lanelet2_extension_python package contains Python bindings for lanelet2_extension package

The autoware_lanelet2_extension package contains libraries to handle Lanelet2 format data.

Syntactic sugar for ROS2 nodes creation and management

Implementation of admittance controllers for different input and output interface.

Steering controller for Ackermann kinematics. Rear fixed wheels are powering the vehicle and front wheels are steering it.

LTTng tracing provider wrapper for image_pipeline ROS 2 meta-package.

tf2_tools

Small lib to transform sensor_msgs with tf. Most notably, PointCloud2

This package contains the ROS Python bindings for the tf2 library

This package contains the C++ ROS bindings for the tf2 library

The tf2_py package

tf2_msgs

KDL binding for tf2

tf2_geometry_msgs

Conversion functions between: - Eigen and KDL

tf2_eigen

tf2_bullet

tf2 is the second generation of the transform library, which lets the user keep track of multiple coordinate frames over time. tf2 maintains the relationship between coordinate frames in a tree structure buffered in time, and lets the user transform points, vectors, etc between any two coordinate frames at any desired point in time.

tf2 unit tests

Stereo and single image rectification and disparity processing.

Test messages for the ros_babel_fish project tests.

A runtime message handler for ROS. Allows subscription, publishing, calling of services and actions with messages known only at runtime as long as they are available in the local environment.

Functions and types for rclcpp::Parameter

OMPL is a free sampling-based motion planning library.

Nav2 Minimum TurtleBot4 Simulation

Nav2's minimum Turtlebot4 Description package

Nav2 Minimum TurtleBot3 Simulation

A simple viewer for ROS image topics. Includes a specialized viewer for stereo + disparity images.

Contains a node publish an image stream from single image file or avi motion file.

Single image rectification and color processing.

image_pipeline fills the gap between getting raw images from a camera driver and higher-level vision processing.

Gazebo ros2 control tests

gz_ros2_control_demos

Gazebo ros2_control package allows to control simulated robots using ros2_control framework.

A metapackage to bring in the default packages second generation Transform Library in ros, tf2.

Example usage of generate_parameter_library for a python module

Python to generate ROS parameter library.