Doc URBI

L'UObject Wheel décrit un périphérique roue et contient les attributs suivants :

wheel = new Wheel("Left");

wheel.reset();

L'UObject Led décrit un périphérique led et contient les attributs suivants :

ledA = new Led(1);

L'UObject Micro décrit un périphérique microphone et contient les attributs suivants :

mic = new Micro("Back");

L'UObject Selector décrit le petit switch selector sur le dessus du robot et contient les attributs suivants :

sel = new Selector();

L'UObject IR décrit les 8 périphériques infrarouges et contient les attributs suivants :

infraRed = new IR();

L'UObject IR décrit les 3 périphériques accéléromètres et contient les attributs suivants :

acc = new Acceleromter();

L'UObject Camera décrit le périphérique caméra et contient les attributs suivants :

c = new Camera();

L'UObject Colormap quand il est lié au périphérique camera fournit un détecteur de taches de base et contient les attributs suivants :

c = new Colormap("camera.val", 0, 255, 120, 190, 150, 230, 0.1););

L'UObject Speaker décrit le périphérique haut-parleur, vous autorisant à utiliser :

Speaker.play("wow");

Speaker.stop();

L'UObject Command est conçu pour vous permettre d'utiliser des commandes spéciales :

Command.reset();

Command.stop();

Command.version();

Command.calibrate();

Voici les différentes instances que nous avons choisi pour l'agencement en cours.

Voici les différents groupes fournis dans l'agencement en cours.

Cette documentation présente comment utiliser l'engine avec l'agencement en usage chargé (TriBot.ini). Vous trouverez des informations utiles à propos d'URBI sur http://gostai.com/doc/urbi-tutorial.htm.

Trois moteurs sont disponibles, wheelL, wheelR et claw. wheelL et wheelR sont groupés dans wheels. Chaque moteur est aliasé à son attribut .torque. aussi :

wheelL = 10; 

égale

wheelL.torque = 10;

et

wheels = 10;

égale

wheelL = 10 & wheelR = 10; 

L'attribut .torque vous autorise à régler la vitesse d'usage du moteur. Cette valeur est réglée entre -100 et 100. Aussi vous pouvez contrôler la vitesse des roues en tapant simplement :

    wheels.torque = 100; 
    

Une valeur négative inverse la rotation du moteur.

Vous pouvez lire la position du moteur (en degrés) en utilisant l'attribut .val. Cette attribut est réglé à 0 quand vous mettez en route le robot. Aussi vous pouvez récupérer la position d'usage de claw en tapant :

 claw.val,

. Dans le cas de claw ; nous avons ajouté un contrôle du PID, aussi vous pouvez régler une position.

claw.val = 360 ;

qui signifie que nous demandons une rotation entière du moteur de claw. Change les paramètres de claw.PGain, claw.IGain et claw.DGain pour obtenir un contrôle affiné de la position.

Tous les capteurs sont aussi aliasés à leur attribut .val, donc par exemple vous avez juste à demander bumper pour obtenir bumper.val. Cela marche de la même façon avec l'objet battery.

Les capteurs sont groupés dans le groupe sensors et tous les périphériques matériels (sensors + motors + battery + beeper) sont groupés dans le groupe hardware.

Le périphérique switch est appelé bumper dans notre agencement. Vous pouvez demander sa valeur ( pour savoir si il est on ou off) en demandant

bumper.val ;

1 est bumper on, 0 est off.

Le capteur à ultrasons est appelé sonar. Vous pouvez obtenir la distance lue en demandant l'attribut .val.

sonar.val ;

retourne la distance mesurée par le capteur. On aura en retour une valeur comprise entre 0 et 255 cm. Quand la valeur lue fait défaut, elle retourne 255.

Le capteur de son est appelé decibel dans notre agencement.

Vous pouvez obtenir la valeur lue en demandant l'attribut .val.

decibel.val ;

retourne une valeur normalisée entre 0 et 1. C'est une valeur brute proportionnelle à la quantité de décibels mesurés.

Vous pouvez régler le capteur de sons en deux modes différents en changeant l'attribut .mode. Deux valeurs sont disponibles, "DB" et "DBA" "DBA" est un mode ajusté mesurant seulement les fréquences comprises entre 200 et 14000Hz. "DB" mesure une bande de fréquences étendue. Règlez cette valeur en tapant :

 decibel.mode = "DB" ;

. La valeur par défaut est "DBA".

Le capteur de lumière est appelé light.

On récupère la valeur mesurée en demandant l'attribut .val.

light.val,

La valeur retournée est normalisée (entre 0 et 1) représentant un pourcentage de la quantité de lumière mesurée.

Vous pouvez régler le capteur de lumière en trois différents modes en changeant l'attribut .mode. Les valeurs disponibles sont "Reflector", "Ambiant" et "Normal". La valeur par défaut dans notre exemple est "Reflector". "Reflector" signifie que le capteur de lumière allume sa led et mesure la lumière réfléchie. "Ambiant" éteins la led et mesure la lumière ambiante. "Normal" éteins la led et retourne la valeur brute mesurée. Vous pouvez le changer en tapant :

light.mode = "Ambiant",

Le périphérique batterie est tout simplement appelé battery.

Vous pouvez obtenir la puissance d'usage en demandant l'attribut .val.

battery.val

Le périphérique bruiteur est appelé beeper.

Vous pouvez uniquement demander au beeper de jouer un son personnalisé, utilisez sa fonction :

play(frequency, time) ;

frequency est un integer entre 200 et 14000, qui est la fréquence du beep. time est un integer mesuré en millisecondes, qui est la durée du son. Si nous voulons jouer un son durant 1 seconde avec une fréquence de 200, nous ferons :

beeper.play(200, 1000),

Un temps de 0 est infini. De même la commande n'attends pas la fin du beep. Donc si vous voulez attendre jusqu'à la fin du beep, essayez quelque chose comme

{ beeper.play(myFrequency, myDuration) & wait(myDuration) },

L'UObject command n'est pas un périphérique. Il autorise l'envoie direct de commandes comme vous le faites avec le SDK du NXT. Vous trouverez plus d'informations sur http://mindstorms.lego.com/Overview/NXTreme.asp.

Vous ne pouvez pas créer d'instances Command mais utilisez le comme :

Command.send(myBuff) ;

myBuff est un buffer de command valide (liste d'integers entre 200 et 14000).

Command.send([3, 10, 10, 0 , 0]);

jouera un beep.

answer = Command.request(myBuff, size) ;

myBuff est un buffer de command valide (attendant une réponse). size est la taille du buffer de retour (il doit être de la taille exacte, trop petit il bloquera tout le serveur, et trop grand il fera échouer votre requête). answer est le buffer de retour (c'est une liste, [] est retourné quand la requête échoue). Cette commande a été créée pour les utilisateurs experts qui demande plus d'URBI. IL n'est pas recommandée de l'utiliser si vous ne savez pas ce que vous faites et peut faire planter tout le serveur. Utilisez le à vos propres responsabilités. Voici un exemple :

answer = Command.request([7,0], 15); 

qui retourne les informations sur port d'entrée 1.

Voici un exemple simple qui explique comment écrire votre propre agencement. Avant de le construire, vous devrez jeter un coup d'oeil au tutoriel URBI (http://www.gostai.com/doc/urbi-tutorial.htm).

Il y a 3 sortes de périphériques fournis par le serveur : moteurs, capteurs et autres périphériques. Il y a un type de moteur appelé Servo. Il y a 4 types de capteurs: Switch, SoundSensor, UltraSonicSensoret LightSensor. 2 autres périphériques sont disponibles: Battery et Beeper.

Ecrire un agencement consiste simplement à instancer des objets périphériques à partir des classes de base ci dessus. Nous allons maintenant vous montrer comment le faire :

Le constructeur d'initialisation de Servo a la syntaxe suivante:

 myServoObject = new Servo(myPort);

Vous pouvez créer 3 objets Servo différents lié aux 3 différents ports ("A","B" et "C" ).

Dans le TriBot.ini en cours, nous créons nos objets Servo :

    wheelL = new Servo("C");
    wheelR = new Servo("A");
    claw = new Servo("B");
    

La roue gauche est sur le port C, la roue droite sur le A et la pince sur le port B.

Le PID contrôle étant fournis avec ce moteur, vous pouvez le lier à un objet Servo approprié pour le contrôler par la position. Utiliser la syntaxe suivante pour lier le contrôle du PID.

 myServoObject inherits PID;

Puis réglez vos propres paramètres de PID :

 
    myServoObject.PGain     = 0.01;
    myServoObject.IGain     = 0.01;
    myServoObject.DGain     = 0.01;
    myServoObject.precision = 0.01; 
    

N'hésitez pas à changer ces paramètres pour changer le comportement de votre PID. Maintenant vous pouvez lancer le contrôle du PID par :

myServoObject.setPID("myServoObject.val", "myServoObject.torque");

Dans notre exemple, nous utilisons le PID de cette façon :

claw inherit PID;
    claw.PGain     = 0.01;
    claw.IGain     = 0.01;
    claw.DGain     = 0.01;
    claw.precision = 0.00;
    claw.setPID("claw.val", "claw.torque");
    

Qui signifie que le PID tourne en permanence, où claw.torque contrôle claw.val (Nous récupérons une position sur claw.val , et la vitesse en dépendant est automatiquement réglée).

Le contrôle du PID s'arrêtera quand la précision que vous attendez est atteinte, si vous voulez autoriser un contrôle permanent, réglez la précision sur 0.

Maintenant vous pouvez créer vos objets capteurs.

Commençons avec l'objet Switch. Pour le créer suivez la syntaxe :

    mySwitchObject = new Switch(myPort);
    

où myPort peut être 1, 2, 3 ou 4.

Dans notre exemple, nous voulons utiliser le switch comme un bumper branché sur le port 4, aussi nous faisons :

bumper  = new Switch(4);

C'est exactement la même façon pour créer un objet UltraSonicSensor :

    myUSSObject = new UltraSonicSensor(myPort);
    

myPort peut être 1, 2, 3 ou 4.

Vous pouvez voir dans notre TriBot.ini un capteur ultrasonic sur le port 2:

sonar   = new UltraSonicSensor(2);

Maintenant nous allons créer un objet SoundSensor :

    mySoundObject = new SoundSensor(myPort, myMode);
    

Comme d'habitude, myPort peut être 1, 2, 3 ou 4. myMode définit le mode de fonctionnement du capteur. Il peut être "DB" ou "DBA", signifiant "décibel" ou "décibel équilibré" (le dernier enregistre les sons dans le spectre audible des fréquences 400-14000Hz).

Aussi dans l'exemple nous créons un capteur de son sur le port 1 en utilisant décibel adjusted:

 decibel = new SoundSensor(1,"DBA"); 

Le dernier capteur est le LightSensor, vous pouvez le créer avec la ligne :

    myLightObject = new LightSensor(myPort, myMode);
    

avec myPort dans 1, 2, 3 ou 4. MyMode définit encore le mode de fonctionnement du capteur et il peut être "Ambiant" (ici le capteur mesure la lumière ambiante), "Reflector" (le capteur allume sa led et mesure la lumière réfléchie) et "Normal" (le capteur retourne sa valeur brute).

Nous avons choisi d'utiliser le capteur de lumière en mode reflector sur le port 1 aussi nous faisons :

light   = new LightSensor(3,"Reflector");

Maintenant nous pouvons ajouter deux autres périphériques à notre agencement.

Le périphérique Battery nous permet de lire le niveau de la batterie. Tapez simplement :

myBattery = new Battery();

Nous le créons de cette façon :

    battery = new Battery();
    

Le périphérique Beeper nous permet d'émettre des beeps personnalisés à partir du haut-parleur du NXT. créons le :

myBeeper = new Beeper();

Nous créons le beeper dans l'exemple :

    beeper  = new Beeper();
    

Une chose agréable qui rend la vie plus facile avec URBI est de coder des fonctions simples de haut niveau. Cela vous permet de déplacer votre robot facilement juste en appelant ces fonctions. On commence avec la fonction forward() qui fait avancer votre robot... en avant!

  fonction global.forward()
  {
     wheels = 10;
  },
  

Ici nous déclarons une fonction forward() de portée (scope) global. Déclarer la fonction dans un scope (vous pouvez l'appeler comme vous voulez), l'autorise a la rendre visible à partir de n'importe quelle connection d'où vous l'exécutez.

wheels = 10; règle la vitesse des roues à 10.

class global
{
  var defaultSpeed ;
  var x ;
  var y ;
  function forward() ;
  function randomMove() ;
} ;
function global.forward()
{
  //définition de la fonction;
} ;
function global.randomMove()
{
  //définition de la fonction ;
  forward() ; //appelée sans global
} ;

Maintenant, nous pouvons améliorer ce code permettant une vitesse personnalisée. Voici une bonne façon de le faire:

global.defaultSpeed = 10;

function global.forward()
{
   wheels = global.defaultSpeed;
},

Ici nous définissons une variable dans le scope global qui définissent la vitesse personnalisée. Cela vous permet de définir la vitesse à chaque fois que vous le voulez (très utile lors de tests sur votre propre programme).

Enfin, nous pouvons ajouter un timer à cette fonction, utile pour se déplacer durant une période de temps fixe:

global.defaultSpeed = 10;

function global.forward(timer)
{
  wheels = global.defaultSpeed |
  wait(timer)|
  wheels = 0;
},

Ici nous ajoutons un paramètre timer qui est le temps voulu de rotation des roues. La syntaxe wheels = global.defaultSpeed | wait(timer) exécute sequentiellement wheels = global.defaultSpeed PUIS wait(timer). Quand vous séparez un groupe d'un autre (e.g. : wheels = 0 - qui arrête les roues) utilisant le séparateur |, qui fait attendre l'instruction pour l'instruction précédente. Donc wheels = 0 sera exécuté APRES la fin du timer. Aussi cet appel fait avancer le robot en avant pendant une seconde puis s'arrêter.

global.forward(1000),

Ce qui suit est un exemple venant du fichier std.u qui définit des fonctions de mouvement de base.

class global ;

global.defaultSpeed = 10;

function global.forward()
{
   wheels = global.defaultSpeed;
},

function global.backward()
{
   wheels = -global.defaultSpeed;
},

function global.turnleft()
{
   wheelL = - global.defaultSpeed &
   wheelR = global.defaultSpeed;
},

function global.turnright()
{
   wheelR = - global.defaultSpeed &
   wheelL = global.defaultSpeed;
},

Ici, nous allons voir comment créer une fonction qui va générer un déplacement au hasard du robot. Cette fonction sera utile pour la prochaine partie de notre didacticiel. Cette fonction est destinée à faire réagir le robot à un événement. Donc, l'idée est de faire un mouvement de recul, puis à changer la direction au hasard. Nous avons également besoin de 2 paramètres, une constante de temps, ce qui fera tourner le robot pendant ce laps de temps (Ce qui évitera de ne pas tourner assez ); Et une base de temps randomisée qui est le temps maximum de rotation qui sera généré. Voici le code :

function global.randomMoves(constantTime, randomTime)
{
  {backward() & wait(2s)}
 |
  {
   {if (random(2) == 1) left()
    else right()
   }
   &
   wait( (constantTime+random(randomTime))*100)
  }
  |
  forward()
},

{backward() & wait(2s)} Aussi en premier