Salut AlexBotMaker
Je suis tres interresse par ton post , car je travail au programme de mon hexapode 3ddl (arduino,ssc32,18servo 180º) nom de code CR6VA1 et je me suis basé sur le meme principe que toi , a savoir pythagore et Al-kashi.
Pour ma part je suis partis sur une posture d origine , hauteur=longueur tibia/servo femur 90º et l empatement=(femur+tibia)/2 cette position correspond sur ma radio a tout les manche et inter au centre et des mouvements les plus amples possibles a CR6VA1 une fois que tu as trouvé celle ton ton quadri ca va tout seul :

 

https://tube.geogebra.org/m/1373193

 

Je suis seul sur mon robot et je manque d avis critique donc si ca peux d'aider ou si tu vois des amelioration a apporter suis prenneur.

N ayant aucune notion en math ni en programmation je m eclate a le faire.
Bon courage

coucou,

je continue a travailler dessus mais je manque un peu de temps. les commandes corresponde "aux commandes de ma radio" je te mets un autre fichier avec toute les commandes que je compte utiliser avec l'IK: https://tube.geogebr...show/id/1392051si tu as des idées des critiques ou amélioration a apporter suis prenneur;)) a terme (si j arrive a créer ma cinématique) c est de la gérer avec un gyroscope 3 axe de l'un de mes hélicos.

super travail pour ton quadri moi j ai pas eu ton courage (le châssis je l'ai acheté)niveau prog t'en ai ou ? 

 

une petite vidéo pour la présentation de CR6VA1 :  

Salut,

  j avance dans ma cinématique ) Une petite précision ,dans ma vidéo pas de cinématique mais des angles programmer angle par angle ma radio ne contrôle que la vitesse et quelque position sur les inter.... ma cinématique est loin d être finis mais elle avance bien et géogébra me confirme le bon fonctionnement de mes équation (qui resterons a simplifier par la suite).d' ailleurs pour ne pas polluer ton post je pense que je vais créer le mien pour une explication pas a pas de mon raisonnement peut être particulier et peut orthodoxe, vu mon niveau en math, mais fonctionnel ) 

 

A chaque robot ses contrainte.Moi je me suis imposer un gyroscope 3 Axes d'ou l'implantation du roulis et tangage dans ma cinématique .Quand a ton quadri (vi vi j y ai réfléchis..) je pense que tu peux te passer du roulis/tangage/lacet, mais tu dois inclure dans tes équation son centre de gravite qui ne dois jamais être devant la diagonal des pattes adjacente a celle qui se lève (suis pas sur d'etre clair.....).Rien de compliqué mais une contrainte importante pour un quadri, selon sa vitesse de déplacement son inertie peut avoir une importance aussi mais je pense que pour commencer tu peux t'en passer.

 

pour tes question sur les coordonnés heu...... cylindrique: je sais pas ce que c est...... cartésiens: suis pas sur, ma radio contrôle le centre de mon robot en hauteur largeur longueur + 3 axe de rotation et déplacement on peut considérer ça comme cartésien mais j ai viré les repéré de geogebra qui ne me serve a rien ... je pense que ce n est que du calcul d angle en gros le but c est de lui dire "avance/tourne/baisse toi .... " et il se débrouille a calculer le reste en plus de compenser les dénivelé du terrain mais pas de données genre (X,Y,Z)

 

En ce qui concerne l'arduino pour l instant je finis la cinématique inversé et je me lance dans la programmation (je n ai appris que ce que j avais besoin pour le faire avancer ) j' avoue que je comprends pas la moitié de ton code mais je vais faire comme toi je vais m inspire de ce que tu as fais pour trouver des structure et raisonnent qui correspondent à mon robot.

 

Une fois mon post créer je compte sur toi pour des critiques constructive et je continu à suivre l'avancement de ton robot avec beaucoup d’intérêt      

Bonjour à tous 

Je suis Vaelan mon niveau d'étude se limite à un CAP mécanique auto ,je travaille dans le batiment et j arrive du monde de l’aéromodélisme qui m as fais découvrir celui des microcontrôleur.J ai donc décidé de quitter la planète des hélicos pour partir à l'aventure à travers l'univers de la robotique.

 

Je me suis donc offert le châssis d'un hexapode sur lequel j'ai monté une Arduino un SSC32 et 18 servo a 180° le tout commandé avec ma radio aurora9.

 

 

Après quelque essaie les premier problème se son posé: trajectoire mal maîtrise ,les pattes glisse sur le sol,programmation patte par patte laborieuse..... je me suis donc lancé dans la programmation d'une cinématique inversé .Une petite recherche sur supergoogle et ..........WAOUH.....ça à l'air super compliqué et pour la plupart en anglais.

Donc j'ai décidé de me créer la mienne à moi perso )))

 

Je vais donc vous exposer mon travail (dans les jours, les semaines, les mois qui viennent) pour que les meilleur d'entre vous, puisse me donner des critiques constructive et ne connaissant pas les normes du langage mathématique,me corriger si je ne suis pas clair dans mes explication ou que je suis dans l erreur.Pour ceux,qui comme moi voudrais se lancer, leur donner peut être une orientation.

 

Pour commencer mon cahier des charge:

ma radio ne dois contrôler que le centre de mon hexapode.

la cinématique inversé dois pouvoir être contrôlé par un gyroscope 3 axes.

l hexapode dois gérer tout ses mouvements sans glissement et en respectant des trajectoire propre

 

  Voici les élément que je vais utiliser pour créer la cinématique inversé

pas grand chose donc mais pour l instant ça a l air de suffire.

les différente commandes à prendre en compte, notez que le roulis,tangage et lacet seront aussi géré ,a terme, par un gyroscope.

montage et course max des servos sur le robot.

Première étape, cinématique inverse vu de face:

J'ai définis un point d'origine (en gris sur le schéma) qui représente la position par défaut du centre de gravité de CR6VA1 quand toute mes commande de radio sont au neutre(position centrale pour les manche par exemple) et le centre de gravité réel (en violet sur le schéma)ainsi que l axe de roulis (en rouge) qui sont les seul valeur connu avec les mensuration du robot tout le reste dois être calculé par le programme.

lien dynamique,commande alti/lateral/roulis : 

Ce que je connais :

                                les variables constante

hauteur thorax : thha=2

largeur thorax:    thla=4

longueur thorax: thlo=6

coax                 : coax=1

femur               : femur=3

tibia                  : tibia=5

                                les variables

hauteur "d'origine" pour mon exemple je la définirais à 3 par défaut mais qui sera variable selon la posture choisi,

plus toute les commandes radio.

schéma dynamique: 

 

Pour un meilleur compréhension je ne vais traiter que des pattes centrale droite et gauche vue de face et je ne prendrais pas en compte non plus les modification induite par les mouvement des autres axes pour l instant.Mais tout les principes de calcule sont deja dans cette premiere vue.

Les valeurs manquante avant le calcul des angle de servo :

j ai déjà définis une hauteur par défaut =3 et je vais définir un empattement par défaut, j ai trouvé que (fémur+tibia)/2=4 était parfait.

les valeur "utile" et "carrossage" vont me servir a corriger la modification induite par le roulis sur l'empattement.Ce principe devra etre mis en oeuvre pour chaque axe(je compléterais les équation par la suite).

 

Les hauteur sont facile a trouver:

                                                       hauteur_O=hauteurParDefaut+alti

                                                       hauteur_D=hauteur_O+roulis

 

mais vous remarquerez ,sur la vu dynamique ci-dessous, que le roulis entraîne des parasites sur la position de l’extrémité de la patte.Je vais résoudre ce petit soucis avec pythagore.

 

 

calcul de l'empatement_D:

                                           distance réel, du centre de gravite   => axe fémur:  

                                           utile= thla/2+coax

 

                                           distance du centre de gravite => aplomb axe femur

                                           carrossage=sqrt(utile²-roulis²)

                                           

                                           empatement_D=utile+empatementParDefaut-carrossage+lateral

et voila c'est réglé:

 

Les hauteurs sont défini, l’empattement aussi.Il me manque le vecteur de la patte:

                                            vecteur_D=sqrt(empatement_D²+hauteur_D²)

 

 

 

 

 

 

 

 

 

 

 

me voila avec tout mes triangle, y a plus qu'a trouver les angles de servo pour mettre cette premiere patte en route. Suivis de quelque fonction pour la distribution à travers les 6 pattes   )

Pour le calcul des angle de servo en plus d'Al-Kashi, je vais utiliser le principe de proportionnalité (je crois que c est comme ça que ça s'appel)

En gros si une droite "A" est parallèle à une droite "B" et qu elle sont coupées par une droite  "C" il y a égalité de tout les angles aigus ainsi que pour les obtus (merci aux matheux de corriger ma définition si elle est pas bonne).

https://tube.geogebr...mple/id/1411615

 

Le calcul d'angle étant répétitif je vais quand même créer une fonction "angle" pour ça:

         angle(adj_1,adj_2,opp)=arccos((adj_1² + adj_2² - opp²)/(2 x adj_1 x adj_2))

 

j'ai déjà vu les couses max de mes servo de 180° pour le sens de rotation je reprend mon schéma de depart:

 

je calcul en premier lieu l'angle de mon vecteur:

        alpha_3 = angle(hauteur_D,vecteur_D,empatement_D)

https://tube.geogebr...mple/id/1412777

 

je calcul ensuite la valeur de l'angle de roulis,je dis la valeur parce que la, je vais avoir besoin de connaitre sa position positive ou negative

        valeurAlpha_2=angle(utile,carrossage,roulis)

pour definir sa position j ai créé une fonction sens:

       sens(valeurAngle,commande)=-valeurAngle x (commande / |commande|)

       sens(valeurAngle,commande)=SI(commande<0,-valeurAngle,valeurAngle)

Ce qui multiplie la valeur de l angle par + ou - 1 selon la commande utilisé

Ce qui placera un signe negatif devant la valeurAngle si ma commande est en négatif

Le principe de proportionnalité me dit que l angle de mon servo est modifié de la même valeur que l angle induit par le roulis. 

 

Et j obtient :

        alpha_2=sens(valeurAlpha_2,roulis)

https://tube.geogebr...mple/id/1412809

 

je calcule maintenant l angle entre le vecteur et le femur:

        alpha_1=angle(vecteur_D,femur,tibia)

https://tube.geogebr...mple/id/1412847

 

voila j'ai tout ce qu il faut pour connaitre l'angle réel de mon servo:

        angle servo: alpha=180°-(alpha_1+alpha_2+alpha_3)

https://tube.geogebr...mple/id/1412983

Je vais m'occuper maintenant du servo du tibia.

d abort debut et fin de course:

 

calcul de l'angle du tibia:

           gamma_1=angle(femur,tibia,vecteur_D)

l'angle du 2em servo:

           gamma=180°-gamma_1

vous pouvez bouger les commandes des 3 axes résolu, dans tous les sens et vous verrez que les pattes suivent parfaitement les mouvement du robot.

https://tube.geogebra.org/material/simple/id/1413059 

 

 

et voila la cinématique vu de face fonctionnel.

Au meme titre que l'axe de roulis il ne restera plus qu'a apporter les corrections sur les parasite des autres axes.

Je tiens à préciser( l'ayant fait dans un autre post, j ai oublié dans celui-ci) que sur les vidéo CR6VA1 ne fonctionne pas avec une cinématique inversé mais des angle de servo programmé et renvoyé avec une fonction ma radio ne contrôle que la vitesse des servo et 3 séquence de marche pour avancer et tourner.En gros un prog de noobs fais à l'arache  Pour répondre à ta question Northmaker, le tout fonctionne avec une ARDUINO UNO R3.

 

Pour en revenir à ma cinématique, après test de la première partie, je suis tombé sur un os avec ma fonction:

 

" sens(valeurAngle,commande)=-valeurAngle x (commande / |commande|)"

 

qui ne marche pas. En effet si la fonction multiplie bien la valeurAngle par -1 ou 1 quand la commande est a 0

la valeur renvoyé est non défini..... donc j ai corrigé la fonction (j ai découvert que c’était possible avec geogebra) avec la logique SI.:

 

sens(commande,valeur)=SI(commande<0,-valeur,valeur)

 

et ça à l'air de bien marcher.

N’hésitez pas à me renvoyer les erreurs que j aurais raté ou pas vu pendant mes test.

 

je continue a travailler sur la suite de ma cinématique inversé

Que ca marche pas du premier coup c est souvent le cas pour moi ( plusieur servomoteur hs dans mon bazard peuvent en temoigner ).
Tes photos sont trés flou , on a du mal à comprendre les branchements . As tu fais un schema avant de souder tous ca?
Si c est le cas post le

salut Alex
En faite Oracid veut parler de MODULE ou librairie en arduino je pense , sinon avec l IDE arduino tu peux séparer tes differentes partie de programme avec des onglets (bouton carre avec un flèche vers le bas en haut a droite).
Voila bien longtemps que mon robot et dans le placard par manque de temps mais ton superbe robot me donne avis de mis remettre )
J'ai regardé ton programme qui ressemble beaucoup à mon premier ) par contre si je peux me permettre tu devrais t'intéresser à une programmation Asynchrone parce que les "delay" mettent tout ton programme en pause , pour l instant pas gênant mais quand tu vas vouloir le télécommander ou mettre en place une cinématique inverse tout un série de problème vont apparaître, même si le SSC32 compense avec la vitesse des servo , mouvement parasite, retard de mouvement, tremblement .......

salut 

en mode bricolo/ servo a rotation continu ou petit moteur de recup je te propose :

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. 

 

 

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

 

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

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 

é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

 

Impressionnant!!!

bravo

+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

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 )

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 

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;)  

 

mon robot est un hexapode;) son petit nom CR6VA1 

 

 

 

Pas mal ! j'avoue, il y a beaucoup de travail !

Même si c est pas complet c est gentil ,merci.

 

 

 

se que je comprend pas c'est comment ensuite je met tout en relation ? comment je fait bouger mes pattes comme je veux ? comment je réutilise ces angles et le reste de ces mesures pour pouvoir enfin voir mon robot marcher normalement et non comme Frankenstein ^^

La je vois pas.......

meme si elle n est pas complete la cinématique calcule les angles, tu les applique a tes servo. C'est quoi la relation que tu comprends pas?

 

sans la cinématique inversé:

http://www.geogebra.org/m/apkw5gdx

 

Avec la cinématique inverse:

http://www.geogebra.org/m/mDdgAGPJ#material/zErDBVzc

 

Les curseurs programmés sont en VERT et il ne contrôle que le point "centre" en violet les angles étant obtenu avec la cinématique inversé . Malgré les mouvements que tu appliques au corps du robot l extrémité de la patte reste parfaitement à sa place sans mouvement à la "Frankenstein" ni glissement au sol .Tous les servo sont en mouvement quand tu bouge les commandes.

Après appliquer la valeur de la fonction "angle" à GAMMA de geogebra ou au servoTibia de ton robot je vois pas de différence à part un MAP de la valeur de l angle en PWM.

 

 

 

Moi mon problème n'est pas de reprendre ces calculs ou Al-kashi

As tu vraiment compris la cinématique inversé? comment elle fonctionne et à quoi elle sert?

 

 

 

il y a juste hauteur_corps et hauteur la différence ou je suis pas sur, il s'agit de l’épaisseur du corps du robot !

 

hauteur_corps est la hauteur physique du corps de ton robot

Hauteur est la distance entre le sol et le centre de ton robot

 

Dans ton code "const int et #define" toujours pas bon.

les longueur physique de ton robot sont invariable donc se sont bien des constantes

par contre hauteur et empattement sont des valeurs par défaut qui servent a initialiser des variables et que tu pourras changer dans l avenir donc tu dois les définir par des #define  

Apparemment tu veux faire très simple et le voir marcher rapidement donc oublis les Offset uniquement la marche (avancer et tourner ).Voila le principe et ou ça ne va pas , il faut rajouter l angle de COAX aussi.

 

 

 

 

alpha = acos((pow(FEMUR,2)+ pow(L,2) - pow(TIBIAS,2))/ (2*FEMUR*L));
beta = acos((pow(FEMUR,2) + pow(TIBIAS,2) - pow(L,2))/ (2*FEMUR*TIBIAS));

alpha est incomplet!..

 

 

En faisant varier la longueur du Vecteur de  marche tu obtiendra le mouvement avant/arrière 

En faisant varier la longueur du Vecteur de direction tu le feras tourner et le pied suivra toujours le Vecteur de marche et donc pas de glissement ni mouvement bizarre(attention, la valeur ajouter ou soustraite au Vecteur de direction d'une patte dois toujours être l inverse de ces voisines)

pour lever une patte, on soustrait de la valeur Hauteur de l IK sur la patte voulu la hauteur a laquelle on veux qu elle se lève.

Ma cinématique ne fonctionne pas comme ça, je n ai donc pas testé cette version.Mais c est la plus simple qu on peux mettre en place (supprimer : longitudinal, latéral, roulis, tangage, Lacet) difficile de tester sans le faire marcher 

 

Niveau calcule tu m as dis que ça ne te posais pas de problème, je te laisse faire et je te corrigerais