rosconsole_bridge is a package used in conjunction with console_bridge and rosconsole for connecting console_bridge-based logging to rosconsole-based logging.

This empty package allows to export rosbag migration rule files without depending on rosbag.

This encapsulates the GL dependency for a specific ROS distribution and its Qt version

slam_gmapping contains a wrapper around gmapping which provides SLAM capabilities.

This package contains a ROS wrapper for OpenSlam's Gmapping. The gmapping package provides laser-based SLAM (Simultaneous Localization and Mapping), as a ROS node called slam_gmapping. Using slam_gmapping, you can create a 2-D occupancy grid map (like a building floorplan) from laser and pose data collected by a mobile robot.

The package provides the environment variables `ROS_VERSION`, `ROS_DISTRO`, `ROS_PACKAGE_PATH`, and `ROS_ETC_DIR`.

DNN based detection

Messages definitions for representing computer's hardware state, such as battery information, GPU, some miscellaneous sensors. Format is in ROS. Originally developed at

A collection of tools for making a variety of generic ROS-related tasks easier.

Plays rosbags as though they were happening NOW.

Simple Kalman Filter in Python

Translates joy msgs

Python library to assist in publishing markers easily

Utilities for flashing and enabling Kobuki's USB connection. This package contains tools for flashing the Kobuki's FTDI chip (usually done at the factory). The special firmware for the FTDI chip (USB to serial converter) enables it to appear as /dev/kobuki on the user's PC.

C++ driver library for Kobuki: Pure C++ driver library for Kobuki. This is for those who do not wish to use ROS on their systems.

Dock driving library for Kobuki. Users owning a docking station for Kobuki can use this tool to develop autonomous docking drive algorithms.

Non-ROS software for Kobuki, Yujin Robot's mobile research base.

This package pulls in the Karto mapping library, and provides a ROS wrapper for using it.

The ros_type_introspection package allows the user to parse and deserialize ROS messages which type is unknown at compilation time.

Contains tests for [[bond]], including tests for [[bondpy]] and [[bondcpp]].

The State Machine Compiler (SMC) from http://smc.sourceforge.net/ converts a language-independent description of a state machine into the source code to support that state machine. This package contains the libraries that a compiled state machine depends on, but it does not contain the compiler itself.

Python implementation of bond, a mechanism for checking when another process has terminated.

C++ implementation of bond, a mechanism for checking when another process has terminated.

A bond allows two processes, A and B, to know when the other has terminated, either cleanly or by crashing. The bond remains connected until it is either broken explicitly or until a heartbeat times out.

A bond allows two processes, A and B, to know when the other has terminated, either cleanly or by crashing. The bond remains connected until it is either broken explicitly or until a heartbeat times out.

Create a Pandas data frame from a ros bag file.

sensehat_ros is a ROS package to interact with Astro Pi Sense HAT sensors, stick and LED matrix.

Republishing of Selected TFs

Filters the robot's body out of point clouds.

This package defines services that are used to communicate with the realtime control loop. It also defines messages that represent the state of the realtime controllers, the joints and the actuators.

Ethernet interface to OxTS GPS receivers (NCOM packet structure)

ROS wrapper for the Simple Open EtherCAT Master SOEM. This is an updated version of the original SOEM wrapper released into ROS now including the upstream Repo as a git subtree.

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

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

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.

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.

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

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

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.

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

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.

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

turtle_actionlib demonstrates how to write an action server and client with the turtlesim. The shape_server provides and action interface for drawing regular polygons with the turtlesim.

The pluginlib_tutorials package

Package for Nodelet tutorial.

Metapackage that contains common tutorials

The actionlib_tutorials package

This package provides message types that are used by the package mpc_local_planner

The mpc_local_planner_examples package

The mpc_local_planner package implements a plugin to the base_local_planner of the 2D navigation stack. It provides a generic and versatile model predictive control implementation with minimum-time and quadratic-form receding-horizon configurations.

This package contains a tool to convert Unified Robot Description Format (URDF) documents into COLLAborative Design Activity (COLLADA) documents. Implements robot-specific COLLADA extensions as defined by http://openrave.programmingvision.com/index.php/Started:COLLADA

This package contains a C++ parser for the Collada robot description format. The parser reads a Collada XML robot description, and creates a C++ URDF model. Although it is possible to directly use this parser when working with Collada robot descriptions, the preferred user API is found in the urdf package.

The usb_cam_hardware_interface package

The usb_cam_hardware package

The usb_cam_controllers package

ROS msgs from and to dual quaternions

This package provides message types commonly used with Autonomous Underwater Vehicles

Launch a PID control node.

This package provides messages and serializations / conversion for the

The jderobot_assets package

URDF file descriptions for P2OS/ARCOS robot

A teleoperation node for the p2os_driver package.

Defines the messages that are used to communicate with the p2os_driver package and the ROS infrastructure.

Launch and config files designed for use with the p2os stack.

Driver file descriptions for P2OS/ARCOS robot

Contains the Documentation for the p2os driver/componenets

Wrapper around qpOASES to make it available to the ROS ecosystem.

dual quaternion operations

The urg_c package

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

rqt_robot_monitor displays diagnostics_agg topics messages that are published by

An rqt-based tool that assists monitoring tasks for

Library and Utilities for working with ifm pmd-based 3D ToF Cameras

The codec_image_transport package

A metapackage to aggregate several packages.

A metapackage to aggregate several packages.

A metapackage to aggregate the packages required to use publish / subscribe, services, launch files, and other core ROS concepts.

A metapackage which extends ros_core and includes other basic non-robot tools like actionlib, dynamic reconfigure, nodelets, and pluginlib.

A metapackage which extends ros_base and includes ROS libaries for any robot hardware. It may not contain any GUI dependencies.

A metapackage to aggregate several packages.

A metapackage to aggregate several packages.

A metapackage to aggregate several packages.

This package contains a number of URDF tutorials.

Filters a laser scan to remove points that are in the current static map

ROS Libraries for filtering specific kinds of laser scans

ROS messages for robots using FourWheelSteering.

A ros package that includes plugins and nodes to convert occupied costmap2d cells to primitive types.

ROS messages for robots using Ackermann steering.

Special Messages for PlotJuggler

Mobile robot simulator http://rtv.github.com/Stage

Package which implements capabilities, including code to parse capability interface specs, to parse capability provider specs, and implement the capability server.

Mesh Conversion Utility Used to generate '.iv' files from '.stl' files. This package has not been changed since 2001 and appears to be very stable. We plan on keeping this package in this revision for mesh conversions. This package is only available as a single source file for download. There are no local modifications to this package.

laser_proc

Convex Decomposition Tool for Robot Model

Object_recognition_msgs contains the ROS message and the actionlib definition used in object_recognition_core

Meta-package of libraries for processing laser data, including converting laser data into 3D representations.

Contains a set of tools that can be used from a hard realtime thread, without breaking the realtime behavior.

turtle_tf2 demonstrates how to write a tf2 broadcaster and listener with the turtlesim. The tutle_tf2_listener commands turtle2 to follow turtle1 around as you drive turtle1 using the keyboard.

turtle_tf demonstrates how to write a tf broadcaster and listener with the turtlesim. The tutle_tf_listener commands turtle2 to follow turtle1 around as you drive turtle1 using the keyboard.

Metapackage of geometry tutorials ROS.

ROS wrapper for the sparse bundle adjustment (sba) library (needed for slam_karto)

quaternion operations

The carla_msgs package

This encapsulates the WebKit dependency for a specific ROS distribution and its Qt version

Package modeling the build-time dependencies for generating language bindings of messages.

Package modeling the run-time dependencies for language bindings of messages.

EusLisp ROS message and service generators.

Javascript ROS message and service generators.

Common-Lisp ROS message and service generators.

The marker_msgs package contains messages usable to setup a marker/fiducial system. The package distinguishes between two types of messages. First messages to describe the properties of a marker/fiducial detection system and the detected markers. Secondly messages used to represent a map of markers/features with covariances as it would be produced by a SLAM system or published by a map server for self-localization.

C++ implementation of Lie Groups using Eigen.

The um6 package provides a C++ implementation of the CH Robotics serial protocol, and a corresponding ROS node for publishing standard ROS orientation topics from a UM6.

Tools and utilities for ecl development.

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

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

This is SDHLibrary-CPP, the C++ library to access an SDH (SCHUNK Dexterous Hand)

The nmea_comms package provides helper nodes for transmitting and receiving the NMEA sentences.

A driver for IMUs compatible the microstrain 3DM-GX2 and 3DM-GX3 protocol. Includes a heavily modified standalone driver pulled from the player distribution, and a ROS node.

HTTP Streaming of ROS Image Topics in Multiple Formats

A common repository for CMake Modules which are not distributed with CMake but are commonly used by ROS packages.

More efficient version of tf/tf_remap able to handle TFs at kHz with tens of subscribers.

val_description version including our updated meshes for unit testing and visualisation. Based on the OpenHumanoids fork of the val_description package by NASA JSC. The most current version of the original package can be found at http://gitlab.com/nasa-jsc-robotics/val_description

Launch files to open an OpenNI device and load all nodelets to convert raw depth/RGB/IR streams to depth images, disparity images, and (registered) point clouds.

Model files of OpenNI device.

A ROS driver for OpenNI depth (+ RGB) cameras. These include: Microsoft Kinect, PrimeSense PSDK, ASUS Xtion Pro and Pro Live The driver publishes raw depth, RGB, and IR image streams.

Search-based planning library (SBPL).

The twist_mux msgs and actions package

Holds maps of Willow Garage that can be used for a number of different applications.

The `pr2_mechanism_diagnostics` node subscribes to `mechanism_statistics` and publishes diagnostics data for joints and controllers on `/diagnostics`.

The pr2_mechanism stack contains the infrastructure to control the PR2 robot in a hard realtime control loop.

This package contains the C++ interfaces to the PR2 hardware components that are controlled over EtherCAT. This includes the motors and encoders needed to control the PR2 mechanism, as well as components like the pressure sensors in the fingertips, camera triggers, etc... All of the hardware components in this interface are directly available to the controllers inside the hard realtime control loop.

The controller manager (CM) package provides the infrastructure to run controllers in a hard realtime loop.

This package specifies the interface to a realtime controller. A controller that implements this interface can be executed by the

This package provides ROS specific hooks for stage

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

Neato XV-11 Laser Driver. This driver works with the laser when it is removed from the XV-11 Robot as opposed to reading scans from the Neato's USB port.

This stack aims to bring the common tools and algorithms needed to develop navigation algorithms, in particular slam. It does not focus on the end-point solution, rather the tools needed to create a variety of end-point solutions.

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

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

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.

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

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.

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.

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.

Color codes for ansii consoles.

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

Visualization launchers and helpers for Ridgeback.

Packages for working with Ridgeback from a ROS desktop.

Stream cartesian commands

Graft is not yet finished. It's intended to be a full replacement to robot_pose_ekf, including native absolute references, and arbitrary topic configuration. If you try to use Graft now, please note that not all parameters are configured and you will not always see a change in behavior by modifying the parameters.

AVT GigE SDK version 1.26 for ROS

Placeholder package enabling generic export of media paths.