MackBOT

[Mackhdo]

Je vais vous parler de ma nouvelle première création sérieuse en NXT.

C'est un robot de type Segway donc, comprendre par la que le robot tient en équilibre sur deux roues, en stationnaire ainsi qu'en déplacement.

jusqu'ici rien de bien formidable vu que cela a déjà été fait.
En fait je veux me servir de ce robot comme base pour ensuite ajouter des améliorations qui elles seront, je l'espère, uniques.

Je ne possède pas d'APN, donc les photos vont provenir de mon téléphone et je m'en excuse d'avance.

Le projet se découpe en plusieurs étapes, étant du genre à bosser sur des coups de tête, beaucoup d'étapes ne sont même pas encore réellement définies dans mon esprit.
En fait je focalise souvent sur l'étape en cours et la suivante, pas plus loin, chaque chose en son temps.

ETAPE 1: - Faire une structure en NXT sur deux roues avec un programme en java embarqué (LeJos) tenant en équilibre en état stationnaire gràce à un asservissement par PID: Fait.
ETAPE 2: - Contrôler les déplacements du Bot a partir d'un téléphone portable acceptant les middlets java : En cours.
ETAPE 3: - Ajouter des comportements autonomes (behaviour), en fonction de l'environnement grâce aux capteurs: En cours
- Détecter la proximité d'un obstacle et le cas échéant faire demi tour (Capteur ultrasonique): Fait.
- Détecter la proximité d'un trou/précipice/bord de table et l'éviter (Capteur luminosité): A faire.
- Le robot se lève et se couche seul, de façon délicate (3ème Servomoteur): A faire.

Voila, je vais poster ce soir les parties techniques et développement, je voulais surtout franchir le pas et créer le topic.
Je ferais un topic séparé pour l'installation de l'environnement Lejos comme prévu.

Voici les liens qui m'ont été utiles tout au long de cette réalisation:
- http://wiki.aasimon.org/doku.php?id=marvin:ecp2 lien expliquant la création de marvin bot, contient des explications claire sur le PID
- http://lejos-osek.sourceforge.net/nxtway_gs.htm Un Segway like NXT avec capteur gyroscopique.
- http://www.aplu.ch/home/apluhome.jsp?site=38 Un lien indispensable !! L'auteur a développé tout un ensemble de classe java simplifié pour piloter le NXT en Lejos, beaucoup d'exemple, des vidéos, de très bon tutos, un must !

[Alban42800]

- Le robot se lève et se couche seul, de façon délicate (3ème Servomoteur): A faire.

J'ai déjà vu ça avec 2 moteur sur un RCX : Le robot à une petite roulette en haut, il part couché sur 3 roues et freine d'un coup ce qui le fait basculer verticalement. C'est sur une vidéo ou le créateur passe sur un plateau TV.

Je ferais un topic séparé pour l'installation de l'environnement Lejos comme prévu.

J'ai déjà fait ça : http://www.techlug.fr/Forum/topic2050.html
Essaie d'être complémentaire

[Mackhdo]

Bon....déception...cela à déjà été fait, snif...

Sinon le tuto que je vais faire va être clairement nouveau vu que c'est la version pour Windows 64bits, je vais la faire car il n'y a pas grand choses sur le net pour ce cas précis.
Dans le cas du win32 il y a des tutos à foison très complets, je mettrais des liens dans le tuto.

Sinon j'ai plusieurs idées de concept particulièrement nouveaux, et après recherche sur le net cela n'a apparemment pas encore été fait.
Mais avant cela j'ai besoin de maitriser parfaitement le PID.

[roboleo]

Sinon le tuto que je vais faire va être clairement nouveau vu que c'est la version pour Windows 64bits, je vais la faire car il n'y a pas grand choses sur le net pour ce cas précis.
Dans le cas du win32 il y a des tutos à foison très complets, je mettrais des liens dans le tuto.

Cela complètera parfaitement le travail d'Alban…

Sur ton MOC:
Tous les possesseurs du set Mindstorms NXT 2.0 n'ont pas forcément un capteur gyroscopique supplémentaire. Ton Moc, si je ne me trompe pas évoluera avec ce capteur; il est donc réservé à quelques chanceux.
Il sera donc intéressant que tu expliques la manière de l'utiliser et les particularités de sa programmation. Cela pourra donner à certains l'envie d'en faire l'acquisition.

Tu as défini les étapes dans un ordre tout à fait logique.

Pour l'étape 3
- une information récente: Jeudi 16 décembre, il a été annoncé que l'Inventeur d'Applications pour l'Android a intégré une palette de fonctions pour LEGO MINDSTORMS NXT qui permet de construire ses propres applications Android pouvant contrôler les moteurs et capteurs du robot LEGO MINDSTORMS NXT. C'est donc l'ouverture vers des commandes personnalisées à partir d'un SmartPhone.
http://us.mindstorms.lego.com/en-us/News/ReadMore/Default.aspx?id=257500
Le code source en java est disponible.
- La détection d'un bord, d'un trou, etc., peut aussi s'envisager avec un capteur de contact (sans doute plus facile à contrôler qu'un niveau lumineux).
- je suis très intéressé par le levé et coucher du robot en douceur: par programmation ou commandé par le Smartphone?

Malgré tout ce qui a été déjà fait sur un segway, une nouvelle approche est toujours prometteuse.
Nous attendons tes posts avec beaucoup d'intérêt…

[Mackhdo]

Après l'intervention d'Alban faisant part du système de lever par freinage brutale, j'ai médité dessus.

Voici ce que je pense faire:
-Mettre une roulette à pivotement libre au niveau de la tête du robot vers l'arrière, pour qu'elle fasse contact en position coucher.
- Cette roulette sera sur amortisseur, cela permettra qu'en fin de manipulation il puisse se coucher en "tombant" en arrière sans endommager les pièces.
- Grâce a cette roulette le robot pourra se déplacer en position couché, du coup je compte faire deux modes de pilotage par téléphone (ou pc).
- Un mode de pilotage en position couché, donc pas de contrôle d'équilibre et les moteurs disponibles en puissance max, avec une fonction pour prendre les virage façon voiture plus que tank.
- Un mode de pilotage en mode verticale avec contrôle de l'équilibre donc.
- Le passage entre deux mode se fera par une touche du téléphone, donc sans intervention manuelle, et le robot se lèvera ou se couchera en conséquence.

- je suis très intéressé par le levé et coucher du robot en douceur: par programmation ou commandé par le Smartphone?

Du fait de ces nouvelles étapes, la fonction sera automatisé, donc par programmation, mais le déclenchement par "vieux téléphone" et non smartphone

Pour le capteur de contact, cela induit un point d'appui au seul pour le dit capteur, donc un point d'appui supplémentaire pour le robot, ce qui va a l'encontre du principe du projet pour moi.
A moins que tu ne le voyais d'une autre façon, auquel cas je suis tout ouïe.

Concernant les smartphones, c'est intéressant ! Pour l'instant je ne possède qu'un portable standard sony ericsson qui supporte le java, mais dans un avenir plus ou moins proche je passerais sur android, pas question de prendre un itruc.

je verrais donc le moment venu.

[Mackhdo]

Bon ça m'énerve, il faut vraiment que je trouve un moyen fiable de configurer les poids de départs.

Si j'utilise les instructions de montage de Jan Witzand : http://code.google.com/p/gelway/
ainsi que son code java, ça marche, pas de problème, mais des que je modifie la structure du robot pour la faire selon mon envie, plus rien ne va.

Voici le code principal (simplifié), la ou est mon problème:

Code: Tout sélectionner

   private final double Kp = 1.20;
   private final double Ki =  0.25;
   private final double Kd = 0.1;
   private final double K_psi = 40.257035; // Gyro angle weight
   private final double K_phi = 0.806876; // Motor angle weight
   private final double K_psidot = 0.620882; // Gyro angle velocity weight
   private final double K_phidot = 0.039711;// Motor angle velocity weight

   while (!Button.ESCAPE.isPressed()) {
         ctrl.setDamp(0.1);
         double Psi = gyro.getAngle();
         double PsiDot = gyro.getAngleVelocity();
         double Phi = motors.getAngle();
         double PhiDot = motors.getAngleVelocity();

         double error = Psi * K_psi + Phi * K_phi + PsiDot * K_psidot   + PhiDot * K_phidot;
         int_error += error;
         double deriv_error = error - prev_error;
         prev_error = error;
         double pw = (error * Kp + deriv_error * Kd + int_error * Ki) * 1;
         motors.setPower(pw   + (ctrl.leftMotorOffset() + ctrl.rightMotorOffset()) / 2);

            Thread.sleep(6);
      }


Dans ce code, l'auteur attribue des poids au valeurs de l'angle des moteurs, vitesse des moteurs, angle du gyro et vitesse angulaire du gyro avant.

C'est la somme de ces valeurs proportionnées qui donne l'erreur, s'applique ensuite le classique PID.

Ce qui fait pas moins de 7 valeurs a étalonner.

Quand j'avais le montage d'origine de l'auteur, en modifiant n'importe lequel de ces paramètres d'un cheveu, le robot devient instable et tombe.
Donc il me faut trouver une méthode calculatoire propre, et la j'avoue que je cale.

Il faut bien comprendre que je cherche seulement a comprendre le principe utilisé par l'auteur, je ne veux pas le copier, je veux faire mon propre robot au final avec mon propre code, mais j'ai besoin de comprendre cela d'abord.

Sur le lien que j'ai donné plus haut, il y a la thèse complète de l'auteur, très détaillé, mais en anglais par contre;

Si vous comptez faire un jour un robot similaire, le pdf est une référence.

[Mackhdo]

Bon, après mûre réflexion, je vais reporter ce projet pour le moment et ce pour plusieurs raisons.

- Cela à déjà été fait, et après une multitude de recherche sur le sujet je me rends compte que la plupart sont des copies du projet initial, à savoir marvin bot.
- Je n'arrive pas à maitriser le PID, du moins l'étalonnage des coeffs, si c'est pour juste copier un existant en le modifiant à peine sans comprendre, cela ne m'intéresse pas.
- J'ai un besoin évident de m'entrainer aussi bien a concevoir en lego qu'en programmation Lejos.

Pour toutes ces raisons et d'autres je vais pour l'instant me mettre à la conception de MOCs de technique moindre pour me faire la main.
Désolé du coup pour avoir fait un topic.

Mais ! ce projet sera repris dés que je me sentirais techniquement capable.

[roboleo]

A garder au chaud! Rien n'est inutile.
On le ressortira plus tard après mûrissement…
Le PID fait couler beaucoup d'encre, mais il est très intéressant intellectuellement parlant!