URBI Doc

En premier, assurez vous que le module CM-5 est opérationel.

Vous aurez à flasher le firmware URBI dans le module. Cette opération est nécessaire pour la raison que le format d'envoi des data de l'URBI-engine est différent du protocole Robotis.

Vous pouvez trouver le fichier hexa ici : dans le dossier bin/firmware/ de votre dossier installation de votre bioloid ou la dernière version sur http://www.gostai.com/bioloid

Les systèmes Linux ont une dépendance avec la librairie de boost : vous devez installer la boost 1.34.1 library, elle peut se trouver sur http://www.gostai.com/bioloid .

Vous pouvez vérifier une autre erreur de dépendance en tapant ldd < INSTALLDIR >/urbi-server-bioloid

retourne les informations sur les dépendances de librairies, si une librairie est vérifiée (not found), vous aurez à l'installer. Principalement vous aurez toutes les librairies pré-installé, il manquera peut-être le package "libssl0.9.8".

(utilisez apt-get / aptitude / synaptique pour installer le package manquant sur debian/ubuntu system).

Les systèmes Windows n'ont pas de dépendances extérieures.

Si la procédure échoue, essayez à nouveau! Dans le cas où 'Rewriting:0x0002' est affiché: Vous avez déjà le bon firmware de flashé.

Une fois que vous avez un robot en état de marche, vous pouvez installer l'engine bioloid. La procédure d'installation changera en fonction de votre système, mais cela vous sera familier. Une fois fini, vous obtiendrez un répertoire bin dans lequel vous trouverez le fichier binaire urbi-server-bioloid. D'autres fichiers importants sont localisés dans le répertoire Bioloid.data.

Avant de lancer l'engine, vous aurez à changer la valeur du port de connexion dans le fichier Bioloid.data/YourConfig.u à l'aide d'un simple éditeur de texte ou notepad, gedit,vi, etc... Au même moment, vous pouvez vérifier que URBI.INI contient une ligne du genre load("");.

YourConfig.u peut être le fichier bioloid_scan.u (fichier par défaut) si vous venez juste de commencer avec urbi. Ce fichier scan votre réseau bioloid et crée tous les objets nécessaires.

Vérifiez ce fichier pour voir comment le faire vous même si le résultat n'est pas approprié à votre réseau bioloid. (en particulier, l'ordre des moteurs AX-12).

Bioloid.connect(port, speed);

Connectez vous au bioloid sur le port port à la vitesse speed. COM1 ou /dev/ttyS0" et 57600 sont de bonnes valeurs usuelles. Cette fonction retourne 0 pour une ouverture de port avec succès.Attention:Cela ne veux pas dire que le bioloid est correctement connecté.

Exemple sous linux:

Bioloid.connect("/dev/ttyS0", 57600);

Allez au répertoire d'installation de votre bioloid, passez au répertoire bin/ et lancez urbi-server-bioloid --help. le message d'aide suivant devrait apparaitre:

usage: ./urbi-server-bioloid [OPTIONS] [PATHS...]

  PATHS   absolute or relative path elements searched
          in order for files when 'load' is called.

Options:
  -p PORT   specify the tcp port URBI will listen to.
  -b ADDR   bind to a specific ip address.
  -w FILE   write port number to specified file.
  -n        disable networking.
  -r        report the time taken by URBI loop to execute
  -i        treat stdin as an urbi connection
  -P PERIOD base URBI interval in milliseconds
  -s PERIOD shell-mode (no network) with given period
  -t        use high priority scheduling
  -f        fast mode: the server will run as fast
            as possible and emulate the period specified
  -v, --version   print version information and exit

Pour lancer rapidement l'engine du bioloid, tapez seulement:

./urbi-server-bioloid -P 40

pour les systèmes unix, ou

start /HIGH urbi-server-bioloid -P 40

dans un fichier .bat pour les utilisateurs de Windows.

L'engine affichera une en-tête et dira que c'est prêt. Si tout est juste, rien ne se produira de plus.

A ce moment, votre engine devrait fonctionner. Pour tester la connexion, utilisez ou l'outil fourni exprès par Gostai (like URBI_console, see http://www.urbiforge.com/), ou un simple client Telnet (veuillez notez que tous les ports de l'URBI engine sont 54000 par défaut).

telnet localhost 54000

Si aucune erreur n'apparait, votre client Telnet recevra le même type d'en-tête que vous voyez dans la fenêtre de l'engine. La dernière ligne vous donnera votre ID de connexion et sera de la forme :

[65000000:ident] *** ID: U135766920

Si ce n'est pas le cas, assurez vous que vous avez correctement installé l'engine et suivez les étapes précédentes. Référez vous aux disfonctionnements et FAQ si vous rencontrez des problèmes pour lancer le serveur malgré tout.

Vous êtes maintenant prêt à envoyer des commandes à votre robot par le bioloid URBI engine. Par exemple essayez :

vars;
...
[00004004] *** Bioloid = OBJ
...

La première ligne demande la liste de toutes les variables connues par le serveur et celles, dont vous n'avez pas à vous intéresser, des symboles et de leurs valeurs respectives.

Il y a des fichiers spéciaux comme URBI.INI qui est lu au démarage de l'engine, si ce fichier existe. Il y a un fichier URBI.INI dans le package standard du bioloid, vous pouvez faire tourner l'engine avec ce fichier en entrant ceci:

./urbi-server-bioloid -P 40 ../gostai/Bioloid.data 

Le dossier ../gostai/Bioloid.data/ contient un fichier URBI.INI et quelques fichiers files.u.

Note: avant d'entrer les commandes précédentes, soyez sûr que vous avez édité bioloid_scan.u et décommenté la ligne Bioloid.connect adaptée à votre système.

Ce chapitre introduira les concepts de base pour l'utilisation du bioloid URBI engine. Il peut être passé si vous êtes déjà familier avec URBI engines.

Pour de plus amples informations sur les commandes URBI, lisez les premiers chapitres du tutoriel URBI.

Avant toute autre chose, assurer vous du succès des étapes présentées dans le chapitre Quickstart.

Voici une petite liste de périphériques disponibles sur le bioloid avec lesquels vous pouvez contrôler l'engine. Ce sont les périphériques par défaut créés sans fichiers .u ou .ini

Ces périphériques sont des périphériques parents, il est nécessaire de créer les périphériques à partir d'eux pour utiliser votre robot bioloid: Ceci est expliqué ensuite.

Essayez cette première commande dans votre cession Telnet :

sensor = new Sensor(100);
[00000124] 0.000000

Si ce n'était déjà fait, cette ligne crée un UObject lié à votre AX-S1 dynamixiel réel avec ID 100, adaptez cette valeur à votre configuration.

sensor.irC;
[00000476] 0.000000

La première ligne demande la valeur de l'émetteur IR central. La seconde est la réponse de l'engine du bioloid. La première valeur entière est un timestamp (marqueur de temps) pour la réponse (en millisecondes depuis le lancement de l'engine). Il est suivi par un tag. Référez vous au Tutoriel URBI pour plus de détails. Ce qui est important ici, c'est le point flottant finissant la ligne. C'est la valeur stockée dans l'émetteur d'IR central.Ici 0.000000 indique qu'il n'y a rien en face du robot. Avec votre main droite devant le robot, vous devriez avoir une valeur aproximative de 255.000000.

Notez que les prochaines commandes seront incluses dans +end:{...};. Ceci pour que l'engine vous prévienne de la fin de la commande.

Essayez ce qui suit :

+end:{motor__1.speed = 100; wait (2s) | motor__1.speed = 0;};
[00002622] *** end

Votre robot devrait avoir son 1er moteur qui a tourné pendant 2 secondes, puis s'est arrêté. Maintenant essayez de le faire revenir à sa position initiale avec une commande similaire.

Ensuite essayez :

+end:{motor__1.speed = -100; wait (2s) | motor__1.speed = 0;};
[00005095] *** end

Votre moteur devrait revenir à sa position initiale.

La dernière commande simple sera :

sensor on;
irCDetect:at (sensor.irC > 100) echo "Front obstacle : " + sensor.irC;

Maintenant essayez de mettre votre main contre l'avant de votre bioloid AX-S1 module. Vous devriez avoir un message du genre :

[00008215] *** Front obstacle : 230

Le mot-clé at vous autorise à détecter des événements et à faire agir votre bioloid en conséquence.

L'interface du bioloid est proche de celui spécifié dans le manuel des AX-12 et AX-S1. Tapez "myMotor; mySensor;" dans une connexion (où myMotor est un moteur instancié, et mySensor un sensor) pour obtenir la liste complète de leurs attributs.

Vous devriez maintenant être capable de vous amuser avec l'URBI engine du bioloid. Le prochain chapitre vous donnera des détails complets à propos de l'engine, mais ce que nous avons vu ici est suffisant pour utiliser le bioloid et URBI.

Cet UObject est le maître de tous les autres UObjects pour Bioloid. Il a seulement trois méthodes utilisables par l'utilisateur.

connect("device",int speed) Se connecter au réseau RS232 du Bioloid. Cette méthode nécessite d'être appelée en premier avant toute autre commande. Elle retourne 0 en cas de réussite.

	Bioloid.connect("/dev/ttyS0", 57600);
	[00000066] 0
 

connexion sous sytème unix

	Bioloid.connect("COM1", 57600);
	[00000076] 0
 

connexion sous système windows.

Veuillez noter que le firmware flashé dans le Bioloid CM-5 est programmé pour travailler à 57600 bauds pour le moment; Donnez 57600 comme paramètre dans tous les cas pour le second paramètre est une bonne pratique.

	Bioloid.ping(12);
	[00004993] 12
	Bioloid.ping(29);
	[00012900] 255
 

	Bioloid.scan();
	scanning network, may take some time...
	[00099415] [12, 18, 100]
	Bioloid;
	[00109621] OBJ [listAXS1:[100],load:1,listAX12:[12, 18]]
 

Note: Comment fonctionne scan(): il fait un ping sur tous les ID et attends les réponses.

Après avoir appelé ces fonctions, deux listes sont disponibles dans les objets Bioloid: Bioloid.listAXS1 et Bioloid.listAX12. Chaque liste contient tous les ID, triés, par dynamixiels AX-S1 pour le premier et dynamixiels AX-12 pour le second. Vous pouvez utiliser ces listes pour créer tous vos objets motors et sensors. (regardez <bioloid-dir>/Bioloid.data/bioloid_scan.u dans votre dossier d'installation pour plus de détails et d'exemples).

Les motors du Bioloid sont accessibles par les objets Motor et ont les caractéristiques suivantes :

Si votre engine ne charge aucun filename.u au démarage (declarés dans CLIENT.INI ou dans URBI.INI), par défaut aucun motor n'est créé à cause de la structure du Bioloid, nous ne savons pas combien de motors sont dans votre robot, vous devez les déclarer avant de leur envoyer la moindre commande.

motor[i] = new Motor(j);

cette méthode peut être utilisée pour créer un array de 0 jusqu'au nombre de motors que vous utilisez dans l'ordre que vous voulez.

var i = 0;
for j in [10,12,16,18] {
 motor[i] = new Motor(j);
 i = i + 1;
};

ou pour une création automatisée de tous les motors disponibles:

var i = 0;
for j in Bioloid.listAX12 {
 motor[i] = new Motor(j);
 i = i + 1;
};

Cet exemple cré les 4 motors de la voiture Bioloid:

Les motors sont accessibles par le motor__X, avec X entre 0 et votre max_numbered_motor. Vous pouvez (aurez besoin d') adapter l' #ID des motors dans votre script de configuration de votre robot (c'est plus simple que de renommer chaque motor)!

Nommage Standard: Dépendant de la forme de votre robot Bioloid (humanoïde, voiture, quadrupède, etc ...) les fichiers *.u existent pour créer des alias et des groupes pour ces motors, pour avoir un standard de nommage commun pour tous les robots. Regardez dans le dossier Bioloid.data.

Un motor a les attributs suivants:

tous ces attributs sont disponibles en appellant myMotor.attribute comme:

Vous pouvez contrôler votre motor en deux modes, dépendant du close-loop control que vous voulez:

Pour utiliser cette caractéristique vous aurez à régler .cwAngleLimit et .ccwAngleLimit aux valeurs adaptées:

Pour chaque description commencant par une adresse 0xNN le nombre correspond à l'adresse mémoire du AX-12, voyez le manuel du dynamixiel AX-12 pour plus d'informations sur ces fonctions : AX-12 Dynamixiel ou ici

Au démarage de l'engine Bioloid, les sensors nécessitent d'être créés en premier, puis accéder aux valeurs de leurs différents membres retourne toutes les valeurs d'un module AX-S1. Pour créer un nouvel UObject sensor (AX-S1 #ID est 100 dans cet exemple):

sensor = new Sensor (100);

Le module sensor dynamixel AX-S1 est accessible par l'objet Sensor et a les caractéristiques suivantes :

Ici vous pouvez trouver les AX-S1 Specifications pour plus d'information.

Ce chapitre introduira quelques scripts simples. Pour les utiliser tapez

load ("NomDuFichier.u");

Dépendant de la version du bioloid URBI engine que vous avez, quelques scripts seront disponibles dans les dossiers data, profiles ou scripts de votre répertoire d'installation.

Avant tout autre chose, assurez vous d'être familiarisé avec les parties précédentes de ce document.

Pour de plus amples instructions et informations sur les commandes URBI, veuillez lire les premiers chapitres du tutorial URBI.

Tous ces scripts simples supposent que URBI.INI est vide, aussi mettez les lignes en commentaires avec des # ou des // au début de chaques lignes de URBI.INI pour éviter des comportements imprévisibles.

/* ----------------- Basic pour bioloid  --------------------------------- */
/// Se connecter à Bioloid (si ce n'est déjà fait!)
Bioloid.connect("/dev/ttyS0", 57600);

/// Créez les moteurs
var i = 0;
//déclarez l'ID de votre moteur connecté ici
for j in [10,12,16,18] {
 motor[i] = new Motor(j);
 i = i + 1;
};

var NumberOfMotor = i;

t: {
  for (j=0; j<3;j++) {
    for (i=0; i<NumberOfMotor;i++) motor[i].speed = 100 smooth:1s;
    wait(1.5s);
    for (i=0; i<NumberOfMotor;i++) motor[i].speed = 0 smooth:1s;
    wait(1.5s);
  };
};
/* ----------------- Basic pour bioloid  --------------------------------- */

Ceci fera tester chacun de ses moteurs par bioloid par un petit mouvement, 3 fois

/* -------------------- Music pour bioloid  --------------------------------- */
/// Se connecter à Bioloid (si ce n'est déjà fait!)
Bioloid.connect("/dev/ttyS0", 57600);

/// Créer un sensor
sensor = new Sensor(100);
music:{
 for (i=0; i<27;i++){
  sensor.buzzerTime=255;
  sensor.buzzerIndex=i;
  wait(1.5s);
 };
};
/* -------------------- Music pour bioloid  --------------------------------- */

Ceci fera jouer ses 26 mélodies pré-enregistrées à votre module bioloid AX-S1.

/* ----------------- Bumper pour bioloid car --------------------------------- */
bumper:at (irC > 100)      // à la détection d'un obstacle
{
  wheels = 0 | wait (500ms);  // s'arrête et attends un peu
  wheels = -50 | wait (1s);   // recule
  wheels = 0 time:1s |        // stop doucement
  wheels = 100;               // avance
};

wheels = 100;                 // initial start
/* ----------------- Bumper pour bioloid car --------------------------------- */

Ceci fera avancer votre bioloid, s'arrêter devant le premier obstacle, reculer un peu et avancer à nouveau. Vous aurez à imaginer comment l'arrêter. Vous devez charger bioloid_car.u avant d'exécuter ce script pour avoir de bons résultats. (Il est mieux d'avoir un robot avec 4 roues pour avoir une bonne vision du comportement).

/* ----------------- Navigator pour bioloid car --------------------------------- */
var WHEEL_SLOW = 30;              // vitesse d'avance
var WHEEL_FAST = 80;              // vitesse de rotation
var NAV.side = 1;                 // sens de rotation

navigator:at (irC > 150)                   // à la détection d'un obstacle
{
  wheels = 0 | wait (500ms);                  // s'arrête et attends un peu
  wheels = -40 | wait (500ms);                // recule
  NAV.side = NAV.side * -1;                   // change de direction
  wheelL = NAV.side * WHEEL_FAST &        // tourne
    wheelR = - NAV.side * WHEEL_FAST;
  waituntil (irC < 50) | wheels = WHEEL_SLOW; // attends que le chemin soit libre
                                                 // et avance
};

wheels = WHEEL_SLOW;          // initial start
/* ----------------- Navigator pour bioloid car --------------------------------- */

Vous devez charger bioloid_car.u avant d'exécuter ce script avec de bons résultats.

Ce script fera tourner votre robot autant vers la gauche que vers la droite de l'obstacle jusqu'à ce qu'il trouve une voie libre. Il avancera ensuite jusqu'au prochain obstacle.

Dans cette section vous apprendrez à créer votre propre engine Bioloid avec les modules dont vous avez besoin pour votre robot Bioloid

Le fichier binaire exécutable urbi-server-bioloid contient seulement des UObjects pour gérer les briques CM-5, AX-12 et AX-S1. Si vous voulez que votre robot ait d'autres amméliorations, comme une caméra, micro, etc ... vous aurez besoin d'ajouter des UObjects à votre engine (et du matériel, aussi): ils peuvent être intégrés ou à distance.

Créez vos propre UObjects : généralement ce sont des fichiers .cc, voyez tutorial: UObject documentation pour plus de details.

Comment compiler: créez un fichier Makefile avec ceci dedans:

#nom du binaire final
PRG=myBioloidEngine

#lieu ou se trouve le dossier nommé "urbiengine-bioloid"
URBIENGINE_BIOLOID_DIR=/

LIBURBIENGINE_BIOLOID=\
$(URBIENGINE_BIOLOID_DIR)/usr/local/gostai/core/i686-pc-linux-gnu/\
engine/liburbiengine-bioloid.a

BIN_BIOLOID=$(URBIENGINE_BIOLOID_DIR)/usr/local/bin


all:
	$(BIN_BIOLOID)/umake-engine --prefix=../usr/local \
	-o $(PRG)   $(LIBURBIENGINE_BIOLOID) *.cc

clean:
	rm -rf _ubuild-$(PRG)  $(PRG)

$PRG est le nom du binaire final que vous avez généré.

$URBIENGINE_BIOLOID_DIR est le dossier d'installation ou l'on peut trouver .../gostai/core/.../liburbiengine-bioloid.a.

Pour compiler votre engine, entrez juste make dans un shell, dans votre dossier.

Vous pouvez trouver ici des UObjects comme exemples: Urbiforge .

Aucun de connu à cette heure. rapportez nous s'il y en a.