NXT gyro sensor, quelqu'un peut-il m'aider ?

[efjie2002]

il y a t'il un prof d'anglais parmi nous ?
Je suis preneur d'une traduction pour:
http://www.hitechnic.com/index.html?lan ... t=d24.html

merci d'avance, pour l'instant je bricole!

[maxlemalade]

qu'est ce qui te pose probleme la dedans ? ... enfin, dans l'idée, j'ai pas super envie de tout traduire mais si tu as une ou 2 phrases clef dont tu ne saisis pas le sens, ce n'est pas un probleme de te les passer en francais

[Alban42800]

Tu as de la chance : je bosse aujourd'hui et c'est plutôt calme donc j'ai le temps ! J'suis pas super calé en anglais mais je sais lire une doc technique, voici ma version :

Le capteur contient un capteur gyroscopic simple axe qui détecte la rotation et renvoie le nombre de degrés par seconde de rotation. Il peut mesurer jusqu'à 360 deg/seconde.
il utilise une entrée analogique du nxt et la valeur peut être lue environ 300 fois par secondes.
l'axe de mesure est vertical (voir croquis sur leur site) donc le capteur mesurera les mouvements de rotation comme indiqué par la fléche sur le croquis.

test du capteur : le brancher sur le port 1 et choisir view->ambient light puis bouger le capteur pour voir la valeur sur le nxt.

Utilisation du bloc :
- apparament il y a un offset à définir car au repos la valeur peut varier en fonction de la température notamment : un conseil, prévoit un calibrage en debut de programme (voir l'exemple sur le site).
-tu peux définir un seuil afin d'avoir une sortie vrais/faux qui indique un dépassement du seuil. (trigger)

Il y a ensuite un exemple de programme qui affiche la valeur sur l'écran.

Tout cela n'a pas l'air bien compliqué sur le papier, bien entendu en réel il te faudra plusieurs essais avant de tirer une lecture potable du capteur (perso j'ai bien galéré ave le capteur US au début).

[efjie2002]

merci pour votre aide!
je suis en train de réflechir a un programme combinat le capteur gyro et un chrono afin de déterminer non pas l'a vitesse de rotation mais l'angle / verticale. Mathématiquement c'est simple:
Angle (°)/Verticale = vitesse angulaire (°/s) x Temps:
But du jeu: corriger une assise pour ré-obtenir la verticalité.

je continue à bidouiller...

[Alban42800]

As-tu réellement besoin de connaître l'angle ?
Après tout le capteur te donne une vitesse et une direction et tu envoie au moteur une vitesse et une direction donc c'est du même genre.
Pour simplifier il faut trouver un coefficient multiplicateur entre la valeur lue et la valeur à envoyer au moteur, tout ça dans une boucle rapide et sans te préoccuper de l'angle. Dans la pratique il faudra certainement ajouter une constante au final donc :
vitesse moteur = constante + coefficient x vitesse angulaire.
Il faut aussi certainement corriger en prenant en compte la vitesse du moteur (sinon cela oscille), cette vitesse doit être la même que la vitesse mesuré si le coef est bon :
vitesse moteur = constante + coefficient x (vitesse angulaire - vitesse angulaire précédente).
Tu peux aussi filmer tes expériences pour les regarder ensuite, à tête reposée.
dans un programme NXC:
old_v=0;
while (1)
{
v_ang= -lecture vitesse angulaire-;
v_mot=const + coef * ( v_ang - old_v );
old_v=v_ang;
moteur(v_ang);
}
Pour commencer tu peux simplement fixer le capteur à l'axe du moteur et bouger celui-ci à la main.
Je suis bien conscient que c'est plus compliqué que ça, mais c'est comme ça que je commencerai.

[efjie2002]

j'avais commencé de me plonger dans la prog nxt mais je recommence tout depuis le début en étudiant le nxc

[Nico71]

je voudrais savoir, est ce que on retrouve les même principes dans la prg du nxt que dans la prog d'automate (genre le bon vieux TSX17?).

Genre même architecture que le ladder, et les grahcet ? ou plutot genre la prog d'info ? (nous on utilise borland developper).

[Alban42800]

Non, la prog à beau être en graphique ce n'est pas un grafcet, j'ai déjà programmé des automates (APRIL) et c'est bien différent.
NXT-G = Labview simplifié : c'est le langage utilisé en laboratoire afin que les chercheurs puissent faire des programmes "facilement".
NXC = langage C.
Il y a d'autres langages mais je ne pense pas qu'il y ai de grafcet (à toi de le développer...)

[Polo]

Bah je pense que labview, c'est dans l'esprit du grafcet, mais orienté objet ( comme tout aujourd'hui )
Mais en bon informaticien, je préfère programmer en dur...

[Alban42800]

Labview c'est la base du NXT-G (qui est en fait un labview simplifié). Tu peux obtenir labview pour PC sur leur site gratos (je crois que c'est une version plus complète pour lego).
Sinon pour le capteur gyro j'ai trouvé ça :
http://nxtasy.org/2008/06/21/3-joint-robotic-arm/
[video]http://www.youtube.com/watch?v=wAPUR0fLYOA[/video]

et le code : http://popak.org/robot/hand2_v3.c
C'est du C, à retranscrire dans ton langage, oublie le NXT-G qui sera trop lent pour un bon résultat...

extrait :

Code: Tout sélectionner

apparemment cela commence par une calibration (while... pour fixer Gyrobias)
float Gyro_value=0, a=0.1, Gyro_value2=0, Gyro_value3=0;
while (time1[T1] < 5000) {
      // filter the sensor output

      Gyro_value = SensorValue(GyroSensor);
      Gyro_value2 = SensorValue(GyroSensor2);
      Gyro_value3 = SensorValue(GyroSensor3);
      wait1Msec(10);
       GyroBias = (1-a)*GyroBias + a*Gyro_value;
       GyroBias2 = (1-a)*GyroBias2 + a*Gyro_value2;
       GyroBias3 = (1-a)*GyroBias3 + a*Gyro_value3;
   }
/*  you need to let the program compute your gyro biases - my gyro biases are all different
   GyroBias = 620;
   GyroBias = 591;
   GyroBias3 = 601;
*/

plus loin une lecture et des calculs (f2 et f1 puis e0) pour envoyer l'info aux moteurs :
   while(true) {
      // Runge-Kutta integration (http://en.wikipedia.org/wiki/Runge-kutta)
     wait1Msec(half_h);
     f2 = (SensorValue(GyroSensor)-GyroBias)/GyroScale; // f(tn+h/2)
     ff2 = (SensorValue(GyroSensor2)-GyroBias2)/GyroScale; // f(tn+h/2)
     fff2 = (SensorValue(GyroSensor3)-GyroBias3)/GyroScale; // f(tn+h/2)
      wait1Msec(half_h);
       theta = theta_old + (f1+2*f2)*(nSysTime-t_old)/t_scale;
       theta2 = theta_old2 + (ff1+2*ff2)*(nSysTime-t_old)/t_scale;
       theta3 = theta_old3 + (fff1+2*fff2)*(nSysTime-t_old)/t_scale;
       theta_old = theta;
       theta_old2 = theta2;
       theta_old3 = theta3;
       f1 = (SensorValue(GyroSensor)-GyroBias)/GyroScale; // f(tn)
       ff1 = (SensorValue(GyroSensor2)-GyroBias2)/GyroScale; // f(tn)
       fff1 = (SensorValue(GyroSensor3)-GyroBias3)/GyroScale; // f(tn)
       t_old = nSysTime;

   e0 = ((-theta) - (float)nMotorEncoder[motorB]);
   e02 = ((-theta2+theta) - (float)nMotorEncoder[motorA]);
   e03 = ((theta3) - (float)nMotorEncoder[motorC]);
   motor[motorB] = kp*e0;
   motor[motorA] = kp*e02;
   motor[motorC] = kp*e03;


J'espère sincèrement que tu réussira à le faire fonctionner car il a l''air bien ce capteur.

[Nico71]

impressionnant !

[maxlemalade]

ouah ! ah vi, ca montre bien les possibilité e la chose ^^ par contre, apres, le souci, c'est de trouver le financement pour en acheter 3 :p

[efjie2002]

il faut vraiment que je m'y rattaque pendant les vacances....

[Anio]

C'est dingue !
La vidéo est vraiment bluffante.

Je me demande si, à plus grande échelle, on pourrait reproduire un robot qui marche (sur le même principe, avec des capteur fixés sur soi).