Déplacement

Le robot a deux roues, chacune avec son propre moteur : left wheel motor et right wheel motor sur le robot de départ. Vous le pilotez en réglant la vitesse de chaque roue :

Roue gauche	Roue droite	Le robot…
En avant	En avant	Avance
En arrière	En arrière	Recule
En arrière	En avant	Pivote vers la gauche
En avant	En arrière	Pivote vers la droite
Rapide	Lente	Tourne en courbe vers la droite

Les vitesses sont en radians par seconde, jusqu’à 6,28 (un tour de roue par seconde). Les vitesses négatives font tourner la roue en arrière.

Avancer

1. Obtenez chaque moteur grâce à son nom.
2. Réglez sa position sur l’infini, pour qu’il tourne sans limite.
3. Réglez sa vitesse.

Les moteurs gardent la dernière vitesse réglée : le robot continue donc de bouger pendant que votre programme fait autre chose. Ce programme avance, recule, puis pivote vers la gauche, pendant une seconde chacun :

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

Note

Dans Webots, les angles sont en radians. Pour convertir : radians = degrés × π / 180.

Mesurer de combien une roue a tourné

Chaque moteur a un capteur de position, aussi appelé encodeur, qui compte de combien la roue a tourné, en radians. C’est utile pour parcourir une distance précise. Tourner en arrière fait diminuer le compteur.

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

Piloter un mouvement à la durée est simple, mais le résultat varie avec la vitesse. Les encodeurs mesurent le mouvement lui-même : ils sont donc plus fiables. Pour des virages précis, le gyroscope est encore meilleur.

Ensuite, apprenez à lire les capteurs.