Latest entries for tag 'fawkes'

Fawkes 1.0.0 released

Today we are happy to announce the release of Fawkes 1.0.0. This release four years after the last major release (we still need to get better on this) contains a vast amount of new software components and plugins, sub-systems, and overall system and framework improvements. You may also call this the tenth anniversary release (the first commit was done on Sep 5th 2006). In the past years, Fawkes (or parts thereof) has especially been used in domestic service robot and industrial multi-robot logistics tasks.

In the following we present some additions and changes in 1.0.0 since 0.5.0.

Behavior Modeling
A crucial part of a robotics system is the system to model, reason about and decide on, and eventually execute the intended behavior for the robot to accomplish its task. This version contains some significant improvements.
  • CLIPS-based agent framework: based on the integration of the CLIPS rule-based production system of the 0.5 release we now include several plugins that allow for the easy modeling and execution of agents as a rule-based action selection system.
  • OpenPRS: we have integrated and used the procedural reasoning system in the RoboCup Logistics League.
  • ECLiPSe CLP: this constraint logic programming system is used to power a Golog-based agent framework.
  • ROS-BE: we have backported advances made to the ROS version of the Lua-based Behavior Engine back to Fawkes. Additionally, it allows for native access to the ROS universe using roslua
Topological Map Graph
A topological map graph can be useful for global path finding, relating relevant points of interest (POI) from symbolic names to geometric coordinates, and to store semantic information and properties. In Fawkes, the newly introduced navgraph component and provides these capabilities. It is integrated with the behavior components and additionally provides constraint management (block nodes or edges, apply cost factors to edges), which can be used, for example, for path reservation. It features automatic navgraph generation given POIs, obstacles, and a cell-based map. A navgraph can be represented as a YAML file and there is support for interactive manipulation through ROS rviz.
Gazebo Simulation
The new Gazebo simulation system allows easy access to many types of sensors and full interaction with the Gazebo middleware. This integration is the basis for the simulation integration of the RoboCup Logistics League 2015 domain release.
New Hardware Drivers
Fawkes 1.0 supports several new hardware components, such as the Sick TiM 55x and 57x laser range finders, the Asus Xtion, Point Grey Bumblebee2, Cruizcore XG1100 IMU, and arbitrary Dynamixel servo chains. Based on our libkindrv library the Jaco arm is fully supported, even in dual-arm configurations. The Robotino driver supports direct-access communication mode that completely bypasses OpenRobotino (tested on Robotino 3). This allows for access to sensor timestamps and better control. This also includes a simple acceleration controller which makes the Robotino drive much more smoothly.
Other Items
Some of the other noteworthy changes include switching to YAML-based configuration files, switching to the tf2 transforms library, a plugin to recognize clusters in laser data, bash completion support, and support for IPv6 networking. Additionally, a full pipeline for storing, retrieving, and merging point clouds to and from a MongoDB database has been added. Interfaces are now packed more densely, which means external access libraries must be updated (e.g., jfawkes).
There are many other fixes and performance improvements throughout the software.

Thank you to the contributors who made this release possible. The new release is available on the download page. The documentation is continuously extended and improved in our Trac Wiki.

Posted by Tim Niemueller on December 30, 2016 16:17

World Champion in the RoboCup Logistics League 2014 in Brazil

We did it! We won in the RoboCup Logistics League 2014 in João Pessoa, Brazil. In a flawless run through the tournament we won every game and had an exiting final against the title defender Bavarian Bending Units. We participated with the Carologistics team, a joint venture of the Knowledge-based Systems Group, RWTH Aachen University, the IMA/ZLW & IFU Institute Cluster, RWTH Aachen University, and the Department for Electrical Engineering and Information Technology, Robotics Group, FH Aachen

A few days after the German national team won the Fifa World Cup, we also went to Brazil to win a title, in our case the RoboCup 2014 Logistics League. We competed with 9 other teams from Germany, Brazil, Japan, Egypt, Mexico, Switzerland and France. After arriving in João Pessoa, a beautiful city at the beach with topical weather and a lot of coconuts to drink from, we could continue with our good performance from the German Open. Nevertheless we faced various challenges, such as changing lightening conditions and recovering from wrong worldmodels after wrong perception results. As we solved these issues and further improved our low level skills, which use the Lua behavior engine, and the high level task decision based on an incremental reasoning approach in CLIPS with improved multi-robot collaboration, we continued to increase our performance.

In the final we won against the Bavarian Bending Units with the score 165:124. The following video shows the final.

In the first phase, the exploration phase, we could successfully detect all light signals to determine the machine types. Even after one robot had to be restarted, it could continue its work because the robot team synchronizes their knowledge about the world.
In the production phase the robot team got randomized orders and had to produce the products according to the production chain and the machine types with the raw material pucks lying on the side of the field. We especially profited from our collision avoidance and multi-robot coordination. The collision avoidance allowed us to get through narrow passages between other robots or take alternative paths. The high level decision making and multi-robot coordination of the CLIPS agent lead to a fast completion of complex products.

We also won multiple technical challenges, namely the navigation challenge and the MPS challenge:

At the RoboCup Symposium we presented our simulation of the RoboCup Logistics League. It is an important tool for rapid prototyping, especially of the high level decision and multi-robot coordination. It features a 3D physics and sensor simulation with real world environment agency because it is controlled by the referee box that also controls the real game.

Posted by Frederik Zwilling on July 24, 2014 18:00

Winner of the RoboCup German Open 2014 Logistics League

We won the RoboCup German Open 2014 Logistics League with the Carologistics team. In the finals we beat the TUMsBendingUnits with 71:30. This is an important milestone on the road to the RoboCup 2014 in Brazil.

After some mayor rule changes the competing teams had to play in a shared factory space. Here we benefited from your flexible navigation and collision avoidance. The collision avoidance was ported to Fawkes from the AllemaniAcs Team in the RoboCup@Home league and uses an occupancy grid, A* search and a collision free triangle to find trajectories on the planned path. Our performance was also boosted by a closer multi-robot coordination, which allowed the robot team to produce ordered goods more quickly. The robots could perform small sub-steps of a larger production task in parallel and could continue with the work of another robot. For the development of the agent, the component responsible for the task reasoning and multi-robot coordination, we used a Gazebo based simulation of the Logistics League, which allowed rapid prototyping. Furthermore we used more robust techniques for visual perception of light signals and pucks by using colour filters and geometrical clues.

Posted by Frederik Zwilling on April 5, 2014 12:00

Carologistics at RoboCup 2013

We participated with the Carologistics Team at the RoboCup 2013 in Eindhoven, Netherlands. After a promising performance in the round-robin phase we reached the small finals. To achieve this we had to solve many technical challenges, such as task planning, where we used an incremental reasoning approach and visual perception of light signals and pucks.

In the Open Technical Challenge we gave an interesting demo of a Robotino performing a pick-and-place task with a mounted Jaco Arm from Kinova.

Posted by Frederik Zwilling on June 30, 2013 16:00

MongoDB Logging presented at ROSCon 2013

Last weekend some of us went to ROSCon 2013 to listen to all the great stuff happening in the ROS eco system and present some of our own work.

The item which probably gained most attention was the presentation and announcement of the MoveIt release. It's definitely something to look into and a platform to consider in the future for doing mobile manipulation. Another interesting presentation was on the Robot Web Tools. While the presentation's balance leaned a bit from technical to fancy (probably a web people thing) it showed some very nice integration possibilities. Depending on how platform agnostic it is it could be re-used for Fawkes. Another thing to look into is tf2. It seems to finally get rolled out in ROS, making it worthwhile to consider it for integration again.

A particular thing that was talked much about was ROS 2.0, the magic next version which solves everything and makes all dreams come true -- sort of. It shows a lot of promise and the open process by which its design decisions should be made is appealing. Some of the things that were discussed indicate that ROS 2.0 might be much easier to integrate with other non-ROS software.

On our end Ingo Lütkebohle (Bielefeld University) and Tim Niemueller(RWTH Aachen University) presented data recording and evaluation techniques. The MongoDB-based logging received quite some attention. It seems to be time to backport the advancements we made on the Fawkes logger version back to ROS. Additionally the RobotMetaLogger was presented that might benefit by supporting the MongoDB-logger as an input source.

On-line Use of Recorded Data from Database

On particular example we presented is the use of data recording to remember point clouds and other data. Certain times of observation points are recorded during a run. Then later the data and associated transforms is restored and the point clouds are merged to fill shadows and occlusions in the data for a complete perception run. Below are some screenshots of the visualization documenting the process. You can find a video of the process in our recent video on deliberative active perception employing hybrid reasoning.

Posted by Tim Niemueller on May 16, 2013 13:36

Video about Hybrid Reasoning on the PR2

We have posted a video introducing the DFG Research Unit on Hybrid Reasoning in general, and the C1 Robotics sub-project in particular. We present a demo on the PR2 robot that will serve as a baseline system and testbed for further research. The C1 project is a joint effort of the Research Lab Autonomous Intelligent Systems, University of Freiburg, the Knowledge-Based Systems Group, RWTH Aachen University, and the Research Group Foundations of Artificial Intelligence, University of Freiburg.

The Hybrid Reasoning C1 Robotics project investigates effective and efficient ways to combine quantitative and qualitative aspects of knowledge representation and reasoning. In the video in particular, we implemented a baseline system to work on active perception. We want the robot to reason on its current beliefs and if necessary decide what to do to improve them.

The base system was based on ROS for the PR2 and the TidyUpRobot demo from Freiburg. The PDDL-defined planning domain was adapted for action planning in our active perception scenario. The perception system was based on Fawkes' tabletop-objects plugin and the generic robot database recording with MongoDB. The planner decided on a sequence of positions to move to and waited a short time at each position and noted the timestamp at such a position. The database recording was running all the time, storing in particular transforms, images, and point clouds of the Kinect. After each position, the pcl-db-merge plugin was triggered by the planner as another action to merge and align the point clouds. The data for the recorded time stamps was retrieved from the database. The initial point cloud offset estimate was based on the robot's AMCL ( Fawkes port) pose information (at the respective recording time of the point cloud). Then, the point clouds were further aligned using pair-wise ICP alignment (implemented using PCL). The perception pipeline itself was improved to determine cylinder-shaped objects like certain cups. The pipeline was run on the merged point clouds, eventually leading to better results because occlusion shadows and incomplete object shapes had been resolved by taking data from multiple perspectives into account.

In the future, we want to integrate the system with Readylog to model the belief states and reason on their current quality.

The Fawkes related code is available in the timn/pcl-db-merge and abdon/tabletop-recognition branches. The planning code is in the hybris_c1-experimental branch of the alufr-ros-pkg repository.

Posted by Tim Niemueller on March 18, 2013 14:59

Robotino Hackathon 2013

The IMA/ZLW & IFU Institute Cluster, RWTH Aachen University, the Knowledge-based Systems Group, RWTH Aachen University, and the Department for Electrical Engineering and Information Technology, Robotics Group, FH Aachen participate in the RoboCup Logistics League Sponsored by Festo (LLSF) as a joint team.

This year selected students participated in focused development activities regarding computer vision and task coordination. The vision's group task was to create a vision application using the omni-directional camera of the Carologistics Robotino to detect active signal lights on the field. The task of the coordination group was to develop a CLIPS-based agent that would plan for appropriate actions to roam the field to search for these activated signals. Once found, it was to move close to the signal. This forms the base system to perform the "Whack-A-Mole" technical challenge specified in this year's LLSF rules.

As last year it allowed the students to excel at their capabilities and it was a lot of fun. Many of the students decided to stay with the team and are now helping in the preparations for the RoboCup German Open 2013.

Posted by Tim Niemueller on March 1, 2013 12:00

Fawkes 0.5.0 released

Today we are happy to announce the release of Fawkes 0.5.0. This release two years after the last major release (we need to get better on this) contains a vast amount of new software components and plugins, sub-systems, and overall system and framework improvements. For this release, the large majority of additions and changes has been made to functional components and plugins, rather than the core framework. This indicates that Fawkes has matured over the years and provides a solid base for robot software applications.

The new software components cover typical robot tasks like self-localization, (point cloud based) perception, robot arm motion planning, and integration with other software frameworks. Many of these components are possible because we integrated other third party robot software components and make it available within the Fawkes ecosystem. We have also added support for several common robot platforms like the Nao, the Robotino, and the Roomba. These robots can now be used easily out-of-the box with Fawkes.

Here is a more detailed (yet still incomplete) list of additions and changes in Fawkes 0.5.0.

ROS Integration
This version integrates closely with ROS, the Robot Operating System. It can provide data acquired in Fawkes to ROS and vice versa, integrate ROS' move_base locomotion planner, and several plugins now use rviz to visualize their internal state.
OpenNI Integration
Fawkes can now use OpenNI to acquire RGB-D data from sensors like the Kinect, and make use of the provided hand and user tracking capabilities.
Point Cloud Processing
New tool support and plugins have been added to make use of the Point Cloud Library (PCL). For example, a plugin to analyse tabletop scenes has been added identifying the position of table in front of the robot and objects on it.
OpenRAVE Manipulation Planning
An integration plugin for OpenRAVE has been added that allows plugins to use, for example, its motion planning capabilities. The Katana 5 DoF arm hardware plugin has been extended to make use of this new capability.
New Hardware Platforms
Fawkes can now work on robot platforms like the Nao, the Robotino, and the Roomba. The plugins integrate the robot's hardware capabilities and make it easily available to other plugins.
Fawkes now comes with an Adaptive Monte Carlo Localization plugin which has been ported from ROS. Using a known map an frequently taken 2D laser scans it can determine the robot's position within the map.
Coordinate Frame Transforms Framework
Fawkes now includes a framework and library for easily calculating transforms for points in different coordinate frames. The system is based on and thus compatible with ROS' tf framework.
RRD graphing
A new plugin provides RRD graphing capabilities for plugins. For example, for a MongoDB Logging project performance graphs have been created with this framework.
CLIPS Expert System Integration
The CLIPS rule engine for building Expert Systems has been integrated into Fawkes. Plugins can now easily acquire a CLIPS environment and start using it. For example, the Carologistics team has used this to create a reasoning agent to participate in the RoboCup Logistics League sponsored by Festo.

Thank you to the contributors who made this release possible. The new release is available on the download page. The documentation is continuously extended and improved in our Trac Wiki.

Posted by Tim Niemueller on September 27, 2012 12:43

Generic Logging to MongoDB

Autonomous mobile robots produce an astonishing amount of run-time data during their operation. Data is acquired from sensors and actuator feedback, processed to extract information, and further refined as the basis for decision making or parameter estimation. In today’s robot systems, this data is typically volatile. It is generated, used, and disposed right away. However, some of this data might be useful later, for example to analyze faults or evaluate the robot’s performance. A system is required to store this data as well as enable efficient and flexible querying mechanisms.

We have created systems based on the document-oriented, schema-free database MongoDB that is able to store any and all data transmitted via Fawkes blackboard interfaces or ROS topics. A particularly important property is that the interface or message type structure is inherited by the database document, thus allowing selective queries on the stored data. By creating appropriate indexes access is also very efficient. The architecture has been implemented and released as Open Source software for Fawkes and ROS.

This work has recently been accepted for publication at IROS 2012 in the paper "A Generic Robot Database and its Application in Fault Analysis and Performance Evaluation" (Niemueller, Lakemeyer, Srinivasa). The work has been conducted in a cooperation of the Personal Robotics Lab at The Robotics Institute of the Carnegie Mellon University and the Knowledge-based Systems Group of the Computer Science Department of the RWTH Aachen University.

The data can open the door to a wide array of applications, two of which we sketch in the paper. For one, we develop a model of robot data processing and make use of this model to guide our way to manual data-driven fault analysis. For another, we use the MapReduce paradigm to query the data for performance data like number of successful executions and average run times of the behavior system for a particular time range.

The project is described in detail on the Generic MongoDB logging project page.

Posted by Tim Niemueller on July 31, 2012 18:24

Carologistics at RoboCup 2012

The IMA/ZLW & IFU Institute Cluster, RWTH Aachen University, the Knowledge-based Systems Group, RWTH Aachen University, and the Department for Electrical Engineering and Information Technology, Robotics Group, FH Aachen founded the new Carologistics robot team to participate in the Festo RoboCup Logistics League

The team is about to set out for their journey to Mexico City to take part in the competition. During a Hackathon students were trained and selected to take part in the competition and developed the crucial software components required for the competition. They have developed, adapted, ported, and integrated software to perform self localization, navigate the Robotino on the playing field avoiding obstacles, visually detect pucks and lights, and behavior code to tie it all together. They use a mix of Fawkes and ROS to power their robots and to get a tightly integrated system which fits the platform short in terms of computing power. If you are interested about Fawkes and at RoboCup 2012 you are welcome to visit us and have a chat!

Posted by Tim Niemueller on June 14, 2012 01:24

Robotino Hackathon 2012

The IMA/ZLW & IFU Institute Cluster, RWTH Aachen University, the Knowledge-based Systems Group, RWTH Aachen University, and the Department for Electrical Engineering and Information Technology, Robotics Group, FH Aachen founded a new joined team to participate in the Festo RoboCup Logistics League

To kick off the team, and as a preparation for RoboCup 2012 in Mexico City, there will be a Hackathon from May 28th to June 1st (excursion week). The goal of this Hackathon is to integrate a robotics system based on the Robotino robot, that can complete certain logistics task in a restricted environment.

Who can participate?

Any student of the RWTH Aachen University or the FH Aachen can participate. Because of constraints in room and advisers participants will be selected among the applicants. Strong applications including good qualifying information is preferred.

Participants should be fluent in C++ programming. A background in robotics (lectures, programming experience etc.) is preferred but not required. Students must be eager to learn about new mathematical and programming concepts and to work in small groups on a particular topic.

What do we offer?

We can offer first-hand knowledge and experience in robot research and application development from an experienced team of robotics researchers. There will be introductory talks on the first day introducing the topics. On the following days small groups will work on the development an integration of modules on robot self-localization, navigation, computer vision, point cloud processing, behavior design, etc.

Some students will be selected to join us for the participation in RoboCup 2012 in Mexico City based on their work and team cooperation. There will be free Pizza and soft drinks throughout the Hackathon.

Background Info

The RoboCup Logistics League is a brand-new league sponsored by the German industrial manufacturer Festo. The goal is to solve problems in logistics with autonomous mobile robots in a competitive environment. Three Robotino robots per team have the task to transport material between production locations within the field of play.

When will the Hackathon take place?

The Hackathon will be held from May 28th 2012 to June 1st 2012. This is the excursion week at the RWTH Aachen University and there will be no lectures during that time. The Hackathon will be held daily from 9:00 to 18:00. Should you apply participation on each day for the full time is expected (exceptions could be negotiated, state in your application).

How to participate

To participate you will need to apply by email until May 13th 2012. Applicants will be notified by May 20th of acceptance or rejection. There are only a limited number of slots available. Applications will be selected based on the documentation handed in with the application.

To apply send an email to Tim Niemueller including information regarding your studies, semester, and about your background in (C++) programming, robotics, and relevant lectures.

Posted by Tim Niemueller on May 16, 2012 15:20

Fawkes 0.4.2 released

The new GCC version 4.6.0 uncovers more issues than previous GCC releases. With this release, these have been fixed. These bugs did not manifest in typical operation. Additionally, Linux 2.6.38 drops support for Video4Linux version 1, and thus its (non-)existence must be detected. On newer kernels, only the Video4Linux version 2 interface is built now. The issues had been fixed in the master branch a while ago.

These fixes have now been backported to the 0.4 branch, in particular for the upcoming Fedora 15 release. It was detected by our continuous integration build hosts.

Posted by Tim Niemueller on February 22, 2011 12:05

Fawkes 0.4.1 released

In the last few months some minor improvements have been made that we want to share with this release. In particular packaging Fawkes for Fedora shed light on some shortcomings.
Manual pages
All console and GUI tools now come with manual pages. They describe the available options more in-depth than the already existent usage instructions that you get when calling a tool with the "-h" parameter.
Configuration files in user home directories
Until now Fawkes expected a central configuration directory writable by everybody running Fawkes on the system. This is typical on real robots, but this can pose problems on multi-user systems, e.g. during development or using simulation environments. Now, the configuration can still be read from this directory, but information is stored in a .fawkes directory in the user's home directory.
Enforcing undefined symbols
On shared libraries and plugins undefined symbols were not enforced. This is the default behavior of the GNU linker. This can lead to plugins which cannot be loaded later. To uncover this kind of error earlier we now enforce all symbols.
This release contains some minor bug fixes and adjustements for the latest version of libmicrohttpd.
This released contains 35 new commits (overview).

Posted by Tim Niemueller on January 9, 2011 19:55

Fedora now includes Fawkes

Recently we proposed Fawkes for inclusion into Fedora. The review has completed and the package has been accepted! Fawkes and its development environment can now be installed out of the box, see the download page for instructions.

On a related note Fawkes has been chosen by the Fedora Robotics SIG to play a major role in the Fedora Robotics Spin along with Player and Stage. The main idea of this spin is to have software on a LiveDVD providing a ready-to-use robotic simulation environment, with a demo application to introduce users step by step to the available software. Additionally as much robotics related software as possible, ranging from packages for hardware access (laser scanners, robotic arms) and robotic middleware frameworks, to full-blown simulation environments and libraries relevant for robotic applications like vision processing or task control will be added. The Robotics Spin has been proposed as a Fedora 15 Feature.

For this LiveDVD Fawkes will be used in combination with Player and Stage to provide the environment for the demonstration application. In particular, the behavior engine based on Lua will be the tools used to guide the user to complete tasks of increasing complexity within the Stage simulation environment. Among others like Player/Stage and the RoboCup 3D Soccer Server Fawkes will be one of the highlighted robot software packages.

Posted by Tim Niemueller on November 16, 2010 18:09

Video of talk about the Behavior Engine

Recently, I held a talk at Willow Garage about my recent efforts of porting the Fawkes behavior engine to ROS. It gives a brief introduction to Fawkes and explains the basic concepts and what one has to keep in mind when porting the behavior engine, and why Fawkes' architecture is beneficial for knowledge-based systems. It continues with an introduction of the behavior engine stack and the effort to port it to ROS using roslua, also written by the speaker.

This work was conducted as part of my research stay and internship at the Robotics Institute of the Carnegie Mellon University in the Personal Robotics Lab at Intel Labs Pittsburgh with Prof. Siddharta Srinivasa.

Posted by Tim Niemueller on November 12, 2010 15:53