This library provides a standardized interface for processing data as a sequence of filters. This package contains a base class upon which to build specific implementations as well as an interface which dynamically loads filters based on runtime parameters.

Robust and efficient coverage paths for autonomous agricultural vehicles. A modular and extensible Coverage Path Planning library

tools for processing ffmpeg_image_transport_msgs

messages for ffmpeg image transport plugin

ffmpeg_image_transport provides a plugin to image_transport for transparently sending an image stream encoded with ffmpeg.

ROS2 convenience wrapper around ffmpeg for encoding/decoding

ros2_control hardware interface for Feetech Servos

Provide CMake module to find eProsima FastRTPS.

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

A collection of fast point cloud registration implementations

ROS msgs for fadecandy LED controllers

ROS driver for fadecandy LED controllers

This metapackage depends on the SMACH library and ROS SMACH integration packages.

Has examples of using the tf2 Python API.

Example on how to publish a Pointcloud2 message

Examples of minimal subscribers using rclpy.

Examples of minimal service servers using rclpy.

Examples of minimal publishers using rclpy.

Examples of minimal service clients using rclpy.

Examples of minimal action servers using rclpy.

Examples of minimal action clients using rclpy.

Examples of using guard conditions.

Examples of creating and using exectors to run multiple nodes in the same process

Example of how to use the rclcpp::WaitSet directly.

Package containing example of how to implement a multithreaded executor

Examples of minimal nodes which have timers

Examples of minimal subscribers

A minimal service server which adds two numbers

Examples of minimal publisher nodes

Minimalist examples of composing nodes in the same process

Examples of minimal service clients

Minimal action server examples

Minimal action client examples

Example for multiple Executor instances in one process, using the callback-group-level interface of the Executor class.

Example of an async service client

Scenario Execution Example for Simulation

Scenario Execution Example for Scenario Control using RVIZ

Example Multi Robot

Contains message and service definitions used by the examples.

package for rendering event_camera_msgs

Python access for event_camera_msgs.

messages for event based cameras

package to encode and decode event_camera_msgs

ROS messages for ETSI ITS VAM (TS)

Conversion functions for converting ROS messages to and from ASN.1-encoded ETSI ITS VAMs (TS)

C++ compatible C source code for ETSI ITS VAMs (TS) generated from ASN.1 using asn1c

ROS messages for ETSI ITS SPATEM (TS)

Conversion functions for converting ROS messages to and from ASN.1-encoded ETSI ITS SPATEMs (TS)

C++ compatible C source code for ETSI ITS SPATEMs (TS) generated from ASN.1 using asn1c

RViz plugin for ROS 2 messages based on ETSI ITS messages

Conversion functions for converting ROS primitives to and from ASN.1-encoded primitives

ROS messages and utility functions for ETSI ITS messages

ROS messages for ETSI ITS messages

ROS support for ETSI ITS messages

ROS messages for ETSI ITS MAPEM (TS)

Conversion functions for converting ROS messages to and from ASN.1-encoded ETSI ITS MAPEMs (TS)

C++ compatible C source code for ETSI ITS MAPEMs (TS) generated from ASN.1 using asn1c

ROS messages for ETSI ITS DENM

Conversion functions for converting ROS messages to and from ASN.1-encoded ETSI ITS DENMs

C++ compatible C source code for ETSI ITS DENMs generated from ASN.1 using asn1c

ROS messages for ETSI ITS CPM (TS)

Conversion functions for converting ROS messages to and from ASN.1-encoded ETSI ITS CPMs (TS)

C++ compatible C source code for ETSI ITS CPMs (TS) generated from ASN.1 using asn1c

Converts ROS messages to and from ASN.1-encoded ETSI ITS messages

C++ compatible C source code for ETSI ITS messages generated from ASN.1 using asn1c

ROS messages for ETSI ITS CAM (TS)

Conversion functions for converting ROS messages to and from ASN.1-encoded ETSI ITS CAMs (TS)

C++ compatible C source code for ETSI ITS CAMs (TS) generated from ASN.1 using asn1c

ROS messages for ETSI ITS CAM

Conversion functions for converting ROS messages to and from ASN.1-encoded ETSI ITS CAMs

C++ compatible C source code for ETSI ITS CAMs generated from ASN.1 using asn1c

ROS2 package for Epson IMU using C++ wrapper around Linux C driver

Eiquadprog a QP solver using active sets

Bindings between Numpy and Eigen using Boost.Python

This package provides a set of typedef's that allow using Eigen datatypes in STL containers

Exports a custom CMake module to find Eigen3.

The eg_random_generator package

The eg_random_generator package

Generic controller for forwarding commands.

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.

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

This package is composed of 'dynamixel_item', 'dynamixel_tool', 'dynamixel_driver' and 'dynamixel_workbench' class. The 'dynamixel_item' is saved as control table item and information of DYNAMIXEL. The 'dynamixel_tool' class loads its by model number of DYNAMIXEL. The 'dynamixel_driver' class includes wraped function used in DYNAMIXEL SDK. The 'dynamixel_workbench' class make simple to use DYNAMIXEL.

This package includes ROS messages and services for dynamixel_workbench packages

Dynamixel-Workbench is dynamixel solution for ROS. This metapackage allows you to easily change the ID, baudrate and operating mode of the Dynamixel. Furthermore, it supports various controllers based on operating mode and Dynamixel SDK. These controllers are commanded by operators.

ROS2 examples using ROBOTIS DYNAMIXEL SDK

ROS2 custom interface examples using ROBOTIS DYNAMIXEL SDK

This package is wrapping version of ROBOTIS Dynamixel SDK for ROS 2. The ROBOTIS Dynamixel SDK, or SDK, is a software development library that provides Dynamixel control functions for packet communication. The API is designed for Dynamixel actuators and Dynamixel-based platforms.

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.

Standard implementations of the GoalChecker and TrajectoryGenerators for dwb_core

Message/Service definitions specifically for the dwb_core

The dwb_critics package

TODO

dummy sensor nodes

dummy robot bringup

dummy map server node

merge dual lidar's scans.

Drive-by-wire messages

Demonstration of drive-by-wire with joystick

Interface to the Dataspeed Inc. Drive-By-Wire kit

Interface to the Dataspeed Inc. Drive-By-Wire kits

draco_point_cloud_transport provides a plugin to point_cloud_transport for sending point clouds encoded with KD tree compression.

A tool to coordinate unique ROS_DOMAIN_IDs across multiple processes

ROS 2 Domain Bridge

Tests for the Dolly robot.

Launch Ignition simulation with Dolly robot.

Launch Gazebo simulation with Dolly robot.

Follow node for Dolly, the robot sheep.

Meta-package for Dolly, the robot sheep.

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.

A package containing some diagnostics related message and service definitions.

diagnostic_common_diagnostics

diagnostic_aggregator

Provides a "batteries included" experience to novice users.

A package which extends 'ros_base' and includes high level packages like vizualization tools and demos.

depthimage_to_laserscan

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

Contains components for processing depth images such as those produced by OpenNI camera. Functions include creating disparity images and point clouds, as well as registering (reprojecting) a depth image into another camera frame.

Python nodes which were previously in the ros2/examples repository but are now just used for demo purposes.

C++ nodes which access the native handles of the rmw implementation.

C++ nodes which were previously in the ros2/examples repository but are now just used for demo purposes.

Driver to interface with the Dataspeed Inc. USB CAN Tool

CAN bus introspection

Controller Area Network (CAN) messages

Time synchronize multiple CAN messages to get a single callback

CAN bus tools using Dataspeed hardware

Interfaces for data_tamer

DataTamer data logging library

Eclipse Cyclone DDS is a very performant and robust open-source DDS implementation. Cyclone DDS is developed completely in the open as an Eclipse IoT project.

This contains CvBridge, which converts between ROS2 Image messages and OpenCV images.

Exports a CMake module to find cuDNN.

ROS driver for iRobot's Create 1 and 2, based on the libcreate C++ library

Common message definitions for create_robot

ROS driver for iRobot's Create and Roomba platforms, based on libcreate

Robot URDF descriptions for create_robot

Launch and configuration files for common accessories when working with Create/Roomba platforms.

Example launch files for teleoperating the iRobot(R) Create(R) 3 Educational Robot.

C++ action server exposing a non-systematic coverage behavior

Example for using an RPLIDAR A1 with a Create 3

Python examples for interacting with the iRobot(R) Create(R) 3 Educational Robot

Package containing action, message and service definitions used by the iRobot(R) Create(R) 3 examples

C++ action server exposing a non-systematic coverage behavior

CRANE+ V2 move_group config package

CRANE+ V2 gazebo simulation package

CRANE+ V2 examples package

CRANE+ V2 description package

CRANE+ V2 control package

ROS 2 package suite of CRANE+ V2

The costmap_queue package

Messages and services for the controller manager.

Description of controller_manager

Description of controller_interface

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

control_msgs contains base messages and actions useful for controlling robots. It provides representations for controller setpoints and joint and cartesian trajectories.

The control_box_rst package provides C++ libraries for predictive control, direct optimal control, optimization and simulation.

Wrapper around console_bridge, providing nothing but a dependency on console_bridge, on some systems. On others, it provides an ExternalProject build of console_bridge.

Compressed_image_transport provides a plugin to image_transport for transparently sending images encoded as JPEG or PNG.

Compressed_depth_image_transport provides a plugin to image_transport for transparently sending depth images (raw, floating-point) using PNG compression.

A package containing message and service definitions for managing composable nodes in a container process.

Examples for composing multiple nodes in a single process.

common_interfaces contains messages and services that are widely used by other ROS packages.

An almost dependency-less library for converting between color spaces

Messages for describing collisions (simulated or not)