Dein erstes Programm

Dein erstes Programm lässt den Roboter vorwärtsfahren und hält ihn vor einer Wand an. Es ist kurz, enthält aber alles, was jedes Programm braucht.

Python

from controller import Robot

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

# Get the devices of the starter robot by name
leftWheel = robot.getDevice("left wheel motor")
rightWheel = robot.getDevice("right wheel motor")
frontDist = robot.getDevice("frontDist")

# Sensors must be enabled before use
frontDist.enable(timeStep)

# Let the wheels turn without limit, and start driving forward
leftWheel.setPosition(float("inf"))
rightWheel.setPosition(float("inf"))
leftWheel.setVelocity(3.0)
rightWheel.setVelocity(3.0)

# The main loop: each step, the simulation advances by timeStep milliseconds
while robot.step(timeStep) != -1:
    distance = frontDist.getValue()
    print("Distance to the wall in front:", round(distance, 3), "m")

    if distance < 0.05:  # Closer than 5 cm: stop
        leftWheel.setVelocity(0)
        rightWheel.setVelocity(0)
        print("Wall reached!")
        break

C/C++

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

using namespace webots;
using namespace std;

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

  // Get the devices of the starter robot by name
  Motor *leftWheel = robot->getMotor("left wheel motor");
  Motor *rightWheel = robot->getMotor("right wheel motor");
  DistanceSensor *frontDist = robot->getDistanceSensor("frontDist");

  // Sensors must be enabled before use
  frontDist->enable(timeStep);

  // Let the wheels turn without limit, and start driving forward
  leftWheel->setPosition(INFINITY);
  rightWheel->setPosition(INFINITY);
  leftWheel->setVelocity(3.0);
  rightWheel->setVelocity(3.0);

  // The main loop: each step, the simulation advances by timeStep milliseconds
  while (robot->step(timeStep) != -1) {
    double distance = frontDist->getValue();
    cout << "Distance to the wall in front: " << distance << " m" << endl;

    if (distance < 0.05) { // Closer than 5 cm: stop
      leftWheel->setVelocity(0);
      rightWheel->setVelocity(0);
      cout << "Wall reached!" << endl;
      break;
    }
  }

  delete robot;
  return 0;
}

So funktioniert es

1. Den Roboter erzeugen. Robot() verbindet dein Programm mit dem Roboter im Simulator.
2. Den Zeitschritt holen. Die Simulation läuft in Schritten von wenigen Millisekunden. getBasicTimeStep() liefert den Schritt der Welt.
3. Die Geräte holen. Jeder Motor und jeder Sensor wird über seinen Namen gefunden. Das sind die Namen, die du ihnen gegeben hast, als du deinen Roboter gebaut hast.
4. Die Sensoren aktivieren. Ein Sensor liefert keine Werte, bis er aktiviert ist. Der Zeitschritt sagt ihm, wie oft er sich aktualisieren soll.
5. Schleife. robot.step(timeStep) lässt die Simulation einen Schritt weiterlaufen und gibt -1 zurück, wenn die Simulation endet. Alles, was dein Roboter tut, passiert in dieser Schleife.

Ausführen

1. Speichere das Programm als hello.py.
2. Öffne game/worlds/mapping_example_1.wbt und lade den Starter-Roboter mit dem rechten LOAD-Button.
3. Lade hello.py mit dem linken LOAD-Button und drücke auf Start.

Der Roboter fährt vorwärts, und die Webots-Konsole zeigt die Entfernung zur Wand vor ihm an, bis der Roboter anhält. Wenn du stattdessen einen Fehler siehst, sieh unter Fehlerbehebung nach.

Tipp

Verwende print, um zu verstehen, was dein Roboter tut. Es ist das einfachste und nützlichste Werkzeug, um Probleme zu finden.

Probier es aus

• Ändere die Geschwindigkeit von 3.0 auf 6.0. Was passiert in der Nähe der Wand?
• Lass den Roboter bei 10 cm statt bei 5 cm anhalten.
• Gib zusätzlich die Zeit mit robot.getTime() aus.

Als Nächstes lernst du unter Bewegung, zu fahren und zu drehen.