- Descriptions of each project are taken directly from their corresponding homepage.
- Some projects are only supported in specific releases.
Player is a network server for robot control. Running on your robot, Player provides a clean and simple interface to the robot's sensors and actuators over the IP network. Your client program talks to Player over a TCP socket, reading data from sensors, writing commmands to actuators, and configuring devices on the fly.
Player supports a variety of robot hardware. The original Player platform is the ActivMedia Pioneer 2 family, but several other robots and many common sensors are supported. Player's modular architecture makes it easy to add support for new hardware, and an active user/developer community contributes new drivers.
Player runs on Linux (PC and embedded), Solaris and *BSD.
Stage simulates a population of mobile robots, sensors and objects in a two-dimensional bitmapped environment. Stage is designed to support research into multi-agent autonomous systems, so it provides fairly simple, computationally cheap models of lots of devices rather than attempting to emulate any device with great fidelity. We have found this to be a useful approach.
Stage provides populations of virtual devices for Player. Users write robot controllers and sensor algorithms as 'clients' to the Player 'server'. Typically, clients cannot tell the difference between the real robot devices and their simulated Stage equivalents (unless they try very hard). We have found that clients developed using Stage will work with little or no modification with the real robots and vice versa. Thus Stage allows rapid prototyping of controllers destined for real robots. Stage also allows experiments with realistic robot devices you don't happen to have. Various sensors and actuators are provided, including sonar, scanning laser rangefinders, vision (color blob detection), odometry, and a differential steer robot base.
Gazebo is a multi-robot simulator for outdoor environments.
Like Stage, it is capable of simulating a population of robots, sensors and objects, but does so in a
three-dimensional world. It generates both realistic sensor feedback and physically plausible interactions between
objects (it includes an accurate simulation of rigid-body physics).
- Simulation of standard robot sensors, including sonar, scanning laser range-finders, GPS and IMU's.
- Models for commonly used robot types such as the Pioneer2AT.
- Realistic simulation of rigid-body physics: robots can push things around, pick things up, and generally interact with the world in a plausible manner.
- Player compatible: robots and sensors can be controlled through standard Player interfaces.
- Stand-alone operation: programs can interact directly with the simulator (i.e., without going through Player) using libgazebo (included in the distribution).
- Gazebo is free software, released under the GNU Public License. You are free to use, extend and modify Gazebo according to your needs, but we would appreciate it if you would send us your patch.
FlowDesigner is a free (GPL/LGPL) data flow oriented development environment. It can be used to build complex applications by combining small, reusable building blocks. In some ways, it is similar to both Simulink and LabView, but is hardly a clone of either.
FlowDesigner features a RAD GUI with a visual debugger. Although FlowDesigner can be used as a rapid prototyping tool, it can still be used for building real-time applications such as audio effects processing. Since FlowDesigner is not really an interpreted language, it can be quite fast.
It is written in C++ and features a plugin mechanism that allows plugins/toolboxes to be easiliy added. FlowDesigner currently includes the following toolboxes:
- Signal processing
- Audio processing (DSP)
- Vector quantization
- Neural network
- Fuzzy logic
- Real-time audio effect processing (pre-alpha)
- Linear algebra using LAPACK (pre-alpha)
- Octave plug-in (pre-alpha)
[http://robotflow.sf.net/ RobotFlow is a mobile robotics tookit based on the FlowDesigner project. The visual programming interface provided in the FlowDesigner project will help people to better visualize & understand what is really happening in the robot's control loops, sensors, actuators, by using graphical probes and debugging in real-time.
The FlowDesigner & the Robotflow toolkit are written in C++ and provide fully customizable control and processing blocks :
- Drivers & interfaces for Pioneer2 Robots
- Vision processing algorithms (color training & tracking, etc.)
- Player / Stage simulator drivers for FlowDesigner/RobotFlow
- Signal processing algorithms (audio + video)
- Basic Behaviors
- Fuzzy Logic control
- Artificial Neural Networks
- Embedded super blocks (subnets, iterators)
- Basic networking (TCP/IP, broadcast)
- Device control (Sony EVI-D30, SICK lasers, etc.)
- Finite State Machine (beta)
CARMEN is an open-source collection of software for mobile robot control. CARMEN is modular software designed to provide basic navigation primatives including: base and sensor control, obstacle avoidance, localization, path planning, people-tracking, and mapping.
The pmap package provides a number of libraries and utilities for laser-based mapping (SLAM) in 2D environments. It contains four principle components:
- A library for laser-stabilized odometry (lodo). This library uses an incremental SLAM algorithm to correct odometric pose estimates; it produces drift rates that are at least an order of magnitude lower than those observed with odometry alone.
- A library for particle-filter-based mapping (pmap). This library maintains a particle filter over possible maps; the final map will be topologically correct but locally mis-aligned.
- A library for relaxation over local constraints (rmap). This library uses an iterated closest point algorithm to refine topologically correct maps; the output map is both topologically correct and local aligned.
- A library for occupancy grid mapping (omap). This library converts a set of laser ranges scans into an occupancy grid map.
The four components are designed to work together to produce high-quality occupancy grid maps.
Map Manager Library
Map Manager Library is a library for working with maps of an environment, primarily for use with robotics research. It can edit maps from most of the major robot simulators including:
- ActivMedia's Saphira
- Carnegie Mellon's CARMEN
Radish - The Robotics Data Set Repository - provides a collection of standard robotics data sets. Contained here-in you will find:
- Logs of odometry, laser and sonar data taken from real robots.
- Logs of all sorts of sensor data taken from simulated robots.
- Environment maps generated by robots.
- Environment maps generated by hand (i.e., re-touched floor-plans).
By making these data sets available to the community, we aim to facilitate the development, evaluation and comparison of robotics algorithms. While the current focus is clearly on localization and mapping, we expect that Radish will ultimately expand to reflect the interests of the broader robotics community. Radish is a community effort. Researchers are invited to download and make use of the data sets contained here-in, and, in return, to make their own contributions to the repository.
The ADAPTIVE Communication Environment (ACE) is a freely available, open-source object-oriented (OO) framework that implements many core patterns for concurrent communication software. ACE provides a rich set of reusable C++ wrapper facades and framework components that perform common communication software tasks across a range of OS platforms. The communication software tasks provided by ACE include event demultiplexing and event handler dispatching, signal handling, service initialization, interprocess communication, shared memory management, message routing, dynamic (re)configuration of distributed services, concurrent execution and synchronization.
ACE is targeted for developers of high-performance and real-time communication services and applications. It simplifies the development of OO network applications and services that utilize interprocess communication, event demultiplexing, explicit dynamic linking, and concurrency. In addition, ACE automates system configuration and reconfiguration by dynamically linking services into applications at run-time and executing these services in one or more processes or threads.
MPICH2 is an implementation of the Message-Passing Interface (MPI). The goals of MPICH2 are to provide an MPI implementation for important platforms, including clusters, SMPs, and massively parallel processors. It also provides a vehicle for MPI implementation research and for developing new and better parallel programming environments.
[href="http://www.activrobots.com/SOFTWARE/" ARIA] (ActivMedia Robotics Interface Application) is designed for professional developers. It is a powerful Object Oriented (OO) interface to ActivMedia mobile robots, usable under Linux or Win32 OS in C++. ARIA may be distributed under the GNU GPL license or proprietary licenses may be purchased.
ARIA is an API (Application Programming Interface), designed and written entirely in the OO paradigm. ARIA communicates with the robot via a client/server relationship, either using a serial connection (to talk to the robot) or a TCP/IP connection (to talk to a simulator SRIsim).
ARNL - Autonomous Robotic Navigation & Localization - software adds robot localization to the base of ARIA libraries. ARNL uses Monte Carlo / Markov localization techniques and navigation using a modified value iterated search approach. This high-level software comes with every R&D robot accompanied by a laser . Robot position, position probability, and robot status information are available from ARNL. Goals, docks, homes, forbidden lines and other .map features inserted in Mapper are available to ARNL.
libxml2 is the XML C parser and toolkit developed for
the Gnome project (but usable outside of the Gnome platform), it is free software available under the MIT License.
XML itself is a metalanguage to design markup languages, i.e. text language where semantic and structure are added
to the content using extra "markup" information enclosed between angle brackets. HTML is the most well-known markup
language. Though the library is written in C a variety of language bindings make it available in other environments.
Libxml2 is known to be very portable, the library should build and work without serious troubles on a variety of systems (Linux, Unix, Windows, CygWin, MacOS, MacOS X, RISC Os, OS/2, VMS, QNX, MVS, ...)
Qt - Cross-Platform C++ Development - sets the standard for high-performance, cross-platform application development. It includes a C++ class library and tools for cross-platform development and internationalization.
Qt is a comprehensive development framework that includes an extensive array of features, capabilities and tools that enable development of high-performance, cross-platform rich-client and server-side applications.
WxWidgets gives you a single, easy-to-use API for writing GUI applications on multiple platforms. Link with the appropriate library for your platform (Windows/Unix/Mac, others shortly) and compiler (almost any popular C++ compiler), and your application will adopt the look and feel appropriate to that platform. On top of great GUI functionality, wxWidgets gives you: online help, network programming, streams, clipboard and drag and drop, multithreading, image loading and saving in a variety of popular formats, database support, HTML viewing and printing, and much much more.
Expression Toolkit is an animation system based
on an anatomical model of the face. Using basic muscle simulation instead of morph targets, Expression simplifies
the creation of lifelike characters, allowing a face to be set up in a matter of hours instead of days. Written in
C++ and OpenGL, Expression is a general-purpose framework for real-time facial animation in games and web applications.
CppUnit is a C++ unit testing framework. It started its life as a port of JUnit to C++ by Michael Feathers.
mockpp is a platform independent generic unit testing framework for C++. It's goal is to facilitate developing unit tests in the spirit of Mock Objects for Java, EasyMock and jMock.
Mock objects allow you to set up predictible behaviour to help you test your production code by emulating some functionality your code depends on. This might for example be a huge database which is too difficult and time consuming to maintain just for testing purposes.