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
$ sudo apt-get install ros-kinetic-map-server
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...
- 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 ..
$ make
$ sudo make install
$ sudo ldconfig
(feel free to remove the ACADOtoolkit tree now)
$ cd ~/catkin_ws
$ catkin_make
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
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:
export GAZEBO_MODEL_PATH=/home/<your_user_name>/catkin_ws/src/navigation_oru/gazebo_oru/gazebo_models_oru/models:$GAZEBO_MODEL_PATH
This is needed in order to be able to load the different environments (otherwise you get "no namespace found" messages and an empty world).
$ roslaunch orunav_launch single_truck.launch
This should bring up the gazebo simulation GUI and RViz.
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.
$ 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).
.
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.
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.
$ roslaunch coordination_oru_ros newRobotLab.launch
$ rosrun orunav_spatial_deviate pub_goal _BPparam:=$(rospack find orunav_spatial_deviate)/BPDatabase --fileName1 path11.txt --fileName2 path22.txt
Here BPparam is the path to the Database. The last pose (goal pose) of fileName1 is read from the Database folder. It is then published at robot1/goal. Similarly for robot2, the end pose is read from fileName2. In the Database folder pathXX.txt is initial/unmodified path of robotX whereas pathXY.txt is path of robotX spatially adjusted wrt robotY
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.