Bewegung

Der Roboter hat zwei Räder, jedes mit eigenem Motor: left wheel motor und right wheel motor beim Starter-Roboter. Du steuerst ihn, indem du die Geschwindigkeit jedes Rads einstellst:

Linkes Rad	Rechtes Rad	Der Roboter …
Vorwärts	Vorwärts	fährt vorwärts
Rückwärts	Rückwärts	fährt rückwärts
Rückwärts	Vorwärts	dreht sich auf der Stelle nach links
Vorwärts	Rückwärts	dreht sich auf der Stelle nach rechts
Schnell	Langsam	fährt eine Rechtskurve

Geschwindigkeiten werden in Radiant pro Sekunde angegeben, bis zu 6,28 (eine Radumdrehung pro Sekunde). Negative Geschwindigkeiten drehen das Rad rückwärts.

Fahren

1. Hol jeden Motor über seinen Namen.
2. Setze seine Position auf unendlich, damit er sich ohne Begrenzung dreht.
3. Stelle seine Geschwindigkeit ein.

Die Motoren behalten die zuletzt eingestellte Geschwindigkeit, also fährt der Roboter weiter, während dein Programm andere Dinge erledigt. Dieses Programm fährt jeweils eine Sekunde lang vorwärts, rückwärts und dreht sich nach links:

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;
}

Hinweis

Winkel werden in Webots in Radiant angegeben. Zur Umrechnung: Radiant = Grad × π / 180.

Messen, wie weit sich ein Rad gedreht hat

Jeder Motor hat einen Positionssensor, auch Encoder genannt, der zählt, wie weit sich das Rad gedreht hat, in Radiant. Das ist nützlich, um eine feste Strecke zu fahren. Dreht sich das Rad rückwärts, wird der Wert kleiner.

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;
}

Eine Bewegung nach Zeit zu steuern ist einfach, aber das Ergebnis ändert sich mit der Geschwindigkeit. Encoder messen die Bewegung selbst und sind daher zuverlässiger. Für präzise Drehungen ist das Gyroskop noch besser.

Als Nächstes lernst du, die Sensoren auszulesen.