108 réponses à ce sujet

[Vaelan]

Effectivement c'est encore autre chose.

Je débute en programmation aussi, alors sans approfondir reprenons les 3 visions de programmation vu dans le post,

c' est très caricatural mais ça peut aider ceux qui commence de zéro:

 

1) le sketch ou programme chargé dans l'arduino peut être compare à "intelligence" du robot:

   la "conscience" de lui même grâce a une cinématique inverse par exemple

   la "conscience" de son environnement grâce a des capteur

   la partie "inconsciente" de son comportement

   ...

2)les commandes par port série seront une "discutions" avec ton robot:

   les "ordres" qu'on lui donne 

   les données qu'il nous renvoie

   

3)le fichier de config serait plutôt comparé a un "comportement conscient":

   

D'une comparaison grossière:

 

1)inconsciemment nous respirons

 

2)On peut nous dire d arrêter de respirer

   On peut nous dire comment le faire

 

3)On a appris à arrêter de respirer 

   On peut le faire

 

je pourrais pousser la caricature plus loin en disant que son "intelligence" est partitionné en différente partie

pour gérer ses mouvements, ses yeux, ses oreilles ect..... ce son les librairies ou fonction c est ces différente

partie qu il faut rendre le plus clair possible grâce a des module ou onglet avec l'arduino ainsi si l on veut

modifier sa vue il suffit de modifier le module ou onglet vue, en plus de retrouver ces ligne de codes très rapidement

on ne prend pas le risque de modifier un ligne de code qui serais sa sensibilité ou ses mouvements.

 

voila ma vision simpliste mais je l’espère efficace. 

 

 

[AlexBotMaker]

Oui ! c'est pas mal comme interprétation !   c'est une façon de voir les choses ^^

Au faites !

Tu a étudié à L'ESIX en Normandie a Caen ??

[Vaelan]

Puis la cinématique inverse j'ai lu des pages de tutoriel différents mais je comprend toujours pas ... 

En faite c est impressionnant par les équation obtenu, mais en réalité pour la pseudo cinématique inverse (Pythagore/al-kashi) c est hyper simple

il est juste très important de comprendre son principe parce que ce n est pas adaptable d un robot a un autre, en tout cas pas d'une façon simple.

On a du voir a peu prêt les même tuto qui explique le principe d une patte a 90° au sens de marche avec un seul offset.

l important a comprendre c est l intérêt de l IK , pouvoir contrôler son robot par son centre de gravite sans s occuper du reste.

Donc si tu contrôle son centre, ton ik dois déjà savoir ou son tes patte sur ton quad ça donne 2 offset par patte (qui son les meme

en négatif ou positif,largeur/longueur) c est la première chose que tu ne vois pas sur les tutos de plus, sur un quad, le centre de gravite dois etre placé a l’intérieur du triangle des 3 pattes pose au sol + le contre poid de la patte en mouvement chose que l IK peut résoudre plutôt que

(je pense tu a du faire) teste les position et les valider par apporte a son basculement surtout si tu veux des déplacement rapide sans IK ça va vite devenir compliqué (des valeur pour déplacement lent / des valeur pour déplacement rapide / éventuellement des intermédiaire)

pour moi le faite d être seul dessus, bloquer sur des incompréhension sans avis extérieur a était un gros frein donc si tu te lance sur ton IK si tu veux je veux bien travailler dessus avec toi

[Vaelan]

 

Tu a étudié à L'ESIX en Normandie a Caen ??

Lol j aurais aimé mais non , j ai un simple BEP mécanique Auto d un lycée professionnel du sud de la france

[AlexBotMaker]

Ah d'accord ^^ parce que tu m'avait partagé un document de cette école. Je l'intègre en septembre la !

[AlexBotMaker]

Merci pour t'es éclaircissement et ton aide ! c'est sympa

 

j'imagine alors qu'il nous faut toutes les mesures des différentes articulation du robot pour commencer ?

 

Mon robot a tout ces servomoteurs a 90° ou 1.5ms lorsqu’il est en position debout, c'est judicieux ?

 

Puis faut que je trouve les 3 angles présent dans le triangle d'une patte ?

 

La ou je bug un peu c'est en gros comme si on mettait le robot dans un plan ou le centre du plan est le centre de gravité ? Puis par la suite grâce au  coordonnée (x,y,z) en 3 dimensions le plan du robot eux-même utiliseront des "gait" ou "démarche" et ces méthodes connaisse les mouvement de base comment lever et poser une patte par exemple ?

[Vaelan]

Je t avouerais que sur mon hexapode je l ai pas finis et je ne me suis pas occupé de la marche .Même si ce sont deux chose intimement lie se sont deux processus différent .
En effet la cinématique inverse va redéfinir la position de l extrémité des pattes selon les mouvement de ton point de contrôle (généralement le centre de mon hexapode pour moi (je n ai pas de problème de gravité avec 6 patte) et sur un Quadrupède son centre de gravite. Se mouvement peut être induit par une commande de marche , des capteur du style Gyroscope ,Accéléromètre(donc pas de gaits ) , ou des posture d expression (sur mon hexapode posture défensive s il se sent menacé par exemple) .
Tu dois commencer par te demander qu elle mouvement ton robot dois être capable de faire sans lever les pattes.
selon moi le minimum : mouvement sur la hauteur
                                     mouvement sur la largeur
                                     mouvement sur la longueur
ta cinématique gère les coordonnée (X,Y,Z) avec des offset fixe, tu travail donc avec des plans.
 
pour mon robot j ai rajouté: Tangage (bascule avant arrière)
                                            Roulis (bascule droite gauche)
                                            Lacet (rotation droite gauche)
On peux alors imaginer que je ne contrôle plus un point sur des plans mais une sphère qui se déplace
sur les plans (X,Y,Z) pouvant avoir une rotation sur elle même ça ne rend pas la cinématique plus complique en elle même
mais les offset deviennent dynamique.
la ou moi je bloque (bien que j ai entrevue un début de solution) c est la distribution d offset dynamique sur une seul fonction IK
 
sur mon hexapode les patte peuvent se toucher (se qui n ai peut être pas le cas de ton quadrupède) du coup avec la cinématique
inverse je pourrais définir les limites dynamique de chaque patte par apport a sa voisine est définir des méthode de marche optimisé en vitesse et amplitude, mais j en suis pas encore la
 
Donc tu vois que chaque robot a des caractéristique différente et pourquoi la cinématique d un robot ne peut pas marcher sur son cousin pourtant proche mais le principe et sa construction reste la même 

[AlexBotMaker]

D'accord j'ai bien tout relu ^^

et j'ai déjà fait ça pour un peu organiser le travail.

//Robot.ino

#include "Arduino.h"
#include "Robot.h"
      
void setup()
{
  Serial.begin(9600);
}

void loop()
{
   if (Serial.available() > 0)
   {
     char ch = Serial.read();
   
     switch(ch) {
       case 'a':
       tibias();
       debout();
       break;
      case'b':
       for(int i =0; i <7; i++)
        {
        avancer();
        }
        case'c':
        for(int i =0; i <4; i++)
        {
        tourner_droite();
        }
        break;
        case'd':
        for(int i =0; i <4; i++)
        {
        tourner_gauche();
        }
        break;
  
     }
   }
}

#include "Arduino.h"
#include "Robot.h"

void Protocole(double Numservo, double mouvement, double temps)
{
  String avancer = "#";
  avancer.concat(String(Numservo,DEC));
  avancer.concat("P");
  avancer.concat(String(mouvement,DEC));
  avancer.concat("T");
  avancer.concat(String(temps,DEC));
  Serial.println(avancer);
}


void Move(double x, double y, double z)
{
  //debout equivaut a (0,0,20) en coordonnée ...)
  
  
  
  
}



/**************Demarche*****************/



void debout() 
{
  for(int i=16 ; i<=28; i ++)
  {
  Move(i,1500,1000);
 
  }
}

void avancer()
{
   /***********************ARR_DROITE******************************/
   
   Move(17,2000,50); 
   delay(Temps2);
   Move(16,1700,Temps);
   delay(Temps2);
   Move(17,1500,Temps); 
   delay(Temps3);
   Move(16,1300,Temps3);
   
   /***********************AV_DROITE******************************/
   
   //Move(19,1400,Temps);
   delay(Temps2);
   Move(20,2000,50); 
   delay(Temps2);
   Move(19,1700,Temps);
   delay(Temps2);
   Move(20,1500,Temps); 
   delay(Temps3);
   Move(19,1500,Temps3);
   
  /*************************ARR_GAUCHE****************************/
  
   Move(23,2000,50); 
   delay(Temps2);
   Move(22,1200,Temps);
   delay(Temps2);
   Move(23,1500,Temps); 
   delay(Temps3);
   Move(22,1700,Temps3);
   
   /***********************AV_GAUCHE******************************/
   
   //Move(25,1600,Temps);
   delay(Temps2);
   Move(26,2000,50); 
   delay(Temps2);
   Move(25,1300,Temps);
   delay(Temps2);
   Move(26,1500,Temps); 
   delay(Temps3);
   Move(25,1500,Temps3);
}


void tourner_droite()
{
  
     /*************************ARR_GAUCHE****************************/
  
   Move(23,2000,50); 
   delay(Temps2);
   Move(22,1100,Temps);
   delay(Temps2);
   Move(23,1500,Temps); 
   delay(Temps3);
   Move(22,1500,Temps3);
   
      
   /***********************AV_GAUCHE******************************/
   
   //Move(25,1600,Temps);
   delay(Temps2);
   Move(26,2000,50); 
   delay(Temps2);
   Move(25,1100,Temps);
   delay(Temps2);
   Move(26,1500,Temps); 
   delay(Temps3);
   Move(25,1500,Temps3);
   
   /***********************AV_DROITE******************************/
   
   //Move(19,1400,Temps);
   delay(Temps2);
   Move(20,2000,50); 
   delay(Temps2);
   Move(19,1100,Temps);
   delay(Temps2);
   Move(20,1500,Temps); 
   delay(Temps3);
   Move(19,1500,Temps3);
   
   
    /***********************ARR_DROITE******************************/
   
   Move(17,2000,50); 
   delay(Temps2);
   Move(16,1100,Temps);
   delay(Temps2);
   Move(17,1500,Temps); 
   delay(Temps3);
   Move(16,1500,Temps3);
  
}


void tourner_gauche()
{
    /***********************ARR_DROITE******************************/
   
   Move(17,2000,50); 
   delay(Temps2);
   Move(16,1850,Temps);
   delay(Temps2);
   Move(17,1500,Temps); 
   delay(Temps3);
   Move(16,1500,Temps3);
   
   /***********************AV_DROITE******************************/
   
   //Move(19,1400,Temps);
   delay(Temps2);
   Move(20,2000,50); 
   delay(Temps2);
   Move(19,1850,Temps);
   delay(Temps2);
   Move(20,1500,Temps); 
   delay(Temps3);
   Move(19,1500,Temps3);
   
  /*************************ARR_GAUCHE****************************/
  
   Move(23,2000,50); 
   delay(Temps2);
   Move(22,1850,Temps);
   delay(Temps2);
   Move(23,1500,Temps); 
   delay(Temps3);
   Move(22,1500,Temps3);
   
   /***********************AV_GAUCHE******************************/
   
   //Move(25,1600,Temps);
   delay(Temps2);
   Move(26,2000,50); 
   delay(Temps2);
   Move(25,1850,Temps);
   delay(Temps2);
   Move(26,1500,Temps); 
   delay(Temps3);
   Move(25,1500,Temps3);
}

void tibias()
{
  Move(18,1470,Temps);
  Move(21,1470,Temps);
  Move(24,1470,Temps);
  Move(27,1470,Temps);
}

  #include "Arduino.h"
  
  /*****Mesure********* (mm)*/
  const int coax=41;
  const int feemur=53;
  const int tibiat=98;
  /*******PLAN********* Point de départ du robot (mm)*/
  const int X_distance_patte =120;
  const int Y_distance_patte =80; //centre vers l'extrémité des pattes
  const int Z_distane_patte =20;   //Offset fixe hauteur  
 
  
   /*******RAPIDE*******/
   const int Temps=50;
   const int Temps2=100;
   const int Temps3=400;
   /*******LENT********
   int Temps=500;
   int Temps2=1000;
   int Temps3=2000;
   
   /********************FONCTION**************************/
   void Protocole(double Numservo, double mouvement, double temps);
   void Move(double x, double y, double z);
   void debout();
   void avancer();
   void tourner_droite();
   void tourner_gauche();
   void tibias();

[Vaelan]

étant novice en la matière je te dirais que j aurais fais pareil pour le module déclaratif :

Variable constante

prototype de fonction

 

pour le corps du programme:

setup :

j aurais rajouté une position de départ pour le robot histoire de pas avoir de

surprise à sa mise sous tension et ne pas risquer de cramer un servo.

loop:

la je ne ferais que des appel de fonction, j'éviterais de placer de la logique a cette

endroit ça me permettrais d activer ou désactiver des fonctions simplement pour 

test

 

le module de mouvement:

Euh la je dirais que ça pique un peux les yeux c est trop répétitif (bien que la fonction

Move() soit je pense prévu pour ca)

plusieurs façon pour résoudre ça :

soit avec un tableau dans le module déclaratif avec tes servo (je vois que tu n as 

aucune correction sur tes servo ....)moi j ai du redéfinir tout les min et max de mes servo

mais si tu as la chance d'avoir tout tes servo avec des course identique alors de simple boucle

suffiront.

j ai pas compris pourquoi tu a séparé le mouvement des tibia pour le deplacement? 

 

manque(pour bien structurer tout de suite):

module communication:

          Protocole()

          port série

          "radiocommande"

          "Bluetooth"

          "Wifi"

prévoir(selon évolution):

module capteur

module IK

 

Etant novice j'espére que je suis pas trop a cote de la plaque mais je suis sur que de expert en 

programmation viendront me corriger pour me faire avancer aussi

 

[AlexBotMaker]

Merci pour ta réponse

Tu parle de la méthode Protocole ou Move ? Laquelle des deux pics les yeux ^^

 

Mais au final toi tu avait quoi comme autre mesure de ton robot ?

quelle théorème tu utilisait ?

Faut il une méthode pour calculer les angles dans le triangle de la patte ?

 

En gros je dois mapper mes articulations ? poser des limites pour chaque servomoteur ?

[Mike118]

Ce qui pique les yeux à mon avis ( et qui me pique les yeux un peu à moi aussi ) C'est le fait de répéter N fois des choses " très similaire " 

 

   Move(23,2000,50); 
   delay(Temps2);
   Move(22,1850,Temps);
   delay(Temps2);
   Move(23,1500,Temps); 
   delay(Temps3);
   Move(22,1500,Temps3);
   
   /***********************AV_GAUCHE******************************/
   
   //Move(25,1600,Temps);
   delay(Temps2);
   Move(26,2000,50); 
   delay(Temps2);
   Move(25,1850,Temps);
   delay(Temps2);
   Move(26,1500,Temps); 
   delay(Temps3);
   Move(25,1500,Temps3);

Afin de réduire cela tu peux faire une fonction : 

tourneGauchePatte(int i ) 
{
    Move(17+3*i,2000,50);
    delay(Temps2);
    Move(16+3*i,1850,Temps);
    delay(Temps2);
    Move(17+3*i,1500,Temps);
    delay(Temps3);
    Move(16+3*i,1500,Temps3);
}

Après tu as plus qu'à appeler cette fonction et mettre i = 0 puis 1 puis 2 puis 3  voir même faire une boucle " for "  

Après il y a aussi d'autre truc à éviter : Je te déconseille de mettre des chiffre en dur du style 16 , 1500 etc... Essaye d'utiliser au maximum des #define =)  ainsi si un jour pour une raison x ou y tu as besoin de changer 1500 en 1650  tu auras juste à changer le define et pas à changer chacune de tes lignes de codes. 

Enfin, utiliser les tableau et les structures c'est vraiment un bonne habitude à prendre. 

Voir mon petit tuto sur les structures

[Vaelan]

+1 mike118 

 

Sur un tuto que j ai regardé sur le net un prof(je ne me rapelle plus son nom je suis dsl pour lui) disait: "il n'y a pas de mauvaise façonde programmer , mais celle que l on connais" cette phrase à était un grand soulagement pour moi

Par contre structurer un programme et apprendre a le commenter est , a mon sens, essentiel et une priorité quand on veut apprendrea coder. Au fur et a mesure que l on progresse on cherche toujours a optimiser le code , améliorer nos machine et c est désespérantde devoir tous recommencer a zéro parce qu on ne retrouve plus la ligne de code qui correspond ou trop de changement a faireou bien encore retrouver un bug dans un "labyrinthe sans plan".

 

concernant mon hexapode en lui même j en suis a peine plus loin que toi j ai juste une radio 9 voies en plus une fois qu il a marché je me suis consacré a la cinématique inverse qui doit être le cœur du programme ensuite dans l ordre viendra gyroscope/accéléromètre, les style de marche,autre capteur ,comportement

 

concernant la cinématique inverse je ne me suis pas lancer dedans en programmation directement, je me serais pris les pieds dans le tapis, j avais créé un post sur se forum y a a peut prêt un an mais je me suis arrête a 30 ou 40 % de la cinématique complète, je suis alle plus loin par la suite mais j ai pas pris le temps de compléter mon post (vais peut être m'y remettre, au moins corriger les incohérence de correction roulis/tangage).

Sinon je n'utilise que de la trigonométrie Pythagore/Al-kashi tu peut tout faire avec ça, y a surement mieux .

Je me suis intéressé a la trigonométrie sphérique mais bon ça a commence par des figures géométrique à deux sommet ,ca m as effrayé j ai arrêté tout de suite )calcule matriciel , pareil je nage ....

 

Après le principe est simple tu définis la position de départ de l'extrémité de ta patte(celle que je t ai dis de placer dans le setup par exemple), tu prend la hauteur de l offset avec la distance de l aplomb de l'offset à l'extrémité de la patte, ca te donne 2 cote d'un triangle rectangle dont tu peux calculer le troisième cotés avec Pythagore maintenant tu connais ce troisième cotés ,la longueur du fémur, la longueur du tibia te voilamaintenant avec un triangle quelconque dont tu connais tout les cotés y a plus qu a calculer tes angles avec Al-kashi  tu applique ça dans tous les sens de mouvement de ton robot.

Voila c est pas très compliqué faut juste pas s emmêler les pinceau

[AlexBotMaker]

Merci pour ton rappelle mike118 ! Je n'y ai même pas pensé à faire sa !

ça réduit la taille du programme efficacement !

 

Je crois avoir compris maintenant a peu près a quoi sa sert l'inverse kinematics ^^

Voici les changements que j'ai apportée rapidement hier soir :

#include "Arduino.h"
#include "Robot.h"
      
void setup()
{
  Serial.begin(9600);
  
  for(int i=16 ; i<=28; i ++)
  {
  Deplacement(i,NEUTRE,1000);
  }
}

void loop()
{
   //test
   avancer();
}

#include "Arduino.h"
#include "Robot.h"

void Move(double x, double y, double z)
{
 
  
}


/******************IK*********************/


void IK()
{
  double L = sqrt(HAUTEUR/EMPATTEMENT); //Calcul de l'hypothénuse (Pythagore)
  
  double alpha = acos((-pow(FEMUR,2) + pow(TIBIAS,2) + pow(L,2))/ 2*TIBIAS*L);
 
  double beta = acos((pow(FEMUR,2) - pow(TIBIAS,2)- pow(L,2))/ 2*FEMUR*L);
 
  double gamma = acos((pow(FEMUR,2) + pow(TIBIAS,2) - pow(L,2))/ 2*FEMUR*TIBIAS);
  
  double Move = alpha*16.6;
  double Move1 = beta*16.6;
  double Move2 = gamma*16.6;
  
  for(int i=Move; Move <=2300; i++)
  {
  Deplacement(17, Move ,1000);
  }
  
  for(int i=Move1; Move1 <=2300; i++)
  {
  Deplacement(18, Move1, 1000);
  }
  
  Deplacement(18, Move2, 1000);
    
}

/**************Demarche*****************/


void avancer()
{
  int i=0;
  
   for(i=0; i<=1 ; i++)
  { 
    Deplacement(17+3*i,FEMUR_HAUT,Temps);
    delay(Temps2);
    Deplacement(16+3*i,COAX_AVDROIT,Temps); 
    delay(Temps2);
    Deplacement(17+3*i,NEUTRE,Temps);
    delay(Temps3);
    Deplacement(16+3*i,COAX_ARRDROIT,Temps3);
  }
  
     for( i=2; i<=3; i++)
  { 
    Deplacement(17+3*i,FEMUR_HAUT,Temps);
    delay(Temps2);
    Deplacement(16+3*i,COAX_AVGAUCHE,Temps); 
    delay(Temps2);
    Deplacement(17+3*i,NEUTRE,Temps);
    delay(Temps3);
    Deplacement(16+3*i,COAX_ARRGAUCHE,Temps3);
  }
  
}


void tourner_droite()
{
  
  for(int i=3; i<=0; i--)
  { 
   Deplacement(17+3*i,FEMUR_HAUT,Temps); 
   delay(Temps2);
   Deplacement(16+3*i,TOURNER_DROITE,Temps);
   delay(Temps2);
   Deplacement(17+3*i,NEUTRE,Temps); 
   delay(Temps3);
   Deplacement(16+3*i,NEUTRE,Temps3);
  }
  
}


void tourner_gauche()
{
   for(int i=0; i<=3; i++)
   { 
   Deplacement(17+3*i,FEMUR_HAUT,Temps); 
   delay(Temps2);
   Deplacement(16+3*i,TOURNER_GAUCHE,Temps);
   delay(Temps2);
   Deplacement(17+3*i,NEUTRE,Temps); 
   delay(Temps3);
   Deplacement(16+3*i,NEUTRE,Temps3);
   }
}

void tibias()
{
  Deplacement(18,1470,Temps);
  Deplacement(21,1470,Temps);
  Deplacement(24,1470,Temps);
  Deplacement(27,1470,Temps);
}


void Deplacement(double Numservo, double mouvement, double temps)
{
  String bouger = "#";
  bouger.concat(String(Numservo,DEC));
  bouger.concat("P");
  bouger.concat(String(mouvement,DEC));
  bouger.concat("T");
  bouger.concat(String(temps,DEC));
  Serial.println(bouger);
}

#include "Arduino.h"
  
/*****Mesure********* (mm)*/
#define  COAX 41
#define  FEMUR 53
#define  TIBIAS 98
#define HAUTEUR 20
#define EMPATTEMENT 50
/**************************/
#define X_DISTANCE 120
#define  Y_DISTANCE 80     //centre vers l'extrémité des pattes
#define  Z_DISTANCE 20     //Offset fixe hauteur  
 

#define NEUTRE 1500
#define FEMUR_HAUT 2000
#define FEMUR_BAS 1000
#define TIBIAS_HAUT 1800
#define TIBIAS_BAS 1200
#define COAX_AVDROIT 1700
#define COAX_ARRDROIT 1300
#define COAX_AVGAUCHE 1300
#define COAX_ARRGAUCHE 1700

#define TOURNER_DROITE 1100
#define TOURNER_GAUCHE 1900

  
/*******RAPIDE*******/
#define Temps 50
#define Temps2 100
#define Temps3 400
/*******LENT********
#define Temps 500
#define Temps2 1000
#define Temps3 2000

   
   
   /********************FONCTION**************************/
   void Deplacement(double Numservo, double mouvement, double temps);
   /******IK*****/
   void Move(double x, double y, double z);
   void IK();
   /****Deplacement****/
   void debout();
   void avancer();
   void tourner_droite();
   void tourner_gauche();
   void tibias();

[Vaelan]

c est mieux , je te laisse gérer la suite de la prog. moi je suis sur un RPI2 et  en python du coup j ai pas trop développe le C

par contre (sauf erreur de ma part) "COAX","FEMUR","TIBIA" devrais etre des constante.

 

Maintenant niveau IK la je peux t'aider, dans tes déclaration il va te manquer la hauteur du corps de ton robot pour définir la position la plus basse a laquelle ton robot peu marcher et les distance entre les axe servo avant => arrière et droite => gauche pour définir les offset

 

après tu dois me dire quel sont les mouvement que tu veux pouvoir faire 

 

exemple offset pour IK simple (hauteur , latéral , longitudinal )

Offset Y = longueur corps / 2 + le déplacement du centre sur Y

Offset X = largeur corps / 2 + le déplacement du centre sur X

Offset Z = hauteur - (hauteur corps / 2) + déplacement du centre sur Z

 

exemple offset pour IK complet (hauteur , latéral , longitudinal , lacet , roulis , tangage)

Offset Y=longueur corps / 2 x sin(Lacet) x cos(tangage)  + la valeur déplacement du centre sur Y

Offset X=largeur corps / 2 x cos(lacet) x cos(roulis) +  la valeur déplacement du centre sur X

Offset Z=(hauteur - (hauteur corp / 2)) x sin(roulis) x sin(tangage) + la valeur déplacement du centre sur Z

 

Maintenant l intérêt de l'IK? Ne contrôler que le centre de ton robot sans te préoccuper d ou se trouve le début de tes pattes .Le calcule des angles de servo commence à l endroit des Offset. Une fois programmé tu n auras plus à définir chaque servo et l IK va gérer les angles servo mais aussi leur vitesse (plus de patte qui glisse au sol COOL) , tu pourras alors créer des fonctions de cycle de marche en définissant ,l ordre de marche, l amplitude des pas  et sur la fonction de commandes ça vitesse de déplacement GÉNÉRAL (donc sont centre )

[AlexBotMaker]

Ben j'ai mis en #define coax, femur etc c'est pas bon ?

J'ai du mal a comprendre un offset c'est une valeur fixe que tu défini ? j'ai un peu du mal a comprendre la dsl ^^

 

La mesure pour la hauteur, je la prend quand le robot est debout ?

et les distance entre les axe de servo ceux du coax ? tu veux dire

 

Al-kashi donne les valeurs des angles en radian j'imagine ?

 

Bon je vais faire des test c'est le mieux pour se rendre compte que mon programme fait nimp ^^

[Vaelan]

la différence entre define et constante est subtile mais importante pour faire tres simple

 

define est une macro 

 

#define M 40

valeur = M

ou 

valeur = 40

c est pareil.

define remplace tout les M par 40 par defaut sans qu'il n est la valeur en memoire 

ainsi un servo dont la position va évoluer au grès du programme mais dont la valeur

de départ est 40 et se répète a plusieurs endroit sera définit par un define pour te permettre

de modifier cette valeur en une seul saisie meme si elle est répété x fois dans ton programme

 

const est un variable 

 

const int M=40

valeur = m

ou

valeur = 40

sont deux entité différente avec la même valeur 

les élément de ton robot telle que le tibia ou fémur sont des parties en dur de ton robot et non modifiable

ce n est pas une valeur par défaut qui va évoluer ou que tu peux substituer a ton robot tu utilise donc

une constante . 

 

pour les offset et principe de la cinématique inverse je t es fait un petit shema.C est peut etre plus simple

de le visualiser 

 

la Hauteur correspond a la hauteur du sol au centre du robot par défaut

Exemple sur ma radio le potar qui controle la hauteur (-10 +10) la hauteur par defaut c est 0 

[Vaelan]

exemple du mouvement de Lacet

position initial: Les Offset sont facile à définir

 

rotation de Lacet: Les Offset sont modifié par l angle de lacet

 

Il en va de même pour toutes les autres rotations.

Maintenant si avec ta radio tu lui demande de suivre le sens de marche(je te rappel que ta radio ne contrôle

que la croix rouge au CENTRE) alors que son corps est en torsion la cinématique inverse connait la position

de départ de chaque pattes et peu calculer le mouvement de chacune d'elle alors même qu'aucune d'elle ne

bouge de la même façon .

 

Dis moi ce que tu n as pas cerné avant la suite;)  

 

[Oliver17]

Intéressant, sans pourrir le post, juste une question, ça fonctionne aussi pour un hexapode ?

 

Merci

[Vaelan]

mon robot est un hexapode;) son petit nom CR6VA1 

 

[Oliver17]

Et on peut le voir sur le forum ?

Du moins y a un post à sont sujet ?

 

Edit : vu