navigation_oru (orunav) navigation stack
This contains a brief guide how to install / run some examples of the ROS-based software tools NAVIGATION_ORU developed at ORU in a set of previous and on-going projects (SAUNA, SAVIE, ILIAD and Semantic Robot).
The tools require full ROS installation and one external packages (ACADO). The installation assumes you have Ubuntu 16.04 LTS [ROS Kinetic] or Ubntu 14.04 LTS [ROS Indigo].
Please refer to http://wiki.ros.org/kinetic/Installation/Ubuntu
Install map server
$ sudo apt-get install ros-kinetic-map-server
Get the navigation_oru source tree:
Download the navigation_oru source tree into your catkin workspace (here we assume ~/catkin_ws):
$ cd ~/catkin_ws/src
$ git clone https://github.com/OrebroUniversity/navigation_oru-release.git navigation_oru
Do not compile yet... please follow the instructions below first...
Install external dependencies:
- ACADO Toolkit (used for the orunav_path_smoother)
You need to build this package from source.
$ git clone https://github.com/acado/acado.git -b stable ACADOtoolkit
$ cd ACADOtoolkit
$ mkdir build
$ cd build
$ cmake ..
$ sudo make install
$ sudo ldconfig
(feel free to remove the ACADOtoolkit tree now)
Compile the orunav source tree
$ cd ~/catkin_ws
NOTE: the default build type is in DEBUG mode - some packages as the constraint extractor work way faster if they are built in RELEASE mode. Change the build into RELEASE mode by:
$ catkin_make -DCMAKE_BUILD_TYPE=Release
Gazebo simulation environment
NOTE: this should now be encoded directly into the devel/setup.bash script.
Update the GAZEBO_MODEL_PATH variable, add the following to your ~/.bashrc file:
This is needed in order to be able to load the different environments (otherwise you get "no namespace found" messages and an empty world).
A set of examples
A single truck - basement environment of AASS
$ roslaunch orunav_launch single_truck.launch
In order to navigate to a pose in the environment, select the "2D Nav Goal" button on the task bar in RViz and point/click in the map where the vehicle should drive. First orunav_motion_planner (a lattice-based motion planner) generates an initial path (green) which then are optimized using orunav_path_smoother which then are executed automatically by the orunav_mpc tracking controller. This is how it typically should look like.
A set of three trucks - empty environment
$ roslaunch orunav_launch multiple_trucks.launch
This will bring up the gazebo simulation GUI and RViz. There we have an empty environment with three trucks.
Similar to the single truck example you can utilize the task bar to select where each truck should drive. Note that the coordination is not running here, check out https://github.com/FedericoPecora/coordination_oru if you want coordination as well. To set which truck should go where use one of the "2D Nav Goal" buttons (there are three of them, the first will trigger the first vehicle, the second the second vehicle and so on). .
Pallet picking from an semi-known pose
This is based on some old stuff that haven't been used for a while and is not really robust in the current state. The idea here is to pickup a pallet at a semi-known pose. To bring up the simulation / visualization run:
$ roslaunch orunav_launch click_n_pick.launch
Two goal target poses is loaded from a file, one which is the approximate pickup location and the other is the drop of location. To send the pickup command run:
$ rosservice call /robot1/next_task
...and to leave the pallet call the same service again:
$ rosservice call /robot1/next_task
The alignment of the pallets is done using a sdf based tracker - due to the camera mounting the images are up-side down in the visualization.
Description of packages
In alphabetic order.
Meta package containing plugins, vehicle models, worlds etc.
Meta package for the whole stack.
Given an occupancy map, the geometry of the vehicle, and a vehicle pose, this package computes a collision free region (area and heading interval). This is used in the orunav_path_smoother package to optimize the path.
Package to handle the conversion between generic messages and types. Note that some conversions of more specific types is defined in the package defining the type.
This provides an coordinator instance which have the same interface as the real coordinator but doesn't do any coordination. This return the fastest trajectory for all vehicles.
Package with debugging tools. There is a tool to plot the behavior of the controller, see test/README.txt in the package.
Provides an interface to operating the forklifts. This interface is used for driving the trucks in gazebo and the real CitiTrucks.
A set of generic types and interfaces, such as pose, path, trajectory etc. Contains also various of utilities function and also ways to do serialization (saving / loading).
2D geometry, mainly polygon intersection etc. for computing vehicles footprints.
Contains a set of example launch files.
Lattice based motion planner, will provide a relative fast way of computing kinetically feasible motion between discretized poses.
Tracking controller using model predictive control. Handles apart from the trajectory also constraints on poses along the path.
Package for all specialized messaged used.
Generic tools that are useful when writing nodes to handle a set of targets / missions.
Package using signed distance function to estimate poses of euro pallets.
Package that contains a set of parameters for the system.
Path planning using a set of predefined paths.
Path smoothing functionality that takes an existing motion, for example, from the orunav_motion_planner, and minimize the amount of required driving and turning.
Rosbag processing tools, contains an odometry meter.
Functions to display various of generic types (orunav_generic) to rviz. Note that some rviz message generation for specific types are located in the package where they are defined.
Given a path and acceleration, max velocity, etc. constraints compute a speed profile for the path.
Package that acts as an interface to the tracking controller (orunav_mpc) and the coordinator. Contains the interface to compute task (e.g. how drive to this location) and execute task.
The publication that to the highest degree explains the navigation_oru stack (most suitable citing) is:
H. Andreasson, J. Saarinen, M. Cirillo, T. Stoyanov and A. Lilienthal, “Fast, continuous state path smoothing to improve navigation accuracy”, ICRA 2015 link.