rclc lifecycle convenience methods.

Example of using rclc_executor

The ROS client library in C.

gtsam

LGSVL Simulator Bridge

Msg and srv definitions for rc_reason_clients

Clients for interfacing with Roboception reason modules on rc_visard and rc_cube.

The quaternion_operation package

CMake Functions and Modules for automating CMake

ROS 2 packages for TurtleBot3 simulations

Gazebo simulation package for the TurtleBot3

Package for TurtleBot3 fake node. With this package, simple tests can be done without a robot. You can do simple tests using this package on rviz without real robots.

Package containing storage and converter plugins for rosbag 1

Vendor package for rosbag_storage of ROS1

Messages for interfacing with various computer vision pipelines, such as object detectors.

Provides small examples for use of the fmi_adapter package

Wraps FMUs for co-simulation

AprilTag detector library

Teleoperation node using keyboard for TurtleBot3.

TurtleBot3 driver node that include diff drive controller, odometry and tf node

ROS 2 launch scripts for navigation2

This package provides four basic examples for TurtleBot3 (i.e., interactive marker, object detection, patrol and position control).

3D models of the TurtleBot3 for simulation and visualization

ROS 2 launch scripts for cartographer

ROS 2 launch scripts for starting the TurtleBot3

ROS 2 packages for TurtleBot3

Interface for using ROS with the

Utilities to interface with

Robot-independent Gazebo plugins for sensors, motors and dynamic reconfigurable components.

Message and service data structures for interacting with Gazebo from ROS2.

Provides a cmake config for the default version of Gazebo for the ROS distribution.

Contains message and service definitions used by tts.

Package enabling a robot to speak with a human voice by providing a Text-To-Speech ROS service

Messages for publishing monitoring data about ROS systems

Package providing a ROS node for interacting with Amazon Lex

Common messages for interacting with Amazon Lex using the lex_node package

Lex Common utilities, intended for use by Lex clients

Kinesis Video Streams producer node

Messages for transmitting video frames to Kinesis Video Streams.

AWS Kinesis stream management library intended for use with the Kinesis Video Producer SDK

Package providing a ROS node for sending health metrics to Cloudwatch Metrics

ROS2 H264 encoder node

Common base code for ROS1/ROS2 H264 encoder node

AWS CloudWatch management library used to manage offline files.

Light version of dataflow libraries

Library used by ROS1/2 node to publish metrics

Subscriber node for the aws/monitoring topic to publish metrics to AWS Cloudwatch

AWS CloudWatch management library used by ROS1/2 node to publish logs to CloudWatch service

CloudWatch Logger node for publishing logs to AWS CloudWatch Logs

Common utilities for ROS2 nodes using Amazon Web Services.

Common AWS SDK utilities, intended for use by ROS packages using the AWS SDK

Interfaces between core Autoware.Auto components

ROS2 Navigation Stack

A handful of useful utility functions for nav_2d packages.

Basic message types for two dimensional navigation, extending from geometry_msgs::Pose2D.

TODO

voxel_grid provides an implementation of an efficient 3D voxel grid. The occupancy grid can support 3 different representations for the state of a cell: marked, free, or unknown. Due to the underlying implementation relying on bitwise and and or integer operations, the voxel grid only supports 16 different levels per voxel column. However, this limitation yields raytracing and cell marking performance in the grid comparable to standard 2D structures making it quite fast compared to most 3D structures.

TODO

This package enables Reinfocement Learning with Gazebo and Turtlebot3

TODO

Navigation 2 plugins for rviz

TODO

TODO

Messages and service files for the navigation2 stack

Refactored map server for ROS2 Navigation

A controller/manager for the lifecycle nodes of the Navigation 2 system

This package provides a validation class for ROS2 parameters with validation based on parameter type and defined bounds. Support for custom validation callbacks is also provided. Some useful convenience functions for event callbacks are also provided

ROS2 controller (DWB) metapackage

This package provides an implementation of a 2D costmap that takes in sensor data from the world, builds a 2D or 3D occupancy grid of the data (depending on whether a voxel based implementation is used), and inflates costs in a 2D costmap based on the occupancy grid and a user specified inflation radius. This package also provides support for map_server based initialization of a costmap, rolling window based costmaps, and parameter based subscription to and configuration of sensor topics.

Common support functionality used throughout the navigation 2 stack

TODO

Bringup scripts and configurations for the navigation2 stack

TODO

Standard implementations of the GoalChecker and TrajectoryGenerators for dwb_core

Message/Service definitions specifically for the dwb_core

The dwb_critics package

TODO

TODO

The costmap_queue package

rqt_runtime_monitor provides a GUI plugin viewing DiagnosticsArray messages.

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.

CAN related message types.

Simple example system 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.

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

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.

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.

A template class and associated utilities which encapsulate basic reading from UDP sockets

A template class and associated utilities which encapsulate basic reading from serial ports

rqt_py_common provides common functionality for rqt plugins written in Python. Despite no plugin is provided, this package is part of the rqt_common_plugins repository to keep refactoring generic functionality from these common plugins into this package as easy as possible. Functionality included in this package should cover generic ROS concepts and should not introduce any special dependencies beside "ros_base".

rqt_gui_py enables GUI plugins to use the Python client library for ROS.

rqt_gui_cpp enables GUI plugins to use the C++ client library for ROS.

rqt_gui provides the main to start an instance of the ROS integrated graphical user interface provided by qt_gui.

rqt is a Qt-based framework for GUI development for ROS. It consists of three parts/metapackages

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

A simple bridge between ROS 1 and ROS 2

Server Side tools for Authorization and Authentication of ROS Clients

Point cloud utilities for Ignition simulation with ROS.

Image utilities for Ignition simulation with ROS.

Demos using Ignition Gazebo simulation with ROS.

Tools for using Ignition Gazebo simulation with ROS.

Bridge communication between ROS and Ignition Transport

Meta-package containing interfaces for using ROS 2 with

Tile map provides a slippy map style interface for visualizing OpenStreetMap and GoogleMap tiles. A mapviz visualization plug-in is also implemented

multires_image

Common plugins for the Mapviz visualization tool

ROS interfaces used by Mapviz

mapviz

Package for sanitizing lanelet maps

Package for interpreting traffic rules in a lanelet map

Routing module for lanelet2

Python bindings for lanelet2

Lanelet2 projection library for lat/lon to local x/y conversion

Example maps in the lanelet2-format

Parser/Writer module for lanelet2

Examples for working with Lanelet2

Lanelet2 core module

Meta-package for lanelet2

Messages used by wiimote package.

The wiimote package allows ROS nodes to communicate with a Nintendo Wiimote and its related peripherals, including the Nunchuk, Motion Plus, and (experimentally) the Classic. The package implements a ROS node that uses Bluetooth to communicate with the Wiimote device, obtaining accelerometer and gyro data, the state of LEDs, the IR camera, rumble (vibrator), buttons, joystick, and battery state. The node additionally enables ROS nodes to control the Wiimote's LEDs and vibration for feedback to the human Wiimote operator. LEDs and vibration may be switched on and off, or made to operate according to a timed pattern.

Vendor library for SDL2.

ROS2 driver for a generic Linux joystick. Will contain a MacOS and Windows version later. The joy package contains joy_node, a node that interfaces a generic Linux joystick to ROS2. This node publishes a "Joy" message, which contains the current state of each one of the joystick's buttons and axes.

ROS2 package to interface with a GRBL serial device

Wrapper (aka vendor package) around the FMILibrary by Modelon AB (JModelica.org)

The rc_dynamics_api provides an API for easy handling of the dynamic-state data streams provided by Roboception's stereo camera with self-localization. See http://rc-visard.com Dynamic-state estimates of the rc_visard relate to its self-localization and ego-motion estimation. These states refer to rc_visard's current pose, velocity, or acceleration and are published on demand via several data streams. For a complete list and descriptions of these dynamics states and the respective data streams please refer to rc_visard's user manual.

Tests for ROS specific extensions to the launch tool.

The launch command for ROS 2 command line tools.

A package providing utilities for writing ROS2 enabled launch tests.

ROS specific extensions to the launch tool.

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 creating and using exectors to run multiple nodes in the same process

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

Test package, which uses things exported by osrf_testing_tools_cpp.

The swri_transform_util package contains utility functions and classes for transforming between coordinate frames.

swri_system_util

swri_serial_util

This library provides functionality to simplify working with the navigation messages defined in marti_nav_msgs.

swri_roscpp

Contains scripts that are useful as prefix commands for nodes started by roslaunch.

swri_opencv_util

swri_math_util

swri_image_util

swri_geometry_util

This package provides documentation on common interface conventions for drive-by-wire systems.

swri_console_util

rqt_publisher provides a GUI plugin for publishing arbitrary messages with fixed or computed field values.

Generate the message type support for dynamic message construction in C++.

Generate the message type support for dynamic message construction in C.

The interface for rosidl typesupport packages.

Generate the C++ interfaces for eProsima FastRTPS.

Generate the C interfaces for eProsima FastRTPS.

Runtime utilities for working with generated ROS interfaces in Python.

The parser for ROS interface files.

Generate the ROS interfaces in Python.

Generate the ROS interfaces in C++.

Generate the ROS interfaces in C.

The CMake functionality to invoke code generation for ROS interface files.

API and scripts to parse .msg/.srv/.action files and convert them to .idl.

Code shared on static and dynamic type support of rmw_fastrtps_cpp.

Implement the ROS middleware interface using eProsima FastRTPS static code generation in C++.

Implement the ROS middleware interface using eProsima FastRTPS static code generation in C++.

C++ types and functions shared by the ROS middleware interface to RTI Connext Static and RTI Connext Dynamic.

Implement the ROS middleware interface using RTI Connext static code generation in C++.

Package containing various utility types and functions for C

Provide CMake module with extra functionality for Python.

CMake shim over the poco library.

Testing tools for C++, and is used in various OSRF projects.

Provide CMake module to find eProsima FastRTPS.

The ability to add tests in the ament buildsystem in CMake.

The ability to add definitions, include directories and libraries of a package to a target in the ament buildsystem in CMake.

The ability to use Python in the ament buildsystem in CMake.

The ability to run Python tests using pytest in the ament buildsystem in CMake.

The ability to add nose-based tests in the ament buildsystem in CMake.

The functionality to deduplicate libraries in the ament buildsystem in CMake.

The functionality to order include directories according to a chain of prefixes in the ament buildsystem in CMake.

The ability to add gtest-based tests in the ament buildsystem in CMake.