Webot Simulation

Webot Simulation

How do i set up webots for the adeept car to simulate movement 

Create a project

Setting up Webots to simulate a 4-wheel drive (4WD) smart robot car—such as an Adeept-style platform—involves creating or importing the robot's physical structure, configuring its motor kinematics, and writing a Python controller script to drive movement.

Here is a step-by-step guide to getting your simulation up and running smoothly.

Create or Import the Robot Model (PROTO)

Webots relies on .proto files to define robot structures. Since exact third-party hobbyist kits like Adeept rarely come pre-packaged in standard simulator libraries, you have two primary approaches:

Using a pre-built model is by far the fastest and cleanest way to get a simulation running in Webots—especially for a 4-wheel drive robot, because all the wheel joints, sensors, and motors are already correctly wired up and calibrated.

Here is how to bring in a pre-built 4WD robot template and connect your Python controller to it:

Load a Pre-Built 4WD Robot

Clear your current workspace or delete the incomplete robot node.

Click the + (Add) button at the top of the Scene Tree.

In the Add Node window, look under Proto Nodes -> robots -> gctronic.

Select the e-puck (which is Webots' standard differential-drive mobile robot) and click Add.(Alternatively, if your Webots version includes other generic 4WD or differential robots under Proto Nodes, you can use those as well!)

When using Webots' built-in e-puck (or a standard differential-drive robot) as a stand-in model, the motor names differ slightly from custom multi-motor setups. The e-puck uses two primary wheel motors named "left wheel motor" and "right wheel motor".

Here is the complete Python controller script tailored specifically for the pre-built e-puck robot to drive forward and cross your bridge:

Python Controller Script for the e-puck

Create a new robot controller file in Webots (named e.g., adeept_custom_drive.py) and paste the following code:

from controller import Robot

# 1. Initialize the Robot instance

robot = Robot()

# Get the time step of the current world

TIME_STEP = int(robot.getBasicTimeStep())

# Initialize e-puck motor devices

left_motor = robot.getDevice("left wheel motor")

right_motor = robot.getDevice("right wheel motor")

# Set motors to velocity control mode (position = infinity)

left_motor.setPosition(float("inf"))

right_motor.setPosition(float("inf"))

# Set initial velocities to zero

left_motor.setVelocity(0.0)

right_motor.setVelocity(0.0)

def set_speed(left, right):

  left_motor.setVelocity(left)

  right_motor.setVelocity(right)

# 2. Define bridge crossing parameters

# Note: Max wheel speed for an e-puck is approximately 6.28 rad/s

CLIMB_SPEED = 6.28

BRIDGE_CROSSING_DURATION = 4.0  # seconds

start_time = robot.getTime()

has_crossed = False

# 3. Main Control Loop

while robot.step(TIME_STEP) != -1:

  current_time = robot.getTime()

  elapsed_time = current_time - start_time

  if not has_crossed:

    if elapsed_time < BRIDGE_CROSSING_DURATION:

      # Drive forward at maximum climbing speed

      set_speed(CLIMB_SPEED, CLIMB_SPEED)

    else:

      # Stop the robot after crossing the bridge

      set_speed(0.0, 0.0)

      has_crossed = True

      print("Bridge crossing complete. Stopping.")

  else:

    # Keep the robot stopped after finishing the run

    set_speed(0.0, 0.0)

Create the directory for the Webot controller

Create a directory in the controllers directory adeept_custom_drive

Save the python file adeept_custom_drive.py in the directory

Select It in Webots:

Go back into Webots.

Click on your robot's controller dropdown field again.

Because the folder now exists on your computer, adeept_custom_drive will now appear right there in the dropdown list for you to select!

in webot simulator want to have a robot adeept smartcar move 2 feet strait 

Change the code in the adeept_custom_drive.py

from controller import Robot

# Initialize the Robot

robot = Robot()

time_step = int(robot.getBasicTimeStep())

# Constants for conversion and geometry

# Adjust wheel_radius if your Adeept model uses different sized wheels (default ~3.25 cm / 0.0325m)

WHEEL_RADIUS = 0.0325 

TARGET_DISTANCE_METERS = 2.0 * 0.3048  # 2 feet in meters (~0.6096 m)

TARGET_RADIANS = TARGET_DISTANCE_METERS / WHEEL_RADIUS

# Initialize motors

motor_names = ['left_front_wheel', 'left_back_wheel', 'right_front_wheel', 'right_back_wheel']

motors = []

for name in motor_names:

    motor = robot.getDevice(name)

    motor.setPosition(float('inf'))  # Set to velocity control mode

    motor.setVelocity(0.0)

    motors.append(motor)

# Initialize position sensors (encoders) if available on your model

# If your model names differ, check your Scene Tree device names

left_sensor = robot.getDevice('left_front_wheel_sensor')

right_sensor = robot.getDevice('right_front_wheel_sensor')

left_sensor.enable(time_step)

right_sensor.enable(time_step)

# Set cruising speed (rad/s)

CRUISE_SPEED = 3.0

print(f"Driving straight for 2 feet ({TARGET_DISTANCE_METERS:.2f} meters)...")

# Start motors

for motor in motors:

    # Reverse sign on right/left depending on your motor orientation axis mapping

    if 'left' in motor.getName():

        motor.setVelocity(CRUISE_SPEED)

    else:

        motor.setVelocity(CRUISE_SPEED)

# Main control loop

while robot.step(time_step) != -1:

    current_left_rad = left_sensor.getValue()

    

    # Check if we have traveled far enough

    if current_left_rad >= TARGET_RADIANS:

        # Stop all motors

        for motor in motors:

            motor.setVelocity(0.0)

        print("Target distance reached. Stopping.")

        break