1. Webots
Webots, developed by Cyberbotics Company
[24][1], is an open-source simulation platform, which can simulate three-dimensional agents (models). This platform is highly compatible with the mainstream operation systems, such as Windows, Linux, MAC OS. It can support C, C++, Java, Python, MATLAB and other programming languages
[41][2]. The simulation of a
unmanned aerial vehicles (UAV
s) in a jungle by Webots is shown in
Figure 1.
Figure 1.
Simulation of a UAV by Webots.
Webots includes a variety of built-in agents (models) such as wheeled robots, underwater robots, UAVs, pedestrians, humanoid robots, and bionic robots. These agents can be easily customized by developers with enriched attributes such as shape, material, and color. Additionally, developers can create their own models by using other tools. For instance, Webots can import files in VRML97 format, which can be produced using SolidWork
[42][3]. Developers also can easily obtain the parameters of the agents, such as motor speed, accelerometer, camera screen, and other such parameters of the robot, via its interface. Webots also includes a range of sensors that are commonly used in robots, such as distance sensors, cameras, gyroscopes, and LIDARs. Moreover, Webots is capable of supporting the Robot Operating System (ROS)
[22][4], an open-source framework that assists researchers and developers in creating and reusing code across various robotics applications. Additionally, Webots allows for the simulation of physical properties such as gravity, illumination, density, and friction coefficients. To simulate collision and dynamics, Webots uses an open-source physical simulation engine known as the Open Dynamics Engine (ODE). This engine facilitates the simulation of rigid body dynamics and collision systems, bringing the simulations closer to realism and greatly enhancing their reliability
[43][5].
In addition to its reliable updates and maintenance, Webots has a thriving community and official technical support. The platform is widely used for simulation and control of UAV, offering numerous examples and tutorials for UAV simulation, as well as support for popular open-source flight control systems such as ArduPilot
[44][6]. There is also an abundance of open-source tutorials available to developers who wish to learn from them. Because of its rich functionality and diverse development environments, more than two hundred universities and research centers use this platform to test applications and algorithms
[45][7]. For example, it can be utilized to evaluate the performance and reliability of UAVs swarm algorithms, such as obstacle avoidance algorithms
[46][8].
2. Gazebo
Gazebo, developed by Dr. Andrew Howard from the University of Southern California in 2002
[25][9], is a widely used open-source simulation platform in scientific research and engineering, particularly due to its close integration with ROS. Typically, it is used in conjunction with ROS, as Gazebo-ROS
[47][10], to simulate complex robot systems, especially robot swarms
[48][11].
Gazebo is compatible with Windows, Mac OS, Ubuntu, and other Linux distributions. It supports applications and algorithms developed in C, C++, and Python. Gazebo also offers a range of physical simulation engines, including ODE, Bullet
[49][12], Simbody
[21][13], and Dynamic Animation and Robotics Toolkit (DART)
[50][14]. This enables the platform to simulate physical properties such as friction, gravity, and lighting
[51][15]. Additionally, Gazebo can provide high-quality lighting and texture simulations by using its use of the Object-Oriented Graphics Rendering Engine (OGRE).
Figure 2 illustrates the main interface and a simulation example of Gazebo.
Figure 2.
The main interface and a simulation example of Gazebo.
Gazebo comes with various built-in robot models, mainly wheeled and flying robots such as TurtleBot, PR2, and iRobot Create. The default model is relatively simple but suitable for complex validation calculations
[23][16]. With ROS integration, this platform supports motion path planning. Sensors such as laser radar, monocular, stereo, RGB-D, and infrared sensors can also be simulated. Developers can customize plug-ins for robots and sensors using plug-in functions, including GUI, system, sensor, world, model, and visual. The sensor plug-in is used to model laser radar and infrared sensors. Additionally, the internal data of Gazebo can be directly accessed by its application program interface (API). Gazebo also offers cloud simulation, enabling developers to run projects on an online server
[52][17].
The user operability of Gazebo is relatively poor. It can be difficult to install, and has a high threshold for users
[17][18]. Built-in models are accessed online instead of locally, resulting in longer loading times or failure to load when the internet is unstable. Moreover, the built-in models are not well classified, making it difficult for users to locate the desired models quickly. Developers cannot edit models using this platform; they need to use 3D modeling software (such as Blender, SketchUp) and learn an XML-based SDF specification
[52][17]. However, Gazebo can support for mainstream open-source flight control systems, such as PX4 and ArduPilot, which are widely used on real UAVs, has attracted researchers to evaluate the performance and reliability of UAV control algorithms, such as UAVs swarm validation and visual target tracking
[53,54][19][20].
In short, the advantage of Gazebo is its close connection with the ROS, which maximizes the use of advantages of ROS. Additionally, its built-in models are accessible online, providing developers with unrestricted access. However, the downside is that poor network connectivity can make it difficult for developers to connect to the server and load the models.
3. CoppeliaSim
CoppeliaSim is a powerful simulation platform for robots, formerly known as V-rep
[26][21]. It supports ODE, Bullet, Vortex, and Newton physics engines, allowing for the simulation of dynamic scenarios such as collisions, rolling, gravity, and other physical factors
[55,56][22][23]. Other than that, this platform is able to simulate dynamic particles such as jet engines, water jets, and propellers
[57][24]. Its distributed architecture allows for scene object association or an unlimited number of scripts
[58][25], and it supports applications or algorithms developed using C, C++, Python, Java, LUA, Matlab, or Octave. The conventional API is written in C or LUA. CoppeliaSim is highly portable, performs well on Windows, Mac OS, and Linux systems, and has kinematics solver and data visualization functions
[56,59][23][26].
CoppeliaSim offers a variety of built-in agent models, such as biped, wheeled, bionic, flying, hexapod, and others. The user-friendly interface (
Figure 3) allows developers to easily select appropriate models. Additionally, the platform supports importing models in mainstream formats such as URDF, COLLADA, DXF, OBJ, STL, and glTF. There are six options for developing applications or algorithms, including embedded script, plugin, add-on, ROS node, remote API, and node talking TCP/IP. CoppeliaSim also provides various sensors for detecting distances, visuals, and pressures. Each type of sensor has different variants; for instance, proximity sensor includes ray-type, randomized ray-type, pyramid-type, cylinder-type, disk-type, and cone-type; vision sensors are divided into orthogonal projection-type and perspective projection-type
[60,61][27][28]. These sensors can meet the needs of most developers. Furthermore, this platform has rich development resources such as a large number of tutorials, API documents for developers, and an official forum. It is still frequently updated and released, making it a great tool for developers working with robotics simulations.
Figure 3.
The main interface and a simulation example of CoppeliaSim.
To put it simply, this platform offers a rich selection of built-in models that can fulfill most simulation requirements. It also provides various UAV models, including multi-copter UAVs, with high realism and flexibility, enabling users to simulate different UAV behaviors and motion modes. To enhance UAV behavior simulation, CoppeliaSim allows users to incorporate different sensors such as cameras, LIDAR, GPS, and inertial navigation systems that provide perception and navigation capabilities to help UAVs perform tasks better. With the powerful physics engine, users can simulate various physical effects and model UAV behavior more realistically. In simulations of UAVs swarm, communication and coordination between UAVs are crucial. This platform enables users to set communication protocols and frequencies between UAVs, simulating information exchange and collaborative actions. On the basis of network simulation, researchers can better understand and study UAVs swarm behavior. Many researchers currently use this platform to simulate and verify UAVs swarm algorithms such as entrapping multiple targets
[62][29], formation control
[63][30], and collaborative transportation
[64][31]. However, due to the high accuracy and precision of the built-in models, they may not be suitable for simulating large numbers of swarms
[23][16].
4. ARGoS
ARGoS is a simulation platform developed by the European Union as part of the Swarmanoid project. It is designed to support large-scale robot simulations, and provides a flexible and modular architecture that enables researchers to experiment with a wide range of algorithms and scenarios. ARGoS integrates several engines, including ODE-based 3D dynamics engine, 3D particle engine, Chipmunk-based 2D dynamics engine, and 2D dynamics engine
[27][32]. It also comes with a built-in LUA script editor that allows researchers to easily create and modify simulation scenarios. While ARGoS lacks a scene editor, its modular architecture and built-in scripting capabilities enable researchers to customize and manipulate the simulation environment through custom scripts. The platform supports Ubuntu/Kubuntu, OpenSuse, and Mac OS, but does not currently support Windows
[65][33].
Figure 4 illustrates the main interface of this platform and a simulation example based on it.
Figure 4.
The main interface and a simulation example of by ARGoS.
The most significant feature of ARGoS is its ability to divide the simulation space into independent subspaces, and each is controlled by a separate physics engine. This enables concurrent execution of multiple simulations, resulting in significant reductions in processing time
[27][32]. Additionally, the platform has a multi-threaded structure that includes master and slave threads. The master thread assigns the task of updating a single plug-in, such as a sensor, actuator, or physics engine, to the slave thread, which effectively employs multi-core processors to significantly improve computing performance, particularly for multi-robot or swarm simulations. ARGoS can support the simulation of thousands of robots simultaneously, saving 40% of time compared to the two-dimensional dynamic verification of 10,000 robots
[27][32].
The robot library comprised ARGoS relatively limited and includes only a few simple models such as e-puck, eye-bot, Kilobot, marXbot, and spiri robots. These robots can be programmed using LUA script or C++, but mesh importing is not supported, and the object representation is encoded with OpenGL
[66][34]. While ARGoS does provide an official technical support forum and manuals for developers, the update frequency is not very high, and the development tutorial resources are not extensive.
In summary, ARGoS is a powerful simulation platform that is particularly well-suited for simulating robot swarms, especially when large numbers of robot models need to be generated and involved. It has been widely adopted for simulating swarm foraging robots due to its ability to simulate large-scale swarms of robots quickly
[67][35]. This feature is also applicable to simulating UAVs swarms, where ARGoS is better suited for simulating large-scale swarms of UAVs compared to high-precision simulation of individual UAVs. However, ARGoS still has room for improvement. Its robot library needs to be enriched, and its poor cross-platform performance cannot be ignored. Additionally, 3D mesh models are currently not supported, which limits its use in certain applications. Despite these limitations, nonetheless, ARGoS remains a valuable tool for researchers in swarm robotics and related fields.
5. MRDS
The full name of MRDS is Microsoft Robotics Developer Studio, which is a 3D robot simulation platform designed and developed by Microsoft
[28][36].
Figure 5 shows an outdoor scene simulated by MRDS. In addition to CPU, MRDS can also leverage other independent floating-point processors such as GPU and PPU for computation, making it capable of completing intensive computing-based simulations
[68][37]. The platform is based on Physx Engine, which is commonly used on various simulation platforms for modeling rigid bodies and liquids
[35,69,70][38][39][40].
Figure 5.
An outdoor scene simulated by MRDS.
MRDS can only be used on the Windows operating system, and the applications or algorithms for MRDS can be developed by VPL, C#, Visual Basic, Jscript, or Python
[41][2]. Although MRDS is not an open-source platform, it can be used free of charge for non-commercial purposes. It uses decentralized software services (DSS) and concurrency and coordination runtime (CRR) to improve the performance of multi-line programming capabilities and to reuse the multi-core capabilities of processors
[71][41]. This means that each service component can operate independently without synchronizing, allowing visual and acoustic services to be delivered independently without interruption. Even if one of the sensors fails, other functions will continue to operate normally. Unfortunately, this platform only provides limited robot models, such as iRobot, Lego NXT, and MobileRobotics, and it cannot support path planning
[72][42]. The tutorials and development resources for MRDS are also very limited. Furthermore, the platform has not been updated for a long time, and its maintenance is becoming more and more difficult.
To be brief, the Physx Engine integrated into MRDS provides significant advantages to this platform, particularly in simulating harsh environments, such as sand. Additionally, the decentralized framework enhances its robustness and fault tolerance; even if one sensor fails, other robot functions can continue to operate normally. Users can leverage the Visual Simulation Environment (VSE) tool in MRDS to create and modify UAV models to suit their needs. Within VSE, users can design and adjust the physical entities, sensors, behaviors, and more of the UAV before controlling them with MRDS services. However, the platform has shortcomings such as limited built-in models, variable cross-platform performance, and maintenance challenges.
6. MORSE
MORSE (Modular Open Robots Simulation Engine) is a simulation platform developed based on Blender engine
[21][13], which offers a realistic graphics environment that can be used for testing and evaluating robots without any further modifications in real-life scenarios
[73][43]. The simulation engine utilizes the Bullet library to define physical properties such as object shapes, mass, friction, boundary collision, and other physical factors. This platform provides three types of robot components, namely, sensors, actuators, and robots. Robots carry two components: sensors and actuators. The former is used for data collection, while the latter is responsible for executing instructions. In addition, there are three components related to environment interaction, including scenes, middlewares, and modifiers. Scenes are simulated environments such as buildings, indoor environments, and jungles. Middlewares are responsible for binding sensors and actuators. As the data generated by sensors in simulation do not contain any noise, the modifier is used to simulate the noise data to achieve an effect that is much closer to the real environment.
MORSE can be deployed on Linux, Windows, and Mac OS, but with a better support for Linux. This platform generates simulation scenes using a set of Python classes called Builder API, which provides a special internal language called domain-specific language (DSL)
[74][44]. This allows developers to use Python to configure MORSE, even if they are not familiar with Blender. The built-in models contain agents such as iRobot ATRV unmanned ground vehicle (UGV) and Yamaha RMAX UAV, which can be enriched by importing Collada, DXF, 3DS Max, VRML, and other formats. MORSE also has built-in sensors such as cameras, gyroscopes, GPS, accelerometers, thermometers, and lasers
[73][43], making it suitable for simulating realistic graphics. MORSE has unique advantages in human-computer interaction and UAVs attitude simulation. It provides UAV models such as multi-copter UAV in the model library. Users can define parameters such as the number of UAVs, their positions, sensors, controllers, etc. by editing Python scripts. The platform also provides a variety of simulation scenarios, such as the outdoor (environment), which meets the needs of UAV simulation, and users can also model the environment based on it. Researchers use MORSE to simulate UAVs, such as multi-UAV communication
[75][45] and path planning
[76,77][46][47]. The simulation of an UAVs swarm using MORSE is shown in
Figure 6.
Figure 6.
An UAVs swarm simulated by MORSE.
Unfortunately, the lack of updates since 2016 and limited community resources and development tutorials make it challenging for developers to use MORSE effectively. Furthermore, the absence of a graphical user interface and the requirement for developers to be familiar with command line tools and the Blender engine can be a barrier to entry for beginners. Additionally, MORSE lacks built-in algorithms such as path planning, which can make it challenging for developers to use it for more complex projects. Overall, while MORSE is not a good choice for entry-level developers due to its technical requirements and limited support resources.
7. USARSim
USARSim is a simulation platform developed by the National Institute of Standards and Technology in the USA for researching rescue robots and intelligence agents
[29][48]. The platform is based on the Unreal Engine 2.0 developed by Epic Games
[78][49], which provides high-quality 3D rendering capabilities using the PhysX physics engine. Applications and algorithms can be developed using C, C++, Java
[41][2], or the built-in Unreal Script language. Control codes are developed using the GameBot interface, which is a communication interface exclusive to the phantom engine. USARSim is compatible with Windows, Linux, and Mac OS. An example of USARSim simulating UAVs can be seen in
Figure 7.
Figure 7.
Simulation of UAVs by USARSim.
The Mobility Open Architecture Simulation and Tools (MOAST) framework of USARSim offers a range of hierarchical and modular controllers, interfaces, and tools that provide motion generation, world modeling, and sensor information processing
[79][50]. In addition, USARSim includes two controllers, Pyro and Player
[80][51]. Pyro is a controller for AI exploration and robot development, which includes Python libraries, environments, a GUI, and drivers. Player is a robot service that can control the robot and sensors, such as touch sensors, lasers, and acoustics, in the simulation environment. Users can easily and fully control the controller and actuator carried by a robot using Player.
USARSim supports eight types of ground robots, including P2AT, P2DX, ATRV-Jr, Zerg, Tarantula, Talon, Telemax, and Soryu; four types of vehicles, namely, Hummer, Sedan, SnowStorm, and Cooper; two bipedal robots, QRIO and ERS, a helicopter, and a submarine. As USARSim is developed by using Unreal Engine 2.0, it has high-quality 3D capabilities. Furthermore, it supports multiple types of UAVs, including multi-copter UAV, as well as different sensors and controllers. It provides predefined scenarios such as buildings, earthquake zones, and tunnels, while also allowing users to create custom scenarios. Users can write their algorithms to control the UAV. Although USARSim was primarily designed for search and rescue missions, it has also been used by many researchers for UAV simulation, such as obstacle avoidance and navigation
[81,82][52][53]. However, the robot library is limited, and similar to MRDS, this platform has not been updated or maintained, resulting in poor support for new types of robots and sensors. While there are some official communities and manuals, community activity is weak, and tutorials are inadequate
[21][13].