My Experience using Webots

Webots: Robot Simulator

Webots is an open source robot simulator that provides a complete development environment to model, program and simulate robots. Thousands of institutions worldwide use it for R&D and teaching. Webots has been codeveloped by the Swiss Federal Institute of Technology in Lausanne, thoroughly tested, well documented and continuously maintained since 1996. It is the most efficient solution to quickly get professional results. [Reference]

What Can I Do with Webots?

• Develop custom robots or using available robot
• Develop custom 3D environment (ground, obstacle, object, sky, physics behavior)
• Create your robots logic
• Simulate and testing
• Record or Screenshot your simulation

Webots Research Area

• Many mobile robotics projects have relied on Webots for years in the following areas:
• Mobile robot prototyping (academic research, the automotive industry, aeronautics, the vacuum cleaner industry, the toy industry, hobbyists, etc.)
• Robot locomotion research (legged, humanoids, quadrupeds robots, etc.)
• Multi-agent research (swarm intelligence, collaborative mobile robots groups, etc.)
• Adaptive behavior research (genetic algorithm, neural networks, AI, etc.).
• Teaching robotics (robotics lectures, C/C++/Java/Python programming lectures, etc.)
• Robot contests (e.g. Robotstadium or Rat’s Life)

Webots Simulation

• A Webots simulation is composed of following items:
• A Webots world file (.wbt) that defines one or several robots and their environment.
• The .wbt file does sometimes depend on external PROTO files (.proto) and textures.
• One or several controller programs for the above robots (in C/C++/Java/Python/MATLAB).
• An optional physics plugin that can be used to modify Webots regular physics behavior (in C/C++)

Available robots

• Webots have many kinds of available robot, for example:
• e-puck (two-wheeled robot)
• Parallax Boe-Bot (three-wheeled robot)
• Four-wheeled robot
• Hexapod robot
• Robotics armSmall size car-like robot
• Humanoid robot
• Dog-like robot

Programming Language

Webots User Interface

• 3D window that displays and allows you to interact with the 3D simulation
• Scene tree which is a hierarchical representation of the current world
• Text editor that allows you to edit source code, and finally
• Console that displays both compilation and controller outputs.

User Guide

e-puck Robot

Simple Tutorial

1. Create Project Directory

1. Click “Wizards” menu then click “New Project Directory” submenu
2. Click “Next”
3. Choose directory for your new project, then click “Next”
4. Choose a name for the new world (here I name it “main.wbt”), and check the features you want (here I check the “Center view point”, “Add a textured background”, “Add a directional light”, and “Add a rectangle arena”. Then click “Next”
5. Finally click “Finish”

2. Add e-puck Robot

1. Add rectangle obstacle.
   Select the last node “E-puck” of the scene tree view. Click on the Add button (plus sign) at the top of the scene tree view. In the dialog box, choose “PROTO nodes (Webots) / objects / factory / containers / WoodenBox (solid)”, then click “Add”. Then Double-click on the “WoodenBox” node in the scene tree. This should open the node and display its fields. Select the “size” field and set its “x” value to -0.2, “y” value to 0.1, and “z” value to -0.1. Select the “translation” field and set its “x” value to 0, “y” value to 0.05, and “z” value to -0.2.
2. Add tube obstacle.
   Select the last node “E-puck” of the scene tree view. Click on the Add button (plus sign) at the top of the scene tree view. In the dialog box, choose “PROTO nodes (Webots) / objects / obstacles / OilBarrel (Solid)”, then click “Add”. Then Double-click on the “OilBarrel” node in the scene tree. This should open the node and display its fields. Select the “radius” field and set it value to -0.05. Select the “height” field and set it value to 0.1 Select the “translation” field and set its “x” value to 0.2, “y” value to 0.05, and “z” value to -0.2.

1. Click “Wizards” menu then click “New Robot Controller” submenu
2. Click “Next”
3. Choose the language for your controller program. Here I use C language. Then click “Next”
4. Specify a name for the controller name. Here I name it “e-puck-move_forward”. Then click next.
5. Finally click “Finish”

/*
 * Copyright 2019 Albert Alfrianta
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * 
 * 
 * Created on: 2019-09-16, Bogor, Indonesia
 * 
 * Contact: albert.brucelee@gmail.com or https://www.linkedin.com/in/albert-alfrianta/
 * 
 * Description:
 * 	Simple e-puck robot program to make the robot move forward
 * 	Written in C programming language
 * 
 */


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <webots/device.h>
#include <webots/distance_sensor.h>
#include <webots/led.h>
#include <webots/motor.h>
#include <webots/nodes.h>
#include <webots/robot.h>

int time_step;

/* Motor device */
static WbDeviceTag left_motor, right_motor;

/* E-puck angular speed in rad/s */
#define MAX_SPEED 6.28

/* function to get simulator time step */
static int get_time_step() {
  static int time_step = -1;
  if (time_step == -1)
    time_step = (int)wb_robot_get_basic_time_step();
  return time_step;
}


/* function to set motor velocity to move forward */
static void move_forward() {
  wb_motor_set_velocity(left_motor, MAX_SPEED);
  wb_motor_set_velocity(right_motor, MAX_SPEED);
}

/* function to init robot stuff */
static void init_robot() {
  // get simulator time step
  time_step = get_time_step();
	
  // get a handler to the motors and set target position to infinity (speed control)
  left_motor = wb_robot_get_device("left wheel motor");
  right_motor = wb_robot_get_device("right wheel 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);
}

/* main function */
int main(int argc, char **argv) {
  /* necessary to initialize webots stuff */
  wb_robot_init();

  init_robot();

  /* main loop
   * Perform simulation steps of TIME_STEP milliseconds
   * and leave the loop when the simulation is over
   */
  while (wb_robot_step(time_step) != -1) {
    /*
     * move the robot forward
     * */
    move_forward();
  };

  /* Enter your cleanup code here */

  /* This is necessary to cleanup webots resources */
  wb_robot_cleanup();

  return EXIT_SUCCESS;
}

• wb_robot_get_basic_time_step()
  Webots have simulator time step. The basic time step is the time step increment used by Webots to advance the virtual time and perform physics simulation [reference].
• wb_robot_step(time_step) 
  This command is to perform simulation steps. This needed for the controller time step. The controller time step is the time increment of time executed at each iteration of the control loop of a controller. We must call this to synchronize our program and the simulator condition. It will return -1 if the simulation is stopped. If we not call this command, the robot will do nothing. For example the wb_motor_set_velocity(left_motor, MAX_SPEED) only set the motor speed value. So we need to call and looping the wb_robot_step(time_step) command to make the robot move.

1. First we initialize the robot, and the necessary stuff like get handler to the motors.
2. Then we make the robot move forward using the while loop. 
3. When the while loop exit, we cleanup the webots resources. 
   Note: in this program we run an infinite while loop, so the wb_robot_cleanup is never reached.

Download this Project

Going Further

Next Tutorial