This package holds config and launch files for running the

This package holds common configuration files for running the

The cob_navigation stack provides different navigation packages for

Messages for representing state information, such as battery information and emergency stop status.

cob_moveit_interface

MoveIt config files for all cob and raw

MoveIt launch files

cob_monitoring

The cob_model_identifier package provides nodes to analyse the system response behavior of actuators to optimally tune PID controllers to be used with cob_twist_controller framework.

This package implements the Care-O-bot mimic

The cob_mecanum_controller_node provides a lightweight base controller for mecanum drive robots. The out/input for the wheel command/state are wheel velocities in rad/s for the wheels [front left, front right, rear left, rear right]

cob_mapping_slam holds launch files for running SLAM using the

cob_map_accessibility_analysis receives the map from navigation as well as obstacles and inflates_obstacles topics to assemble a common obstacle map. Upon request, this node checks the accessibility of poses within thin map by (i) checking whether the pose itself is free and by (ii) checking whether there is a closed path from robot to the goal pose.

Messages for cob_manipulation

The cob_manipulation stack includes packages that provide manipulation capabilities for Care-O-bot.

cob_lookat_action

cob_linear_nav provides a simple navigation instrument driving on a linear path from current position to goal without any planning or obstacle avoidance capabilites. Obstacle avoidance should be carried out in other package, e.g.

This package contains scripts to operate the LED lights on Care-O-bot.

Flips the image of Care-O-bots kinect in dependence of the viewing direction of the cameras to receive an upright image all the time.

Helper scripts for Care-O-bot

The cob_hardware_emulation package provides idealized nodes emulating real robot hardware and/or physics simulation.

This package contains configuration for each robot instance (e.g. cob4-X, raw3-X). There is a directory for each robot with configuration about urdf and hardware/device configurations.

The cob_hand_bridge package provides a driver for the gripper of Care-O-bot4.

The cob_hand stack includes packages that provide access to the Care-O-bot hand through ROS serial.

Grasp generation for Care-O-bot based on OpenRAVE

The package cob_generic_can provides an interface for nodes on a can-bus and examplary wrappers for two PeakSys-can-libs. When a can-bus-device is generated (for an example see base_dirve_chain) you can use generic_can to create as many itfs as there will be components communicating via this can-bus. Assign type of the can communication device (e.g. usb-to-can or can-card of a specific vendor) and can-address of the target device. This package comes with wrappers for PeakSys and PeakSysUSB adapters.

This package provides some worlds for gazebo simulation.

The cob_gazebo_tools package provides helper tools for the gazebo simulation

This package contains a specialization of the gazebo_ros_control plugin. The cob_gazebo_ros_control plugin allows Multi-HardwareInterface-Support.

Additional gazebo plugins used with Care-O-bot

This package provides some objects and furniture for gazebo simulation.

Launch files and tools for 3D simulation of Care-O-bot in gazebo simulator.

The cob_frame_tracker package contains nodes that publish Twist commands based on the distance to the desired tf frame target.

The cob_footprint_observer package adjusts the footprint of the robot based on the setup (e.g. arm and/or tray).

Fiducial recognition. Implementation of different 2D tags like PI-tag from Bergamasco et al. for recognition with a single 2D camera.

The cob_extern stack contains third party libraries needed for operating Care-O-bot. The packages are downloaded from the manufactorers website and not changed in any way.

This stack holds packages for IPA default environment configuration.

This packagae implements the special homing procedure that is needed for old cob4/raw bases

The cob_driver stack includes packages that provide access to the Care-O-bot hardware through ROS messages, services and actions. E.g. for mobile base, arm, camera sensors, laser scanners, etc...

Autonomous docking

This package contains the description (mechanical, kinematic, visual, etc.) of the Care-O-bot robot. The files in this package are parsed and used by a variety of other components. Most users will not interact directly with this package.

Default configuration of the different robots supported by the Care-O-bot stacks. Configuration is e.g. preconfigured joint positions.

The cob_default_robot_behavior package provides helper scripts for standard robot behaviors.

This package contains configuration files for the default environments for Care-O-bot supported by IPA.

cob_dashboard is a modified version of [[pr2_dashboard]].

Common messages and services used in various packages within cob_control.

The cob_control_mode_adapter package provides a node that automatically loads respective ros_controllers depending on required control mode.

cob_control meta-package

The cob_common stack hosts common packages that are used within the Care-O-bot repository. E.g. utility packages or common message and service definitions etc. Also the urdf desciption of the robot is located in this stack.

The cob_command_tools stack provides tools, for operating Care-O-bot.

This package provides a simple GUI for operating Care-O-bot.

The cob_collision_velocity_filter package is a package for collision avoidance using teleoperation.

The collision monitor uses the planning scene monitor to read the state of the robot and check it for collision with itselt or the environment. It addition a ground plane is added in any case. Can be used as a stand-aloan node or a move_group capability.

This package provides nodes that broadcast tf-frames along various (model-based) Cartesian paths (e.g. Linear, Circular). The tf-frames are interpolated using a given velocity profile (e.g. Ramp, Sinoid) and can be used as targets for the cob_frame_tracker/cob_twist_controller.

The package cob_canopen_motor implements a controller-drive component which is connected to a can-bus and works with a canopen-interface. "CanDriveItf" provides a - more or less - generic interface to the controller-drive components. "CanDrvie..." then implements a specific setup, e.g. an ELMO Harmonica Controller in case of the "CanDriveHarmonica".

cob_cam3d_throttle: only for Trottel

This repository holds the current calibration data for Care-O-bot.

This package provides launch files for starting a simulated Care-O-bot.

This package provides launch files for operating Care-O-bot.

Driver package for interfacing the battery management system (BMS) on Care-O-bot.

The 'cob_base_velocity_smoother' reads velocity messages and publishes messages of the same type for "smoothed" velocity to avoid shaking behavior.

This package contains classes that are able to control the platform of the Care-O-Bot. This means to establish a CAN communication to drive and steering motors of the platform and later send motion commands and receive motor information.

The cob_base_controller_utils package contains common utils for various base_controllers.

cob_android_settings

cob_android_script_server

cob_android_resource_server

cob_android_msgs

cob_android package provides tools for android apps operation.

This Package contains Care-O-bot specific action definitions.

Message, service and action definitions for environment perception.

An extension of the Flexible Collision Library.

library to read/write .npy and .npz files in C/C++

Node for fast color blob detection

The cmd_vel_smoother package

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

ROS driver for CANLAB CLPE-G-NVP2650D

The messages for Clober

ROS package containing the message definitions for the Clearpath Robotics OutdoorNav safety module.

Messages for Clearpath Platforms.

Examples to show how to use CPR OutdoorNav API

Examples library to show how to use CPR OutdoorNav API

Examples to show how to use CPR OutdoorNav API

ROS package containing the message definitions for the Clearpath Robotics OutdoorNav navigation module.

Metapackage for Clearapth messages.

The clearpath_mission_scheduler_msgs package

The clearpath_mission_manager_msgs package

ROS package containing the message definitions for the Clearpath Robotics OutdoorNav logging module.

ROS package containing the message definitions for the Clearpath Robotics OutdoorNav localization module.

ROS package containing the message definitions for the Clearpath Robotics OutdoorNav dock module.

ROS package containing the message definitions for the Clearpath Robotics OutdoorNav control selection module.

ROS package containing the message definitions for the Clearpath Robotics OutdoorNav configuration module.

ROS package containing the message definitions for camera related calls.

This package provides a recovery behavior for the navigation stack that attempts to clear space by reverting the costmaps used by the navigation stack to the static map outside of a given area.

The class_loader package is a ROS-independent package for loading plugins during runtime and the foundation of the higher level ROS "pluginlib" library. class_loader utilizes the host operating system's runtime loader to open runtime libraries (e.g. .so/.dll files), introspect the library for exported plugin classes, and allows users to instantiate objects of said exported classes without the explicit declaration (i.e. header file) for those classes.

Common Lisp utility libraries

cl_urdf

Implementation of TF datatypes

Homogeneous transform library for Common Lisp.

Client implementation to use TF2 from Common Lisp

Client implementation to use TF from Common Lisp

chomp_motion_planner

Uses opencv to find checkboards and compute their 6D poses with respect to the image. Requires the image to be calibrated.

The ROS package for chaplus service

Bundle python requirements in a catkin package via virtualenv.

Low-level build system macros and infrastructure for ROS.

ROS integration for the Catch unit test framework

Cartesian trajectory interpolation as a standalone library

A Cartesian trajectory controller with multiple hardware interface support

Stream cartesian commands

Defines a hardware interface to send Cartesian commands to a robot hardware and read Cartesian states.

Cartesian trajectory execution interface.

This planner attempts to find a legal place to put a carrot for the robot to follow. It does this by moving back along the vector between the robot and the goal point.

The carla_msgs package

The care-o-bot-simulation meta-package

The care-o-bot-robot meta-package

The care-o-bot-desktop meta-package

The care-o-bot meta-package

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

canopen_chain_node specialization for handling of canopen_402 motor devices. It facilitates interface abstraction with ros_control.

CiA(r) CANopen 301 master implementation with support for interprocess master synchronisation.

Base implementation for CANopen chains node with support for management services and diagnostics

This implements the CANopen device profile for drives and motion control. CiA(r) 402

CAN related message types.

DBC file interface. Read a DBC file, unpack CAN messages and convert to engineering units, pack values into CAN messages for publishing.

Utilities for throttling cameras

Metadata extractor that matches existing camera info to a particular camera and lens.

camera_info_manager API without an active ROS node.

This package provides a C++ interface for camera calibration information. It provides CameraInfo, and handles SetCameraInfo service requests, saving and restoring the camera calibration data.

camera_calibration_parsers contains routines for reading and writing camera calibration parameters.

camera_calibration allows easy calibration of monocular or stereo cameras using a checkerboard calibration target.

camera_aravis: A complete and comfortable GenICam (USB3Vision and GigEVision) based camera driver for ROS (ethernet and usb).

This package contains a script to generate calibration launch and configurationfiles for your robot. which is based on Michael Ferguson's calibration code

This package defines messages for storing calibration samples to be used in full robot calibration procedures. This package is still unstable. Expect the messages to change.

This package contains a collection of launch files that can be helpful in configuring the calibration stack to run on your robot.

Runs an optimization to estimate the a robot's kinematic parameters. This package is a generic rewrite of pr2_calibration_estimation.

Provides a toolchain running through the robot calibration process. This involves capturing calibration data, estimating parameters, and then updating the URDF.

High resolution version of the ROS worker.

Contains a static signal handling helper class.

ROS node wrapper with some convenience functions using *bota_worker*.

ROS node for communicating with rokubimini sensors

Meta package that contains all essential packages of BOTA driver.

ROS interface to Rexroth ROKIT Locator

State machine library with ros logging

Boost plugin loader implementation

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.

Model Attachment Plugin

A beluga extension to facilitate the use of OpenVDB.

Primer on Particle Filtering with Beluga.

Set of miscellaneous tools to work with beluga.

System tests for beluga.

Utilities to interface ROS with Beluga.

Example launch files for Beluga AMCL.

Scripts to benchmark, profile and compare beluga with other AMCL implementations.

An AMCL node implementation for ROS2 using Beluga.

A generic MCL library for ROS2.

This package provides the Behavior Trees core library.

The bcr_bot package

The bayesian_belief_networks package form https://github.com/eBay/bayesian-belief-networks, Authored by Neville Newey, Anzar Afaq, Copyright 2013 eBay Software Foundation

The battery_monitor_client package

This package provides implementations of the Trajectory Rollout and Dynamic Window approaches to local robot navigation on a plane. Given a plan to follow and a costmap, the controller produces velocity commands to send to a mobile base. This package supports both holonomic and non-holonomic robots, any robot footprint that can be represented as a convex polygon or circle, and exposes its configuration as ROS parameters that can be set in a launch file. This package's ROS wrapper adheres to the BaseLocalPlanner interface specified in the

The baldor package

An application used to systematically record rosbags

The backward_ros package is a ros wrapper of backward-cpp from https://github.com/bombela/backward-cpp

The backward_local_planner package.

The backward_global_planner package.

Python ROS drivers for accessing an Axis camera's MJPG stream. Also provides control for PTZ cameras.

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

This package provides message types commonly used with Autonomous Underwater Vehicles

The autoware_system_msgs package

The autoware_msgs package

Includes messages to handle each class in Autoware Map Format

The autoware_lanelet2_msgs package. Contains messages for lanelet2 maps

Package to contain an install external message dependencies

The autoware_config_msgs package

The autoware_can_msgs package

Generic Messages for Communication with an Automotive Autonomous Platform

Generic Messages for Navigation Objectives in Automotive Automation Software

Messages for vehicle automation

ROS package for recording image and audio synchronously

Convert audio (audio_common_msgs/AudioData) to spectrogram (sensor_msgs/Image)

Outputs audio to a speaker from a source node.

Messages for transmitting audio via ROS

Common code for working with audio in ROS

Transports audio from a source to a destination. Audio sources can come from a microphone or file. The destination can play the audio or save it to an mp3 file.

Gazebo model plugin to simulate Audibot

Meshes and URDF descriptions for audibot

Metapackage for audibot

Support package for the ATF test app packages.

Example test configuration to verifying the correct behaviour of the ATF.

Plugins for the ATF recorder.

ATF plotting functionalities for ATF results.

Messages, services and actions for the ATF.

Metrics for the ATF.

ATF functionalities for generating tests, recording data, analysing data and aggregating results.

An automated testing framework (ATF) written for ROS which supports executing integration and system tests, running benchmarks and monitor the code behaviour over time. The ATF provides basic building blocks for easy integration of the tests into your application. Furthermore the ATF provides everything to automate the execution and analysis of tests as well as a graphical web-based frontend to visualize the results.

Asynchronous Web/WebSocket Server in C++

A C++ library for asynchronous serial communication