Gerakan

Robot punya dua roda, masing-masing dengan motornya sendiri: left wheel motor dan right wheel motor pada robot pemula. Kamu menggerakkannya dengan mengatur kecepatan setiap roda:

Roda kiri	Roda kanan	Robotnya…
Maju	Maju	Melaju maju
Mundur	Mundur	Melaju mundur
Mundur	Maju	Berputar ke kiri
Maju	Mundur	Berputar ke kanan
Cepat	Lambat	Berbelok melengkung ke kanan

Kecepatan dinyatakan dalam radian per detik, hingga 6,28 (satu putaran roda per detik). Kecepatan negatif memutar roda ke belakang.

Melaju

1. Ambil setiap motor berdasarkan namanya.
2. Atur posisinya ke tak hingga, agar motor berputar tanpa batas.
3. Atur kecepatannya.

Motor mempertahankan kecepatan terakhir yang kamu atur, jadi robot tetap bergerak sementara programmu melakukan hal lain. Program ini membuat robot maju, mundur, dan berputar ke kiri, masing-masing selama satu detik:

Python

from controller import Robot

robot = Robot()
timeStep = int(robot.getBasicTimeStep())
maxSpeed = 6.28  # The maximum speed of the wheels, in radians per second

leftWheel = robot.getDevice("left wheel motor")
rightWheel = robot.getDevice("right wheel motor")
leftWheel.setPosition(float("inf"))
rightWheel.setPosition(float("inf"))

def drive(left, right, seconds):
    # Set the speed of each wheel, and keep it for some time
    leftWheel.setVelocity(left)
    rightWheel.setVelocity(right)
    start = robot.getTime()
    while robot.step(timeStep) != -1:
        if robot.getTime() - start >= seconds:
            break

drive(maxSpeed, maxSpeed, 1.0)    # Forward
drive(-maxSpeed, -maxSpeed, 1.0)  # Backward
drive(-2.0, 2.0, 1.0)             # Spin to the left
drive(0, 0, 0.1)                  # Stop
print("Done")

C/C++

#include <iostream>
#include <cmath>
#include <webots/Robot.hpp>
#include <webots/Motor.hpp>

using namespace webots;

Robot *robot;
Motor *leftWheel, *rightWheel;
int timeStep;
const double maxSpeed = 6.28; // The maximum speed of the wheels, in radians per second

// Set the speed of each wheel, and keep it for some time
void drive(double left, double right, double seconds) {
  leftWheel->setVelocity(left);
  rightWheel->setVelocity(right);
  double start = robot->getTime();
  while (robot->step(timeStep) != -1) {
    if (robot->getTime() - start >= seconds)
      break;
  }
}

int main() {
  robot = new Robot();
  timeStep = (int)robot->getBasicTimeStep();

  leftWheel = robot->getMotor("left wheel motor");
  rightWheel = robot->getMotor("right wheel motor");
  leftWheel->setPosition(INFINITY);
  rightWheel->setPosition(INFINITY);

  drive(maxSpeed, maxSpeed, 1.0);   // Forward
  drive(-maxSpeed, -maxSpeed, 1.0); // Backward
  drive(-2.0, 2.0, 1.0);            // Spin to the left
  drive(0, 0, 0.1);                 // Stop
  std::cout << "Done" << std::endl;

  delete robot;
  return 0;
}

Catatan

Sudut di Webots dinyatakan dalam radian. Untuk mengonversi: radian = derajat × π / 180.

Mengukur seberapa jauh roda berputar

Setiap motor punya sensor posisi, yang juga disebut encoder, yang menghitung seberapa jauh roda sudah berputar, dalam radian. Sensor ini berguna untuk melaju sejauh jarak tertentu. Berputar mundur membuat hitungannya berkurang.

Python

from controller import Robot

robot = Robot()
timeStep = int(robot.getBasicTimeStep())

leftWheel = robot.getDevice("left wheel motor")
rightWheel = robot.getDevice("right wheel motor")
leftWheel.setPosition(float("inf"))
rightWheel.setPosition(float("inf"))

# Each wheel has a position sensor, which counts how far it has turned
leftEncoder = leftWheel.getPositionSensor()
rightEncoder = rightWheel.getPositionSensor()
leftEncoder.enable(timeStep)
rightEncoder.enable(timeStep)

robot.step(timeStep)  # Step once, so that the sensors have a value
start = leftEncoder.getValue()

leftWheel.setVelocity(5.0)
rightWheel.setVelocity(5.0)

while robot.step(timeStep) != -1:
    turned = leftEncoder.getValue() - start
    if turned > 10.0:  # Stop after 10 radians
        break

leftWheel.setVelocity(0)
rightWheel.setVelocity(0)
print("Left wheel:", round(leftEncoder.getValue() - start, 2), "rad")

C/C++

#include <iostream>
#include <cmath>
#include <webots/Robot.hpp>
#include <webots/Motor.hpp>
#include <webots/PositionSensor.hpp>

using namespace webots;
using namespace std;

int main() {
  Robot *robot = new Robot();
  int timeStep = (int)robot->getBasicTimeStep();

  Motor *leftWheel = robot->getMotor("left wheel motor");
  Motor *rightWheel = robot->getMotor("right wheel motor");
  leftWheel->setPosition(INFINITY);
  rightWheel->setPosition(INFINITY);

  // Each wheel has a position sensor, which counts how far it has turned
  PositionSensor *leftEncoder = leftWheel->getPositionSensor();
  PositionSensor *rightEncoder = rightWheel->getPositionSensor();
  leftEncoder->enable(timeStep);
  rightEncoder->enable(timeStep);

  robot->step(timeStep); // Step once, so that the sensors have a value
  double start = leftEncoder->getValue();

  leftWheel->setVelocity(5.0);
  rightWheel->setVelocity(5.0);

  while (robot->step(timeStep) != -1) {
    double turned = leftEncoder->getValue() - start;
    if (turned > 10.0) // Stop after 10 radians
      break;
  }

  leftWheel->setVelocity(0);
  rightWheel->setVelocity(0);
  cout << "Left wheel: " << leftEncoder->getValue() - start << " rad" << endl;

  delete robot;
  return 0;
}

Mengendalikan gerakan berdasarkan waktu itu mudah, tetapi hasilnya berubah tergantung kecepatan. Encoder mengukur gerakannya secara langsung, jadi lebih andal. Untuk belokan yang presisi, giroskop lebih baik lagi.

Selanjutnya, pelajari cara membaca sensor.