Only released in EOL distros:   indigo jade kinetic

Introduction

This package provides topics and services specific for the ROS integration with the simulation of the RoboCup Logistics League (RCLL) that is also used for the Planning Competition for Logistics Robots In Simulation. The simulation environment is based on Gazebo and Fawkes. Detailed information about the simulation is available on the RCLL simulation website.

The main node of this package provides access to the global pose of the robot, light signal information perceived by the robot, feedback from zone exploration, and a service to trigger navgraph generation. Additional nodes allow for automatic sending of beacons and skill execution integration (not necessary anymore, it still exists for reference if you want to interface directly with Fawkes).

The nodes should each operate in a robot-specific namespace. For an example see the included launch files.

If you use the provided USB stick, you do not need to worry about the requirements and installation requirements, it is all setup and this page only documents the available interfaces/API. Use the following instructions if you want to setup the simulation on your own system.

Requirements

• A desktop-full installation of Indigo, Jade, or Kinetic (our primary toolchain is based on Fedora 23 or later, but Ubuntu 14.04 or later will also work)

• Gazebo 5 or later (if using Indigo, you must build from source using the latest system version, the included version 2 will not work)

• RCLL Simulation, setup instructions (the following components are part of the installation instructions)

  • RCLL referee box

  • Gazebo models and plugins

  • Carologistics RCLL 2016 release (to be published in January 2017)

• fawkes_msgs

• rcll_fawkes_sim_msgs

• rcll_ros consisting of rcll_ros_msgs and rcll_refbox_peer

For general setup instructions to setup ROS and Fawkes on your system please have a look at our wiki for installation on Fedora, or Ubuntu.

Running the Simulation with ROS Integration

Then it is time to start the simulation. First, run without the ROS integration and with the default agent that comes with the simulation.

cd fawkes-robotino/bin
./gazsim.bash -x start -r -a -t -n1

This opens a separate terminal with several tabs. Please see the instructions to run a game in the simulation that gives an overview of the tabs and what to do to start the game. Once you set the game to the exploration phase the robots should start moving. If you are at this point, excellent!

Then it is time to run the simulation with the ROS integration. We modify the command above to the following.

cd fawkes-robotino/bin
./gazsim.bash -x start -n 1 -r -t \
  --ros-launch-main rcll_fawkes_sim:rcll_fawkes_sim_all_1robot.launch

This will run the simulation without the original agent (no "-a" flag) and with the appropriate ROS nodes for a single robot (the robot should still appear in the refbox shell as before and rostopic list should show many topics, also in the robot1 namespace.

Then we instruct the robot to move to a specified machine. To do this, run the actionlib client:

rosrun actionlib axclient.py /robot1/skiller fawkes_msgs/ExecSkillAction

Then in the "Goal" box enter the following:

skillstring='ppgoto{place="C-CS1-O"}'

This instructs the robot to go with global path planning to the output side of the first cyan cap station. The robot should then start moving and the goal should show as completed once the position has been reached.

At this point you are ready to go! Have a look at the list of available skills and make the robot do as you wish.

Getting Help

If you run into trouble, please join the planning competition's Google group to ask questions.

Nodes

This package contains the following nodes.

rcll_fawkes_sim

This is the main node providing RCLL-specific information.

Published Topics

rcll_sim/explore_zone_info (rcll_fawkes_sim_msgs/ExplorationZoneInfo)

• This is used to emit special feedback during the execution of the explore_zone skill. Describes certainty whether a machine has been detected in a zone. This allows, for example, to skip zones for which it cannot be determined with certainty that it contains a machine, for example because a robot was passing to this robot's field of view, and re-visit this zone later.
  
  The state can be unknown, definite yes or no, or maybe, e.g., spurious registering of an obstacle, might also have been a passing robot, recommended to re-visit later if there is time. See the explore_zone skill documentation for further details.

rcll_sim/mps_marker_array (rcll_fawkes_sim_msgs/MPSMarkerArray)

• Provides information to the markers currently visible to the robot.

rcll_sim/mps_light_state (rcll_fawkes_sim_msgs/MPSLightState)

• Information about the light currently in sight. Note that this also contains the information whether any light is visible at all at the moment. This could be used to write a custom behavior during exploration for light signal handling or to read out the machine state during production (which is not strictly necessary, as the information is distributed in the machine info topic of the rcll_refbox_peer node.

rcll_sim/amcl_pose (geometry_msgs/PoseWithCovarianceStamped)

• This gives the position of the robot in the global coordinate frame (see rulebook for the origin and alignment of this frame). It is based on the localization data and thus does contain noise and is subject to a (small) delay.
  
  Note that the very same information is available through the transforms system tf2 as it is published by the Fawkes plugin ros-tf.

Services

rcll_sim/navgraph_generate (rcll_fawkes_sim_msgs/NavgraphWithMPSGenerate)

• If the navgraph generation is to be performed on custom information use this service to do so, e.g., to add additional points of interest or to generate the graph after doing a custom exploration. When running the simulation with the "-t" flag, the graph is automatically generated from ground truth.

rcll_beacon_sender

This node allows to periodically send a beacon signal to the referee box. Ideally, the same operation will be performed by your system's executive to signal aliveness of the robot and readyness to perform its task. In this case, the source of this nodes serves as an example. If it is not possible that the executive performs this task, this node may be run as an alternative. Note, however, that failures of the executive may go unnoticed then.

Subscribed Topics

rcll_sim/amcl_pose (geometry_msgs/PoseWithCovarianceStamped)

• Used to fill in the position information of beacon signals.

Services Called

rcll/send_beacon (rcll_ros_msgs/SendBeaconSignal)

• Called periodically (once per second) to trigger sending of a beacon signal.

fawkes_skiller

This node provides an action to execute skills through the Lua-based Behavior Engine, more specifically through its Fawkes implementation skiller (skill execution and run-time. The current version of Fawkes provides the ros-skiller which serves the same purpose (and provides exactly the same ROS message API), please see its documentation on how to execute skills.

The fawkes_skiller node is used as it more easily supports remapping to push each robot into its own namespace.

Action Goal

skiller/goal (fawkes_msgs/ExecSkillGoal)

• This formulates the skill string to be executed by a skiller. See the skiller documentation for specifics on this string.

Action Result

skiller/result (fawkes_msgs/ExecSkillResult)

• Upon failure, contains an error string. Note that the actionlib server state machine is used to indicate success or failure.

Action Feedback

skiller/feedback (fawkes_msgs/ExecSkillFeedback)

• No feedback is provided.

Published Topics

skiller_status (fawkes_msgs/SkillStatus)

• Provides monitoring of the skiller status, e.g., whether a skill is being executed and whether it succeeded or failed.