VisibleSim: A Behavioral Modular Robotic Simulation Framework

 

VisibleSim is a framework for creating behavioral simulators for distributed lattice-based modular robotic systems in a regular 3D environment.

Physics simulation is not the purpose of VisibleSim, instead, its aim is to provide the tools for studying the behavior of such systems, through the simulation of the interactions between the robotic modules and their environment (neighbor detection, motions within the lattice, user interactions, etc.), or between the modules themselves (communication between modules through message passing).

Each module in the system is assigned a unique identifier, and executes the same controller as all other modules, generating communication or environmental events that are handled deterministically by VisibleSim's discrete-event scheduler. This allows for accurate simulations of complex algorithms on robotic ensembles up to millions of modules in size on a single computer.

VisibleSim is powered by discrete-event simulation, which means that it relies by a scheduler that executes a sequence of discrete actions over time scheduled at fixed dates. Each event represents an action on the simulated world and potentially causes new events to be scheduled at a later date. It is assumed that all changes in the simulated world and modules are caused by the processing of an event and thus the entire simulation can be reduced to an ordered sequence of events. A simulation always start with the startup of the simulated modules, which kick starts the simulation by scheduling subsequent events, and ends when all events have been processed, at which point new events cannot be scheduled again.  

Features

Supported Modular Robots

VisibleSim supports modules in all kinds of lattices and with diverse motion capabilities, embedded sensors, and actuators. A brief summary of the currently supported robotic models is shown below.

Module Controllers: BlockCodes

Each module executes the same distributed program, acting as the controller of the module. This program is named a BlockCode in VisibleSim lingo.

BlockCodes are C++ programs that describe what actions should be carried out by the module upon initialization, and in response to various internal or external events (communication received, neighborhood updates, end of motion, timer, etc...).   

Therefore, a BlockCode essentially consists in:

  • startup function run by each module upon startup, that initializes internal variables and usually sends a message to neighbor modules.
  • Event handlers, that run a function associated to the particular type of the processed event, that updates the internal state of the modules and carries out any necessary action. 
  • Message handlers, that run a function associated to the particular type of the received message, that updates internal variables and carries out any necessary action such as forwarding the message to neighbors.

Please refer to Resources section below for additional information on creating your own application using VisibleSim BlockCodes.

Screenshots

Resources

Download

VisibleSim is available as open-source software under AGPLv3 license on a Github repository at the following link: https://github.com/VisibleSim/VisibleSim

Please refer to the README.md file of the repository for additional usage information.
 

A compressed archive of the latest version of the simulator can be downloaded at https://github.com/VisibleSim/VisibleSim/releases, or using git:

git clone https://github.com/VisibleSim/VisibleSim.git
 

Or download directly from this website (might not be the latest version):

Documentation

An online documentation is available at the following link: http://ceram.pu-pm.univ-fcomte.fr:5015/visiblesim/doc/

Interactive BlockCode Template Generator 

An online tool for generating customizable application templates for any supported module types is available at: http://ceram.pu-pm.univ-fcomte.fr:5015/visiblesim/doc/codeblock.php

A Reference Simulation Framework for Programmable Matter Research

VisibleSim has been our dedicated programmable matter simulation tool for almost a decade. Over the years, it has been used to experiment and validate work on various modular robotic architectures and models, with many results appearing in published research. Some of this work is referenced below, ordered by robotic models.

Smartblocks

[1] Dhoutaut, Dominique, Benoit Piranda, and Julien Bourgeois. “Efficient Simulation of Distributed Sensing and Control Environments.” In Green Computing and Communications (GreenCom), 2013 IEEE and Internet of Things (IThings/CPSCom), IEEE International Conference on and IEEE Cyber, Physical and Social Computing, 452–59. IEEE, 2013. https://doi.org/10.1109/GreenCom-iThings-CPSCom.2013.93.

[2] Piranda, Benoît, Guillaume J. Laurent, Julien Bourgeois, Cédric Clévy, Sebastian Möbes, and Nadine Le Fort-Piat. “A New Concept of Planar Self-Reconfigurable Modular Robot for Conveying Microparts.” Mechatronics 23, no. 7 (October 2013): 906–15. https://doi.org/10.1016/j.mechatronics.2013.08.009.

[3] El-Baz, D., B. Piranda, and J. Bourgeois. “A Distributed Algorithm for a Reconfigurable Modular Surface.” In 2014 IEEE International Parallel Distributed Processing Symposium Workshops, 1591–98, 2014.

[4] Piranda, Benoit, and Julien Bourgeois. “A Distributed Algorithm for Reconfiguration of Lattice-Based Modular Self-Reconfigurable Robots.” In 24th Euromicro International Conference on Parallel, Distributed, and Network-Based Processing (PDP), 1–9. IEEE, 2016. https://doi.org/10.1109/PDP.2016.40.

Blinky Blocks

[5] Naz, Andre, Benoit Piranda, Seth Copen Goldstein, and Julien Bourgeois. “ABC-Center: Approximate-Center Election in Modular Robots.” In 2015 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), 2951–57. Hamburg, Germany: IEEE, 2015. https://doi.org/10.1109/IROS.2015.7353784.

[6] Naz, Andre, Benoit Piranda, Seth Copen Goldstein, and Julien Bourgeois. “A Time Synchronization Protocol for Modular Robots.” In 2016 24th Euromicro International Conference on Parallel, Distributed, and Network-Based Processing (PDP), 109–18. Heraklion: IEEE, 2016. https://doi.org/10.1109/PDP.2016.73.

[7] Naz, André, Benoit Piranda, Seth Copen Goldstein, and Julien Bourgeois. “Approximate-Centroid Election In Large-Scale Distributed Embedded Systems.” In AINA 2016, 30th IEEE Int. Conf. on Advanced Information Networking and Applications, 548–556. Crans-Montana, Switzerland: IEEE, 2016.

[8] Naz, André, Benoit Piranda, Seth Copen Goldstein, and Julien Bourgeois. “Electing an Approximate Center in a Huge Modular Robot with the K-BFS SumSweep Algorithm.” In IROS 2018, IEEE/RSJ Int. Conf. on Intelligent Robots and Systems, 4825–4832. Madrid, Spain, 2018.

2D Catoms

[9] Naz, André, Benoît Piranda, Julien Bourgeois, and Seth Copen Goldstein. “A Distributed Self-Reconfiguration Algorithm for Cylindrical Lattice-Based Modular Robots.” In Network Computing and Applications (NCA), 2016 IEEE 15th International Symposium On, 254–263. IEEE, 2016. http://ieeexplore.ieee.org/abstract/document/7778628/.

[10] Naz, André, Benoit Piranda, Thadeu Tucci, Seth Copen Goldstein, and Julien Bourgeois. “Network Characterization of Lattice-Based Modular Robots with Neighbor-to-Neighbor Communications.” In 2016 13th International Symposium on Distributed Autonomous Robotic Systems (DARS), 415–429. London, UK: Springer, 2016.

3D Catoms

[11] Piranda, Benoit, and Julien Bourgeois. “Geometrical Study of a Quasi-Spherical Module for Building Programmable Matter.” In DARS 2016, 13th International Symposium on Distributed Autonomous Robotic Systems, 2016. https://www.researchgate.net/profile/Benoit_Piranda/publication/307930970_Geometrical_study_of_a_quasi-spherical_modules_for_building_programmable_matter/links/582438d308ae7ea5be7233a7.pdf.

[12] Tucci, Thadeu, Benoît Piranda, and Julien Bourgeois. “Efficient Scene Encoding for Programmable Matter Self-Reconfiguration Algorithms.” In Proceedings of the Symposium on Applied Computing, 256–261, 2017. https://doi.org/10.1145/3019612.3019706.

[13] Tucci, Thadeu, Benoit Piranda, and Julien Bourgeois. “A Distributed Self-Assembly Planning Algorithm for Modular Robots.” In International Conference on Autonomous Agents and Multiagent Systems) (AAMAS ), 550–58. Stockholm, Sweden: Association for Computing Machinery (ACM), 2018.

[14] Pescher, Florian, Benoıt Piranda, Stephane Delalande, and Julien Bourgeois. “Molding a Shape-Memory Polymer with Programmable Matter.” In DARS 2018, 14th International Symposium on Distributed Autonomous Robotic Systems, 13, 2018.

[15] Piranda, Benoit, and Julien Bourgeois. “Designing a Quasi-Spherical Module for a Huge Modular Robot to Create Programmable Matter.” Autonomous Robots 42, no. 8 (December 2018): 1619–1633. https://doi.org/10.1007/s10514-018-9710-0.

[16] Thalamy, Pierre, Benoît Piranda, and Julien Bourgeois. “Distributed Self-Reconfiguration Using a Deterministic Autonomous Scaffolding Structure.” In Proceedings of the 19th International Conference on Autonomous Agents and MultiAgent Systems, 140–48. Montreal QC, Canada, 2019. https://doi.org/10.5555/3306127.3331685.

[17] Thalamy, P., B. Piranda, F. Lassabe, and J. Bourgeois. “Scaffold-Based Asynchronous Distributed Self-Reconfiguration By Continuous Module Flow.” In 2019 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), 4840–46, 2019. https://doi.org/10.1109/IROS40897.2019.8967775.

[18] Thalamy, Pierre, Benoît Piranda, and Julien Bourgeois. “A Survey of Autonomous Self-Reconfiguration Methods for Robot-Based Programmable Matter.” Robotics and Autonomous Systems 120 (October 2019): 103242. https://doi.org/10.1016/j.robot.2019.07.012.

[19] Pescher, Florian, Nils Napp, Benoît Piranda, and Julien Bourgeois. “GAPCoD: A Generic Assembly Planner by Constrained Disassembly.” In Proceedings of the 20th International Conference on Autonomous Agents and MultiAgent Systems. Auckland, New Zealand, 2020.