Code shared on static and dynamic type support of rmw_gurumdds_cpp.

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

A ROS2 Driver for V4L USB Cameras

Parser for Semantic Robot Description Format (SRDF).

Helper scripts and functionality to test industrial motion generation

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

A ROS1 publisher to use with performance_test

ROS1 versions of performance_test messages to use when testing with a ROS1 bridge

Tool to test performance of ROS2 and DDS data layers and communication.

Apex.AI performance_test runner, plotter, and reporter

Mobile Robot Programming Toolkit (MRPT) version 2.x

A generic, simple controller manager plugin for MoveIt.

Generates a configuration package that makes it easy to use MoveIt

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

Components of MoveIt that offer interaction via interactive markers

Components of MoveIt that offer simpler 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

Components of MoveIt used for manipulation

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

Metapackage for MoveIt plugins.

MoveIt interface to OMPL

The interface for using CHOMP within MoveIt

Meta package that installs all available planners for MoveIt

Messages, services and actions used by 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

Python interfaces to MoveIt

MoveIt planning request adapter utilizing chomp for solution optimization

Meta package that contains all essential packages of MoveIt 2

Python library for loading parameters in launch files

grep for ROS bag files and live topics

ROS messages for publishing graphs of different data types

foxglove_msgs provides visualization messages that are supported by Foxglove Studio.

chomp_motion_planner

Wrapper around Apache TVM to make it available to the ROS ecosystem.

The microstrain_inertial_rqt package provides several RQT widgets to view the status of Microstrain devices

A package that contains ROS message corresponding to microstrain message types.

Example listener for Parker LORD Sensing inertial device driver ros_mscl (C++).

The ros_mscl package provides a driver for the LORD/Microstrain inertial products.

micro-ROS Agent package

Scripts and launch files for Leo Rover teleoperation

Message and Service definitions for Leo Rover

URDF Description package for Leo Rover

Metapackage of software for Leo Rover common to the robot and ROS desktop

ign_ros2_control_demos

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

gazebo_ros2_control_demos

gazebo_ros2_control

*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.

DepthAI core is a C++ library which comes with firmware and an API to interact with OAK Platform

Vendor package for zmqpp

Implementation of warehouse_ros for sqlite

Persistent storage of ROS messages

RVIZ plugin for IMU visualization

Messages, services and actions used by play_motion.

Plays a pre-recorded motion on a robot

octovis is visualization tool for the OctoMap library based on Qt and libQGLViewer. See http://octomap.github.io for details.

The OctoMap library implements a 3D occupancy grid mapping approach, providing data structures and mapping algorithms in C++. The map implementation is based on an octree. See http://octomap.github.io for details.

PR2 Resources used for MoveIt! testing

panda Resources used for MoveIt testing

Fanuc Resources used for MoveIt testing

Resources used for MoveIt testing

Various tools for IMU devices

Filter which fuses angular velocities, accelerations, and (optionally) magnetic readings from a generic IMU device into an orientation. Based on code by Sebastian Madgwick, http://www.x-io.co.uk/node/8#open_source_ahrs_and_imu_algorithms.

Filter which fuses angular velocities, accelerations, and (optionally) magnetic readings from a generic IMU device into a quaternion to represent the orientation of the device wrt the global frame. Based on the algorithm by Roberto G. Valenti etal. described in the paper "Keeping a Good Attitude: A Quaternion-Based Orientation Filter for IMUs and MARGs" available at http://www.mdpi.com/1424-8220/15/8/19302 .

This package contains generic definitions of geometric shapes and bodies.

The dynamicEDT3D library implements an inrementally updatable Euclidean distance transform (EDT) in 3D. It comes with a wrapper to use the OctoMap 3D representation and hooks into the change detection of the OctoMap library to propagate changes to the EDT.

Message definitions for controlling Allied Vision Technologies (AVT) cameras

Camera driver for Allied Vision Technologies (AVT) cameras, based on their Vimba SDK.

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

Launch tests for the launch_system_modes package, i.e. launch actions, events, and event handlers for system modes.

Interface package, containing message definitions and service definitions for the system modes package.

Example systems and according launch files for the system_modes package.

The system modes concept assumes that a robotics system is built from components with a lifecycle. It adds a notion of (sub-)systems, hiararchically grouping these nodes, as well as a notion of modes that determine the configuration of these nodes and (sub-)systems in terms of their parameter values.

Message and service definitions used in internal tests for rosbridge packages.

Rosbridge provides a JSON API to ROS functionality for non-ROS programs. There are a variety of front ends that interface with rosbridge, including a WebSocket server for web browsers to interact with. Rosbridge_suite is a meta-package containing rosbridge, various front end packages for rosbridge like a WebSocket package, and helper packages.

A WebSocket interface to rosbridge.

Package containing message files

The core rosbridge package, responsible for interpreting JSON andperforming the appropriate ROS action, like subscribe, publish, call service, and interact with params.

Provides service calls for getting ros meta-information, like list of topics, services, params, etc.

Provides service calls for getting ros meta-information, like list of topics, services, params, etc.

The ROS 2 command line tools for ROS2 Control.

The package provides shared test resources for ros2_control stack

Metapackage for ROS2 control related packages

System modes specific extensions to the launch tool, i.e. launch actions, events, and event handlers for system modes.

Interface for enforcing joint limits.

ROS2 ros_control hardware interface

Includes various supporting tools and utilities for c++ programming.

Extends c++ type traits and implements a few more to boot.

Tools and utilities for ecl development.

Provides a portable set of time functions that are especially useful for porting other code or being wrapped by higher level c++ classes.

Timing utilities are very dependent on the system api provided for their use. This package provides a means for handling different timing models. Current support - posix rt : complete. - macosx : posix timers only, missing absolute timers. - win : none.

This package provides the c++ extensions for a variety of threaded programming tools. These are usually different on different platforms, so the architecture for a cross-platform framework is also implemented.

These are lightweight text streaming classes that connect to standardised ecl type devices.

Common statistical structures and algorithms for control systems.

This avoids use of dynamic storage (malloc/new) and thread safety (mutexes) to provide a very simple sigslots implementation that can be used for *very* embedded development.

Provides a signal/slot mechanism (in the same vein as qt sigslots, boost::signals etc for intra-process communication. These include some improvements - they do not need a preprocessor, are fully type safe, allow for simple connections via a posix style string identifier and are multithread-safe.

Metaprogramming tools move alot of runtime calculations to be shifted to compile time. This has only very elementary structures at this stage.

Contains transforms (e.g. differential drive inverse kinematics) for the various types of mobile robot platforms.

This package provides simple support to cmath, filling in holes or redefining in a c++ formulation where desirable.

Deploys various manipulation algorithms, currently just feedforward filters (interpolations).

Libraries and utilities for embedded and low-level linux development.

Ecl frontend to a linear matrix package (currently eigen).

Maintains the ecl licenses and also provides an install target for deploying licenses with the ecl libraries.

Interprocess mechanisms vary greatly across platforms - sysv, posix, win32, there are more than a few. This package provides an infrastructure to allow for developing cross platform c++ wrappers around the lower level c api's that handle these mechanisms. These make it not only easier to utilise such mechanisms, but allow it to be done consistently across platforms.

Most implementations (windows, posix, ...) have slightly different api for low level input-output functions. These are gathered here and re-represented with a cross platform set of functions.

Any tools relating to mathematical geometry. Primarily featuring polynomials and interpolations.

The formatters here simply format various input types to a specified text format. They can be used with most streaming types (including both ecl and stl streams).

Cross platform filesystem utilities (until c++11 makes its way in).

Template based exceptions - these are simple and practical and avoid the proliferation of exception types. Although not syntatactically ideal, it is convenient and eminently practical.

This library provides lean and mean error mechanisms. It includes c style error functions as well as a few useful macros. For higher level mechanisms, refer to ecl_exceptions.

This provides an Eigen implementation for ecl's linear algebra.

Provides an extensible and standardised framework for input-output devices.

This includes a suite of programs demo'ing various aspects of the ecl_core. It also includes various benchmarking and utility programs for use primarily with embedded systems.

A set of tools and interfaces extending the capabilities of c++ to provide a lightweight, consistent interface with a focus for control programming.

These are a very simple version of some of the functions in ecl_converters suitable for firmware development. That is, there is no use of new, templates or exceptions.

Some fast/convenient type converters, mostly for char strings or strings. These are not really fully fleshed out, alot of them could use the addition for the whole range of fundamental types (e.g. all integers, not just int, unsigned int). They will come as the need arises.

The containers included here are intended to extend the stl containers. In all cases, these implementations are designed to implement c++ conveniences and safety where speed is not sacrificed. Also includes techniques for memory debugging of common problems such as buffer overruns.

Color codes for ansii consoles.

These tools inspect and describe your system with macros, types and functions.

Introduces a compile time concept checking mechanism that can be used most commonly to check for required functionality when passing template arguments.

Embeds the TCLAP library inside the ecl. This is a very convenient command line parser in templatised c++.

Collection of cmake/make build tools primarily for ecl development itself, but also contains a few cmake modules useful outside of the ecl.

Messages and services for the controller manager.

Description of controller_manager

Description of controller_interface

clpe sdk

This package provides the Behavior Trees core library.

Bindings between Numpy and Eigen using Boost.Python

Package to keep interface independent of the driver

The depthai_examples package

The depthai_bridge package

The depthai-ros package

rosbag2 storage plugin using the MCAP file format

mcap vendor package

mavros_msgs defines messages for

Extra nodes and plugins for

MAVROS -- MAVLink extendable communication node for ROS with proxy for Ground Control Station.

MAVLink communication library. This library provide unified connection handling classes and URL to connection object mapper. This library can be used in standalone programs.

PlotJuggler: juggle with data

MassRobotics AMR Interop Sender

Visualization configuration for Clearpath Husky