Developer(s) | Cyberbotics Ltd. |
---|---|
Stable release | Webots R2023a / November 29th, 2022 |
Repository | GitHub |
Operating system | Windows, Linux, macOS |
Type | Robotics simulator |
License | Apache 2 |
Website | Cyberbotics Web page |
Webots is a free and open-source 3D robot simulator used in industry, education and research.
The Webots project started in 1996, initially developed by Dr. Olivier Michel at the Swiss Federal Institute of Technology (EPFL) in Lausanne, Switzerland and then from 1998 by Cyberbotics Ltd. as a proprietary licensed software. Since December 2018, it is released under the free and open-source Apache 2 license. [1]
Webots includes a large collection of freely modifiable models of robots, sensors, actuators and objects. In addition, it is also possible to build new models from scratch or import them from 3D CAD software. When designing a robot model, the user specifies both the graphical and the physical properties of the objects. The graphical properties include the shape, dimensions, position and orientation, colors, and texture of the object. The physical properties include the mass, friction factor, as well as the spring and damping constants. Simple fluid dynamics is present in the software.
Webots uses a fork of the ODE (Open Dynamics Engine) for detecting of collisions and simulating rigid body dynamics. The ODE library allows one to accurately simulate physical properties of objects such as velocity, inertia and friction.
Webots includes a set of sensors and actuators frequently used in robotic experiments, e.g. lidars, radars, proximity sensors, light sensors, touch sensors, GPS, accelerometers, cameras, emitters and receivers, servo motors (rotational & linear), position and force sensor, LEDs, grippers, gyros, compass, IMU, etc.
The robot controller programs can be written outside of Webots in C, C++, Python, ROS, Java and MATLAB using a simple API.
Webots offers the possibility to take screenshots and record simulations. Webots worlds are stored in cross-platform *.wbt files whose format is based on the VRML language. One can also import and export Webots worlds and objects in the VRML format. Users can interact with a running simulation by moving robots and other objects with the mouse. Webots can also stream a simulation on web browsers using WebGL.
Since August 18, 2017, the robotbenchmark.net website has offered free access to a series of robotics benchmarks based on Webots simulations through the Webots web interface. Webots instances are running in the cloud and the 3D views are displayed in the user browser. From this web interface, users can program robots in Python and learn robot control in a step-by-step procedure.
This is a simple example of C/C++ controller programming with Webots: a trivial collision avoidance behavior. Initially, the robot runs forwards, then when an obstacle is detected it rotates around itself for a while and then resumes the forward motion.
#include<webots/robot.h>#include<webots/motor.h>#include<webots/distance_sensor.h>#define TIME_STEP 64intmain(){// initialize Webotswb_robot_init();// get handle and enable distance sensorWbDeviceTagds=wb_robot_get_device("ds");wb_distance_sensor_enable(ds,TIME_STEP);// get handle and initialize the motorsWbDeviceTagleft_motor=wb_robot_get_device("left_motor");WbDeviceTagright_motor=wb_robot_get_device("right_motor");wb_motor_set_position(left_motor,INFINITY);wb_motor_set_position(right_motor,INFINITY);wb_motor_set_velocity(left_motor,0.0);wb_motor_set_velocity(right_motor,0.0);// control loopwhile(1){// read sensorsdoublev=wb_distance_sensor_get_value(ds);// if obstacle detectedif(v>512){// turn aroundwb_motor_set_velocity(left_motor,-600);wb_motor_set_velocity(right_motor,600);}else{// go straightwb_motor_set_velocity(left_motor,600);wb_motor_set_velocity(right_motor,600);}// run a simulation stepwb_robot_step(TIME_STEP);}wb_robot_cleanup();return0;}
A complete and up-to-date list is provided in the Webots user guide.
A pointing device is a human interface device that allows a user to input spatial data to a computer. CAD systems and graphical user interfaces (GUI) allow the user to control and provide data to the computer using physical gestures by moving a hand-held mouse or similar device across the surface of the physical desktop and activating switches on the mouse. Movements of the pointing device are echoed on the screen by movements of the pointer and other visual changes. Common gestures are point and click and drag and drop.
A game controller, gaming controller, or simply controller, is an input device used with video games or entertainment systems to provide input to a video game, typically to control an object or character in the game. Before the seventh generation of video game consoles, plugging in a controller into one of a console's controller ports was the primary means of using a game controller, although since then they have been replaced by wireless controllers, which do not require controller ports on the console but are battery-powered. USB game controllers could also be connected to a computer with a USB port. Input devices that have been classified as game controllers include keyboards, mouses, gamepads, joysticks, etc. Special purpose devices, such as steering wheels for driving games and light guns for shooting games, are also game controllers.
In navigation, dead reckoning is the process of calculating current position of some moving object by using a previously determined position, or fix, and then incorporating estimates of speed, heading direction, and course over elapsed time. The corresponding term in biology, used to describe the processes by which animals update their estimates of position or heading, is path integration.
Numerical control is the automated control of machining tools by means of a computer. A CNC machine processes a piece of material to meet specifications by following coded programmed instructions and without a manual operator directly controlling the machining operation.
A servomotor is a rotary actuator or linear actuator that allows for precise control of angular or linear position, velocity and acceleration. It consists of a suitable motor coupled to a sensor for position feedback. It also requires a relatively sophisticated controller, often a dedicated module designed specifically for use with servomotors.
A robot kit is a special construction kit for building robots, especially autonomous mobile robots.
Lego Mindstorms NXT is a programmable robotics kit released by Lego on August 2, 2006. It replaced the first-generation Lego Mindstorms kit, which was called the Robotics Invention System. The base kit ships in two versions: the Retail Version and the Education Base Set. It comes with the NXT-G programming software, or optionally LabVIEW for Lego Mindstorms. A variety of unofficial languages exist, such as NXC, NBC, leJOS NXJ, and RobotC. The second generation of the set, the Lego Mindstorms NXT 2.0, was released on August 1, 2009, featuring a color sensor and other upgraded capabilities. The third generation, the EV3, was released in September 2013.
Robotics is the branch of technology that deals with the design, construction, operation, structural disposition, manufacture and application of robots. Robotics is related to the sciences of electronics, engineering, mechanics, and software. The word "robot" was introduced to the public by Czech writer Karel Čapek in his play R.U.R., published in 1920. The term "robotics" was coined by Isaac Asimov in his 1941 science fiction short-story "Liar!"
Navisworks is a 3D design review package for Microsoft Windows.
The Player Project is a project to create free software for research into robotics and sensor systems. Its components include the Player network server and the Stage robot platform simulators. Although accurate statistics are hard to obtain, Player is one of the most popular open-source robot interfaces in research and post-secondary education. Most of the major intelligent robotics journals and conferences regularly publish papers featuring real and simulated robot experiments using Player and Stage.
Urbi is an open-source cross-platform software platform in C++ used to develop applications for robotics and complex systems. Urbi is based on the UObject distributed C++ component architecture. It also includes the urbiscript orchestration language which is a parallel and event-driven script language. UObject components can be plugged into urbiscript and appear as native objects that can be scripted to specify their interactions and data exchanges. UObjects can be linked to the urbiscript interpreter, or executed as autonomous processes in "remote" mode.
The e-puck is a small (7 cm) differential wheeled mobile robot. It was originally designed for micro-engineering education by Michael Bonani and Francesco Mondada at the ASL laboratory of Prof. Roland Siegwart at EPFL. The e-puck is open hardware and its onboard software is open-source, and is built and sold by several companies.
A robotics simulator is a simulator used to create application for a physical robot without depending on the actual machine, thus saving cost and time. In some case, these applications can be transferred onto the physical robot without modifications.
Nao is an autonomous, programmable humanoid robot formerly developed by Aldebaran Robotics, a French robotics company headquartered in Paris, which was acquired by SoftBank Group in 2015 and rebranded as SoftBank Robotics. The robot's development began with the launch of Project Nao in 2004. On 15 August 2007, Nao replaced Sony's robot dog Aibo as the robot used in the RoboCup Standard Platform League (SPL), an international robot soccer competition. The Nao was used in RoboCup 2008 and 2009, and the NaoV3R was chosen as the platform for the SPL at RoboCup 2010.
anyKode Marilou is a modeling and simulation environment for mobile robots, humanoids, articulated arms and parallel robots operating in real-world conditions that respect the laws of physics. This robotics suite is used in research centers and industry for various projects like humanoid architectures, wheeled and multi legged vehicles, and multi-robot systems (Multi-agents).
Robotics is an interdisciplinary branch of computer science and engineering. Robotics involves design, construction, operation, and use of robots. The goal of robotics is to design machines that can help and assist humans. Robotics integrates fields of mechanical engineering, electrical engineering, information engineering, mechatronics, electronics, bioengineering, computer engineering, control engineering, software engineering, mathematics, etc.
The following outline is provided as an overview of and topical guide to robotics:
The AIBO ERS-7 is an entertainment robot created for the commercial market. Initially released in 2003, it was the first AIBO installment to be explicitly referred to as a dog and saw adoption in both research and popular culture. It was the last robot developed before the dissolution of Sony's robotics division in 2006 and the eventual release of the ERS-1000 in 2018.
Asynchronous multi-body framework (AMBF) is an open-source 3D versatile simulator for robots developed in April 2019. This multi-body framework provides a real-time dynamic simulation of multi-bodies such as robots, free bodies, and multi-link puzzles, paired with real-time haptic interaction with various input devices. The framework integrates a real surgeon master console, haptic or not, to control simulated robots in real-time. This feature results in the simulator being used in real-time training applications for surgical and non-surgical tasks. It offers the possibility to interact with soft bodies to simulate surgical tasks where tissues are subject to deformations. It also provides a Python Client to interact easily with the simulated bodies and train neural networks on real-time data with in-loop simulation. It includes a wide range of robots, grippers, sensors, puzzles, and soft bodies. Each simulated object is represented as an afObject; likewise, the simulation world is represented as an afWorld. Both utilize two communication interfaces: state and command. Through the State command, the object can send data outside the simulation environment, while the Command allows to apply commands to the underlying afObject.