Running Carmen

Introduction

This document is an aid to begin using the CARMEN robot sensing and navigation software, including (but not limited to) the following programs:

• logger

This program stores sensor and odometry data with time stamps into a log file.

• playback

This program plays back a log file and send the stored messages to the other modules.

• map_editor

This program allows for creating or editting maps for use by Carmen.

• navigatorgui

This program provides a graphic interface which shows the robot's position and destiation on the pre-built map and allows setting of the current position and orientation, and selection of destinations.

• param_edit

This program enables the user to change parameters as the robot is running. It also makes it easy to save the changes to a ".ini" file.

• param_deamon

This program provides other programs with information about the robot being used and the area around it. This can include a pre-built map, sensors on the robot, and typical sensor error.

• robotgui

This program provides a simple graphic interface for the robot, allowing direct motion control and a display of current sensor information.

• processcontrol

This program controls the different processes, restarts them in case of a crash, etc.

• simulator

This program provides simulated data generation from a virtual robot. It requires a previously generated map.

• base_services

This program controls the movement of the robot and accepts inputs from the sensors. This program MUST run on the computer attatched to the robot hardware.

• localize

This program uses the sensor information from the baseServer to find the robot position in a map provided by param_deamon.

• navigator

This program enables autonomous navigation.

• vasco

This program creates a map from sensor and odometry data stored in a log file.

• vasco-tiny

A command line scan-matcher based on vasco. It reads log files and outputs a (locally) corrected log file.

The links above will go to other pages with more complete descriptions and instructions for using these programs.

The "central" program, IPC, enables communication between these and other programs. Information on using and coding with IPC can be found at http://www-2.cs.cmu.edu/afs/cs/project/TCA/www/ipc/ipc.html. A simplistic explanation of IPC: various programs "publish" generated information which is then "subscibed to" by other programs. IPC keeps track of what is published and delivers it to the subscribers.

Carmen use Scenaria

The use of CARMEN will described using two different scenaria: simulating a robot and way-point navigation of it in a known map and then running a playback of a logged ride. Since CARMEN is modular software, each scenario will involve opening a bunch of different xterms and running different programs (called modules in the LCAD version of Carmen). Alternatively, one can use the program proccontrol to start and control each module.

Before starting, go to the Carmen sub-directory carmen/bin.

Running a Simulated Robot

In this section you will learn how to run a simulation of the autonomous driving car from IARA project. Just follow the steps bellow to understand how each of the modules are initialized for this task.

The modules shown in this tutorial may be replaced, as the project is still in developpement. So we encourage you to check the 'process-navigate-volta-da-ufes-pid.ini' file. There you will see every module been used by this process (that is usualy the most update one).

To run the simulation just do:

  cd $CARMEN_HOME/bin/
  ./central

And then, in another tab in the bin/ directory:

  ./proccontrol process-navigate-volta-da-ufes-pid.ini

This will run all the commands automatically.

Central notes

If the central server is already running, you might receive the message:

  Error: unable to bind TCP/IP socket for listening

You can check if the server is running using the command:

  ps -a | grep central

If there is a server running you will receive a message like this:

  6446 pts/0    00:00:00 central

You can kill a running central using:

  killall central

If you are running programs on multiple machines, then you must specify on the other machines which machine is running central. This is done with the bash command:

  export CENTRALHOST=[hostname]

where [hostname] is the name of the machine on which central is running.

Note: When running displays on off-robot computers, running the display programs off-robot rather than on-robot uses less bandwidth than piping the X display across the network.

Parameters Server

  ./param_daemon ../src/carmen-ford-escape.ini

The command above will start the param_deamon such that read the parameters for LCAD's robots and modules from the parameter file "carmen/src/carmen-ford-escape.ini". Some of the parameters contained in "carmen-ford-escape.ini" are informations about the localization, mapping and odometry modules, as well as the geometry of the sensors and the car it-self.

Other command-line options are:

• [map_filename] Opens the map to get some information about it
• robot [robotname] directs the server to parameters specific to the robot which should exist in the specified parameter file.
• [mapfile.map] directs the server to a map file specific to the location. If you do not specify a mapfile, then no map will be served.
• [paramfile.ini] specifies a parameter file. If no file is specified, then parameters from carmen.ini will be used. The param_deamon will look first in the current directory, then the parent directory (../), and then ../src/ for carmen.ini.
• [-port portnum] specifies a port to be used for an ANT server
• [-noant] says not open an ANT server
• [-useant] says to use an ANT server

Proccontrol GUI

Command:

  ./proccontrol_gui

The command above will open an interface where you can easily monitor the modules running for this simulation. As you run other modules, their names will apear in the screen.

Map Server

  ./map_server -map_path ../data/map_ida_guarapari-20170403-2 -map_x 7756892.9 -map_y -364045.2 -block_map on  -lanemap_incoming_message_type 0

The map_server program will load the car's poses and the OFFLINE map from the informations contained in ../data/map_ida_guarapari-20170403-2 directory. The OFFLINE MAP serves as reference to the localisation system of the car.

Essential command-line options:

• -map [map-file]  : Load an offline map from the [map-file].
• -map_path [path]  : Enter the path to the offline map directory.
• -map_x [float]  : map's x global position.
• -map_y [float]  : map's y global position.
• -block_map ['on'/'off'] : enable the generation of the map with the data inside the [path] directory.

Simulator Module

  ./simulator_ackerman

This command will start a moderately useful 2-D simulator, intended to replace the base module. It publishes odometry, laser messages and sonar messages. It accepts base velocity commands. The simulator always starts with its robot in the bottom right corner of the map (0,0), but subscribes to localize_initialize messages as well as simulator_set_truepose messages to initialize its robot position.

The simulator can also run an instance of the robot module to provide collision prevention. This, however, needs to be activated in the ini file using the parameter "simulator_use_robot". This parameter is disabled by default, which means that you have to start the module robot separately.

Slam modules

  ./localize_ackerman -mapping_mode off &
  ./mapper -map_path ../data/mapper_teste -map_x 7756450 -map_y -364200 &
  ./obstacle_distance_mapper

The localize module is the original Carmen localization program using a particle filter. It can perform global localization and pose tracking. Localize uses a set of parameters that (strongly) influence the robustness and performance of localize. This is mainly the observation likelihood model and the noise in the motion model. You will find those parameters as expert parameters in the `carmen-ford-escape.ini` file. In this case we use the '-mapping_mode off' command-line option because we are not generating an offline map from sensor logs.

The mapper module updates the offline map loaded from the map_server module with real-time information (moving objects, people, etc).

RDDF Module

RDDF stands for Road Data Definition file.

  ./rddf_play ../data/rndf/rddf-voltadaufes-20170809.txt ../data/rddf_annotation_log_20140418.txt

This program will create a file that contains pose informations (position and angles) about a previous driven ride. This will be a reference to the rigth path inside the road to the car when in autonomous mode.

Behavior Selector

  ./behavior_selector

As the name suggest, this program will choose the rigth behavior in each different situation detected by other modules.

Motion Control Module

Model predictive planner

  ./model_predictive_planner
  ./rrt_path_follower

The first module outputs the aceleration of the car based on the next position desired. The rtt_path_follower module tries to reduce the latency on the atuation system.

Obstacle avoider

  ./obstacle_avoider

Controls the aceleration of the robot to avoid obstacles.

Interface Modules

Navigatorgui

  ./navigator_gui2 -map_path ../data/map_ida_guarapari-20170403

This will open a graphic display.

Place the simulated robot in the map by left-clicking on the "Place Robot" button, and then left-clicking once on the desired location on the map. Then move the cursor away from the blue dot that appears, in the direction you wish the robot to face. A blue line appears between the cursor (now two curved arrows) and the simulated robot. Click on go to start the simulation.

Procconttrol_gui

  ./proccontrol_gui

This GUI display all the modules running for this process:

Viewer 3D

  ./viewer_3D

This will open a 3D graphic interface where the car movement and sensors data are displayed.

Playback a recorded ride

Now, we will run a playback of a recorded ride so that we can see the car route and sensor data in real-time. To do this section you will need the log file called (NOME DO LOG) saved in a directory called ¨/dados/¨. The log file contains pose, gps and velodyne data from a especific run. The log files are oftenly used to generate new offline maps and to calibrate sensors.