Dynamic-Fleet-Management

DFM: A swarm robotics platform that incorporates multi-agent collision avoidance and path-planning capabilities to lead multiple robots to their goal positions in a shared obstacle-ridden environment

Project Overview

We present DFM (Dynamic Fleet Management), a multi-robot swarm management platform. This project would give a set of robots the ability to autonomously navigate themselves to their respective goal positions while avoiding collisions with nearby agents.

DFM works using an RVO 2-based centralized path planner that gives ideal velocities based on specified goal positions and other agents' positions. It does so by using the Reciprocal Collision Avoidance Algorithm, using which it receives a high level of performance.

This project contains a demonstration to run a Gazebo simulation where four Turtlebot3 Waffle Pi robots reach their goal positions by solving a deadlocked state (where the motion of each robot depedns on the motion of other robots leading to an infitely stationary period). The video showing a run of this demonstration is attached (embedded) below. A direct link to the same can also be found here.

About the Authors

The authors of DFM are Vikram Setty and Vinay Lanka, both robotics graduate students at the University of Maryland.

Vikram is from Hyderabad, India, and has done his bachelor's and master's degrees with a major in mechanical engineering and a minor in computer science from IIT Ropar. His research interests include perception, navigation, and path planning for robotics and autonomous systems. He is also interested in various areas in artificial intelligence and machine learning, especially computer vision and reinforcement learning.

Vinay is from Hyderabad, India, and has done his bachelor's degree majoring in Electronics and Communication Engineering from VIT Vellore. He has two years of work experience in Robotics, having worked as a Robotics Engineer in Newspace Research and Technologies (Defence Aerospace) and as an R&D Engineer in Neoflux. He's interested in the areas of perception and planning of robots and also shares the common interest of Deep Learning and Computer Vision, especially in the field of Robotics.

AIP Workflow Used

This project was developed using the Agile Development Process (AIP) along with pair programming (with a driver and navigator), with a focus on test-driven development (TDD). This sheet has the product backlog, iteration backlogs, and work log for each task done to develop DFM. The end of each iteration is even tagged to distinguish each sprint. Further, the link to the sprint planning and review meeting notes devised to overview each iteration sprint to develop DFM in the most efficient way possible is attached here.

The latest (Phase 2) developed UML class and activity diagrams can be found in the UML/revised directory. Earlier made UMLs can be founf in the UML/initial directory. Further, the proposal for this project can be found in the proposal directory.

A short video providing a brief overview of the project and the details explaining the AIP process used is embedded below. A direct link to the same can also be found here.

Dependencies

RVO2

The main dependency for using DFM is RVO 2 - an algorithm for interactive navigation and planning of large numbers of agents in two-dimensional (crowded) environments. At runtime, each agent senses the environment independently and computes a collision-free motion based on the optimal reciprocal collision avoidance (ORCA) formulation. Our algorithm ensures that each agent exhibits no oscillatory behaviors.

The user specifies static obstacles, agents, and the preferred velocities of the agents. The simulation is performed step-by-step via a simple call to the library. The simulation is fully accessible and manipulable during runtime.

A link to the library can be found here.

Building the code

Run the commands listed below to build the package and libraries.

rm -rf build/ install/
colcon build 
source install/setup.bash

Building for Unit and Integration Tests

Further, run these commands to build for running the unit tests and integration tests.

rm -rf build/ install/
colcon build --cmake-args -DCOVERAGE=1 

Running the Demo

To run the demo example of four Turtlebot 3 Waffle Pis solving a deadlock, run the commands below to spawn the robots in Gazebo.

source install/setup.bash
ros2 launch dynamic_fleet_management gazebo.launch.py 

In another terminal tab/window, run the following to start the solver node and simulation.

source install/setup.bash
ros2 run dynamic_fleet_management robot_commander 

Running the Unit and Integration Tests

Execute the following commands to run the previosuly built unit and integration tests.

source install/setup.bash
colcon test

Generating Coverage Reports After Running Colcon Test

To obtain the coverage reports (first make sure to have run the unit test already), execute the comands listed below.

colcon test

Getting the Test Coverage Report for dynamic_fleet_management:

To get the test coverage for the ROS 2 package, dynamic_fleet_management, run the commands listed below.

ros2 run dynamic_fleet_management generate_coverage_report.bash
open build/dynamic_fleet_management/test_coverage/index.html

Getting the Test Coverage Report for swarm_control:

To get the same coverage report as last time, however for the library swarm_control, run the commands below.

colcon build \
       --event-handlers console_cohesion+ \
       --packages-select swarm_control \
       --cmake-target "test_coverage" \
       --cmake-arg -DUNIT_TEST_ALREADY_RAN=1
open build/swarm_control/test_coverage/index.html

Generating the Combined Test Coverage Report

To obtain the combined test coverage report for the package and library, execute the following in the project's package directory.

./do-tests.bash

Generating the Project Documentation

To get the documentation for the project, run the commands below in the project's package directory.

./do-docs.bash

Google Coding Style Verification

To check how the written code conforms to the Google C++ style guide, look at the results/cpplint_output.txt file to see the output on using the cpplint tool on this project. You should not be able to see any issues or problems, with all the files processed successfully.

This can be self-verified as well by running the following command in the highest-level directory of the project.

# Install cpplint(ignore if already installed):
  sudo apt install cpplint
# Navigate to the 'src' directory
  cd src/
# Self-check Google code style conformity using Cpplint:
  cpplint --filter=-build/c++11,+build/c++17,-build/namespaces,-build/include_order swarm_control/src/*.cpp swarm_control/include/*hpp dynamic_fleet_management/src/*.cpp

On running the above command, you should see the same output in the results/cpplint_output.txt file.

Static Code Analysis

To check the static code analysis of this project, check the results/cppcheck_output.txt file to see the output on using the cppcheck tool. You should not be able to see any issues or problems, with all the files checked successfully.

This can be self-verified as well by running the following command in the highest-level directory of the project.

# Install cppcheck (ignore if already installed):
  sudo apt install cppcheck
# Navigate to the 'src' directory
  cd src/
# Self-check the static code analysis using Cppcheck:
  cppcheck --enable=all --std=c++11 --std=c++17 --enable=information --check-config --suppress=missingInclude --suppress=*:*test*/ --suppress=unmatchedSuppression $( find . -name *.cpp | grep -vE -e "^./build/")

On running the above command, you should see the same output in the results/cppcheck_output.txt file.