MR.CAP, or Multi-robot Joint Control and Planning for Object Transport, is a novel approach to solve simultaneous multi-robot control and planning problems. The algorithm is developed in C++, making use of factor graph inference and an innovative problem reduction to provide a robust, fast and scalable solution. Our approach outperforms state-of-the-art methods in terms of optimization time, scalability and robustness. The algorithm is tested in simulation and on a real robot system. The paper was accepted for publication in IEEE Control Systems Letters. See the website for more information.
Explore the docs »
Website
·
Report Bug
·
Request Feature
Table of Contents
This repository serves to provide the robotics community for a platform to test and develop the algorithm further, as well as to provide a platform for future research in the field of multi-robot control and planning. Our code is released as open source under the MIT license. We hope that this will help to accelerate the development of multi-robot systems and to provide a platform for future research in the field of multi-robot control and planning.
If you find this project useful, please give it a star! Thanks! If you use our code, please cite our paper:
@ARTICLE{10380779,
author={Jaafar, Hussein Ali and Kao, Cheng-Hao and Saeedi, Sajad},
journal={IEEE Control Systems Letters},
title={MR.CAP: Multi-Robot Joint Control and Planning for Object Transport},
year={2024},
volume={},
number={},
pages={1-1},
doi={10.1109/LCSYS.2024.3349989}}
- [
][https://gtsam.org/]
- [
][https://cmake.org/]
- [
][http://eigen.tuxfamily.org/]
- [
][https://www.boost.org/]
- [
][https://index.ros.org/doc/ros2/]
To setup the project locally, follow these simple steps. The demo will allow you to experiment with the algorithm and to test it on your own system.
First, ensure that you have installed GTSAM, and it's necessary prerequisites, as well as proper linking to the library. See GTSAM for more information.
First, navigate to a directory of your choice, and clone the GLEW and GTSAM repositories.
sudo apt-get install libglew-dev
sudo apt-get install libglfw3-dev
sudo apt install libxinerama-dev libxcursor-dev xinput libxi-dev
git clone https://github.com/glfw/glfw
cd glfw
cmake -G "Unix Makefiles"
make
sudo make install
cd ..
git clone https://github.com/borglab/gtsam.git
cd gtsam
git checkout 618ac28f2cc407e27e9eaf4e36ece64bc236b8e7
mkdir build && cd build
cmake -DGTSAM_ALLOW_DEPRECATED_SINCE_V42:=OFF .. # disable deprecated functionality for compatibility
make -j4 check # optional, run unit tests
sudo make install
echo 'export LD_LIBRARY_PATH=/usr/local/lib:${LD_LIBRARY_PATH}' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/local/share:${LD_LIBRARY_PATH}' >> ~/.bashrc
source ~/.bashrc
- Clone the repo
git clone https:://github.com/h2jaafar/mr.cap.git
- Build the project
cd mr.cap mkdir build && cd build cmake .. make
- Run the demo
./mrcap_demo
There are three ways to use the algorithm:
- Pure C++ simulation (i.e non-physics based)
- Gazebo simulation
- Real robot system
To use the pure C++ simulation, simply run the demo as described above. This will run the algorithm on a simulated system, and launch a GUI using ImGui and ImPlot to visualize the results.
There are several configurable parameters in the demo. These are:
- Number of robots
- Number of obstacles
- Number of steps
- Start and goal positions of the centroid
- Robot geometry
- Optimization parameters
- Covariance parameters
- Psuedo-disturbances (for testing)
as well as many more, found in
include/mrcap/MainWindow.h. We have tried to make as many of these parameters as possible configurable, to allow for easy experimentation, however, some of them may require some searching in the code to find.
Some images of the demo are shown below:
To use the Gazebo simulation, first install Gazebo and ROS2. I highly recommend using a custom ROS2 Gazebo world for multi-robot simulation I developed alongside this project. It can be found here. This will allow you to easily launch multiple robots in Gazebo, and to control them using ROS2.
Finally, to use the algorithm on real robot systems is simply a matter of sim2real. Simply remap the topics to the real robot topics, and you're good to go! See include/mrcap/ROSCommunications.h for details regarding the topics subscribed and published to.
In our experimentation, we published robot velocites to /B0n/cmd_vel where n is the robot number. We used a Vicon motion capture system to obtain robot positions, and subscribe to the /vicon/B0n/B0n topics. You can simply substitute this with your localization stack of choice.
- Pure C++ simulation
- Gazebo simulation
- Real robot system
- Configuration files
- Unit tests
See the open issues for a full list of proposed features (and known issues).
Contributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make are greatly appreciated.
If you have a suggestion that would make this better, please fork the repo and create a pull request. You can also simply open an issue with the tag "enhancement". Don't forget to give the project a star! Thanks again!
- Fork the Project
- Create your Feature Branch (
git checkout -b feature/AmazingFeature) - Commit your Changes (
git commit -m 'Add some AmazingFeature') - Push to the Branch (
git push origin feature/AmazingFeature) - Open a Pull Request
Distributed under the MIT License. See LICENSE.txt for more information.
Hussein Ali Jaafar - husseinali.jaafar@torontomu.ca
Project Link: https://github.com/h2jaafar/mr.cap
Major thanks to my co-authors and supervisors for their help and support in this project. This project would not have been possible without them. Specifically Howard (Cheng-Hao) for the late nights helping debug.
GTSAM and the GTSAM team for their amazing library and support.
And of course, ROS and ROS2 for their amazing libraries and support.