Votre premier programme

Votre premier programme fait avancer le robot, et l’arrête devant un mur. Il est court, mais il contient tout ce dont chaque programme a besoin.

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

Comment ça marche

1. Créer le robot. Robot() connecte votre programme au robot dans le simulateur.
2. Obtenir le pas de temps. La simulation avance par pas de quelques millisecondes. getBasicTimeStep() donne le pas du monde.
3. Obtenir les composants. Chaque moteur et chaque capteur est retrouvé grâce à son nom. Ce sont les noms que vous leur avez donnés en construisant votre robot.
4. Activer les capteurs. Un capteur ne donne aucune valeur tant qu’il n’est pas activé. Le pas de temps lui indique à quelle fréquence se mettre à jour.
5. Boucler. robot.step(timeStep) fait avancer la simulation d’un pas, et renvoie -1 quand la simulation se termine. Tout ce que fait votre robot se passe dans cette boucle.

L’exécuter

1. Enregistrez le programme sous le nom hello.py.
2. Ouvrez game/worlds/mapping_example_1.wbt, et chargez le robot de départ avec le bouton LOAD de droite.
3. Chargez hello.py avec le bouton LOAD de gauche, et appuyez sur démarrer.

Le robot avance, et la console de Webots affiche la distance jusqu’au mur devant lui jusqu’à ce que le robot s’arrête. Si une erreur s’affiche à la place, consultez Dépannage.

Astuce

Utilisez print pour comprendre ce que fait votre robot. C’est l’outil le plus simple et le plus utile pour trouver les problèmes.

À vous de jouer

• Changez la vitesse de 3.0 à 6.0. Que se passe-t-il près du mur ?
• Faites s’arrêter le robot à 10 cm au lieu de 5 cm.
• Affichez aussi le temps avec robot.getTime().

Ensuite, apprenez à avancer et à tourner dans Déplacement.