Allows multipoint communication between rosserial nodes connected to an xbee. All nodes communicate back to a master xbee connected to a computer running ROS. This software currently only works with Series 1 Xbees. This pkg includes python code from the python-xbee project: http://code.google.com/p/python-xbee/

rosserial for Windows platforms.

rosserial for the VEX Cortex V5 Robot Brain platform.

rosserial for Cortex/AVR platforms.

rosserial for TivaC Launchpad evaluation boards.

A specialized harness which allows end-to-end integration testing of the rosserial client and server components.

A more performance- and stability-oriented server alternative implemented in C++ to rosserial_python.

A Python-based implementation of the rosserial protocol.

Messages for automatic topic configuration using rosserial.

rosserial for mbed platforms.

rosserial for embedded Linux enviroments

Generalized client side source for rosserial.

rosserial for ChibiOS/HAL platforms.

rosserial for Arduino/AVR platforms.

Metapackage for core of rosserial.

ProAut nearfield_map package

ProAut pointcloud filter package

ProAut parameter package

ProAut octomap package (only messages)

This package contains the source code and the messages for the matlab wrapper.

ProAut octomap package

These are regression tests for the osm_cartography and route_network packages. They are packaged separately to avoid unnecessary implementation dependencies.

Route network graphing and path planning.

Geographic mapping using Open Street Map data.

The trac_ik_python package contains a python wrapper using SWIG for trac_ik_lib

TRAC-IK is a faster, significantly more reliable drop-in replacement for KDL's pseudoinverse Jacobian solver. The TRAC-IK library has a very similar API to KDL's IK solver calls, except that the user passes a maximum time instead of a maximum number of search iterations. Additionally, TRAC-IK allows for error tolerances to be set independently for each Cartesian dimension (x,y,z,roll,pitch.yaw).

A MoveIt! Kinematics plugin using TRAC-IK

This package contains the source code for testing and comparing trac_ik

The ROS packages in this repository were created to provide an improved alternative Inverse Kinematics solver to the popular inverse Jacobian methods in KDL. TRAC-IK handles joint-limited chains better than KDL without increasing solve time.

Common msg and srv definitions used by Roboception's ROS packages

Network interfaces and messages.

The rt_usb_9axisimu_driver package

ROS msgs for fadecandy LED controllers

ROS driver for fadecandy LED controllers

Access to the DD-WRT wifi

Defines helper functions and routines that greatly help when trying to create a settler for a specific sensor channel. This package is experimental and unstable. Expect its APIs to change.

rosrt provides classes for interfacing with ROS from within realtime systems, such as realtime-safe Publisher and Subscriber classes.

rosatomic provides the C++11-style atomic operations by pulling symbols from the proposed Boost.Atomic package into the ros namespace. Once C++11-style atomics (std::atomic) are available from compilers, rosatomic will conditionally use those instead.

The ros_realtime package

Listens on a ImageFeatures topic, and waits for the data to settle. This package is experimental and unstable. Expect its APIs to change.

The lockfree package contains lock-free data structures for use in multithreaded programming. These kinds of data structures are generally not as easy to use as single-threaded equivalents, and are not always faster. If you don't know you need to use one, try another structure with a lock around it first.

Extracts checkerboard corners from a dense laser snapshot. This package is experimental and unstable. Expect its APIs to change.

Provides a node that reports how long a subset of joints has been settled. That is, it calculates how long a set of joints has remained within a specified threshold. This package is experimental and unstable. Expect its APIs to change.

Tools for calculating the intersection of interval messages coming in on several topics. This package is experimental and unstable. Expect its APIs to change.

Provide a node that extracts checkerboard corners from ROS images. This package is still experimental and unstable. Expect its APIs to change.

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.

Contains aligned allocation functions, as well as an STL-compatible AlignedAllocator class.

A C++ library for asynchronous serial communication

rqt_py_trees provides a GUI plugin for visualizing py_trees behaviour trees based on rqt_tf_tree.

Messages used by py_trees_ros and some extras for the mock demos/tests.

The pr2_kinematics package

This package provides a kinematics implementation for the PR2 robot. It can be used to compute forward and inverse kinematics.

Server Side tools for Authorization and Authentication of ROS Clients

ROS package for LDS(HLS-LFCD2). The LDS (Laser Distance Sensor) is a sensor sending the data to Host for the simultaneous localization and mapping (SLAM). Simultaneously the detecting obstacle data can also be sent to Host. HLDS(Hitachi-LG Data Storage) is developing the technology for the moving platform sensor such as Robot Vacuum Cleaners, Home Robot, Robotics Lawn Mower Sensor, etc.

The DYNAMIXEL SDK ROS example package

This package is wrapping version of ROBOTIS Dynamixel SDK for ROS. 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 video_stream_opencv package contains a node to publish a video stream (the protocols that opencv supports are supported, including rtsp, webcams on /dev/video and video files) in ROS image topics, it supports camera info and basic image flipping (horizontal, vertical or both) capabilities, also adjusting publishing rate.

ROS package of IRIS Localization and Mapping (LaMa).

Message and service types: custom messages and services for TurtleBot3 packages

Moveit demos for the PhantomX Pincher arm.

An automatically generated package with all the configuration and launch files for using the pincher_arm with the MoveIt! Motion Planning Framework

IKFast plugin for the PhantomX Pincher arm

URDF Description package for PhantomX Pincher arm

Launch files for starting PhantomX Pincher arm drivers.

The pincher_arm metapackage.

ROS messages for publishing graphs of different data types

fcl_catkin

ROS Package Tool

This package is currently for internal use only. Its API may change without warning in the future. This package is deprecated.

A ROS driver node for AVT/Prosilica Gigabit Ethernet (GigE) cameras.

The driver_common stack contains classes and tools that are useful throughout the driver stacks. It currently contains: driver_base: A base class for sensors to provide a consistent state machine (retries, error handling, etc.) and interface timestamp_tools: Classes to help timestamp hardware events

A framework for writing drivers that helps with runtime reconfiguration, diagnostics and self-test. This package is deprecated.

The hfl package

Standard ROS messages for radars

Metapackage referencing tutorials related to rviz and visualization.

The visulalization_marker_tutorials package

Tutorials showing how to call into rviz internals from python scripts.

Tutorials showing how to write plugins for RViz.

Tutorial showing how to compile your own C++ program with RViz displays and features.

The interactive_marker_tutorials package

Teleoperation for fetch and freight.

Fetch ROS, packages for working with Fetch and Freight

Configuration and launch files for running ROS navigation on Fetch.

An automatically generated package with all the configuration and launch files for using the fetch_urdf with the MoveIt Motion Planning Framework

The fetch_maps package

Kinematics plugin for Fetch robot, generated through IKFast

URDF for Fetch Robot.

The fetch_depth_layer package

Launch and configuration files for calibrating Fetch using the 'robot_calibration' package.

The Robot Pose EKF package is used to estimate the 3D pose of a robot, based on (partial) pose measurements coming from different sources. It uses an extended Kalman filter with a 6D model (3D position and 3D orientation) to combine measurements from wheel odometry, IMU sensor and visual odometry. The basic idea is to offer loosely coupled integration with different sensors, where sensor signals are received as ROS messages.

rqt_plot provides a GUI plugin visualizing numeric values in a 2D plot using different plotting backends.

rospilot

An open-source version of the Fetch charge docking system.

Messages for the fetch_drivers package

Messages for fetch_auto_dock package

libuvc_ros metapackage

USB Video Class camera driver

The gpp_update_map plugin will update the map before running the global planner

The gpp_prune_path plugin will prune the path produced by a global-planner

The gpp_plugin package offers a pipeline for running global planners together with auxiliary pre- and post-processing functions

The gpp_interface package defines the interfaces for pre and post-planning inside the global_planner_pipeline framework

message_to_tf translates pose information from different kind of common_msgs message types to tf. Currently the node supports nav_msgs/Odometry, geometry_msgs/PoseStamped and sensor_msgs/Imu messages as input. The resulting transform is divided into three subtransforms with intermediate frames for the footprint and the stabilized base frame (without roll and pitch).

hector_pose_estimation_core is the core package of the hector_localization stack. It contains the Extended Kalman Filter (EKF) that estimates the 6DOF pose of the robot. hector_pose_estimation can be used either as a library, as a nodelet or as a standalone node.

hector_pose_estimation provides the hector_pose_estimation node and the hector_pose_estimation nodelet.

The hector_localization stack is a collection of packages, that provide the full 6DOF pose of a robot or platform. It uses various sensor sources, which are fused using an Extended Kalman filter. Acceleration and angular rates from an inertial measurement unit (IMU) serve as primary measurements. The usage of other sensors is application-dependent. The hector_localization stack currently supports GPS, magnetometer, barometric pressure sensors and other external sources that provide a geometry_msgs/PoseWithCovariance message via the poseupdate topic.

The rc_genicam_camera provides images from a GenICam compatible camera.

SainSmart USB relay driver controller

Extract geometry value of a vehicle from urdf.

The robotont_nuc_description package

The robotont_msgs package

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

Generic keyboard teleop for legged robots.

include This package provides an implementation of a 3D costmap that takes in sensor data from the world, builds a 3D occupancy grid of the data for only one iteration.

The remote_rosbag_record package

The ixblue INS defined messages package

The iXblue_ins_driver package

Metapackage for iXblue INS driver

The lms1xx package contains a basic ROS driver for the SICK LMS1xx line of LIDARs.

ROS client nodes for the

The ddynamic_reconfigure package

visualization_msgs is a set of messages used by higher level packages, such as

This package defines messages for defining robot trajectories. These messages are also the building blocks of most of the

stereo_msgs contains messages specific to stereo processing, such as disparity images.

This package contains messages for defining shapes, such as simple solid object primitives (cube, sphere, etc), planes, and meshes.

This package defines messages for commonly used sensors, including cameras and scanning laser rangefinders.

nav_msgs defines the common messages used to interact with the

geometry_msgs provides messages for common geometric primitives such as points, vectors, and poses. These primitives are designed to provide a common data type and facilitate interoperability throughout the system.

This package holds the diagnostic messages which provide the standardized interface for the diagnostic and runtime monitoring systems in ROS. These messages are currently used by the

common_msgs contains messages that are widely used by other ROS packages. These includes messages for actions (

actionlib_msgs defines the common messages to interact with an action server and an action client. For full documentation of the actionlib API see the

Pythonic implementation of behaviour trees.

Merging multiple maps without knowledge of initial positions of robots.

Lightweight frontier-based exploration.

Extends the arbotix_node package with a number of more sophisticated ROS wrappers for common devices.

Bindings and low-level controllers for ArbotiX-powered robots.

Messages and Services definitions for the ArbotiX.

Firmware source code for ArbotiX ROS bindings.

Extends the arbotix_python package with a number of more sophisticated ROS wrappers for common devices.

ArbotiX Drivers

Robot agnostic information theoretic exploration strategy

Collection of gazebo plugins

The urdf_sim_tutorial package

Contains different nodes to generate routing graphs for the robot router. voronoi_graph_generator generates a voronoi graph out of a map. dxf_to_graph generates a graph out of a dxf file and segments_to_graph creates a graph using a config file with line segments as input.

Presents rviz plugins to set goal positions for the planner and a tool to visualize generated graphs.

This package contains a MultiRobotRouter using Prioritized Planning in Combination with a collision resolution algorithm to find a routing tabel for a large number of robots.

This package presents a node, which converts synchronized robot routes to path segments published sequentially to maintain synchronization

The tuw_multi_robot_goal_generator package was designed to generate, store, and read goal lists for the tuw_multi_robot_router. The goal_saver is able to store publish goal msgs of type tuw_multi_robot_msgs::RobotGoalsArray in a human readable form. The goal_server is able to read and publish this msgs and to read patches of saved goals for testing. The goals_random node subscribes to the occupancy grid and is able to auto generate valid goals for testing.

Contains launch and config files to run a sample demo.

A simple multi robot controller using Routes as input, which are used to execute the path synchronized.

This repository includes ros packages to plan routes for multiple robots on a search graph. It creates a search graph out of a pixel map and tries to find a path for multiple robots using an extended approach for prioritized planning. The inputs are the tuw_multi_robot_msgs/RobotInfo messages which include the robots pose, the map and the desired goal poses. The output are multiple synchronized routes given to the individual robots.

Simple node to publish regular IP camera video streams to a ros topic.

Visualization for the XPP Motion Framework.

Common definitions (positions, velocities, angular angles, angular rates) and robot definitions in Cartesian and joint state used in the Xpp Motion Framework, as well as conversions to/from xpp_msgs.

The URDF file for a quadrotor to be used with the xpp packages and a simple rviz publisher of quadrotor tfs. Adapted from Daniel Mellinger, Nathan Michael, Vijay Kumar, "Trajectory Generation and Control for Precise Aggressive Maneuvers with Quadrotors".

ROS messages used in the XPP framework.

HyQ-robot specific functions for visualization in the XPP Motion Framework. These include inverse kinematics as well as urdf files for a one-legged, two-legged and four legged robot with

Examples of how to use the xpp framework.

Visualization of motion-plans for legged robots. It draws support areas, contact forces and motion trajectories in RVIZ and displays URDFs for specific robots, including a one-legged, a two-legged hopper and

The rqt_ez_publisher package

Interface driver for Omron OS32C Lidar via Ethernet/IP (Industrial Protocol)

Library implementing ODVA EtherNet/IP (Industrial Protocol).

Generic joystick teleop for twist robots.

Provides tools for viewing data produced by nodes that use the swri_profiler library to output profiling information.