Ça fais bien longtemps que je rêve d'une imprimante 3D et ton sujet va peut être me faire sauter le pas en me faisant découvrir la 

 surtout si elle doit tourner la nuit

Impressionnant!!!

bravo

 Je suis très intéressée par la méthode de Mike118 y a juste une chose très importante! une commande ne se soustrait JAMAIS.

DiffX ( patte avant droite ) = DiffX0 - lateral

 DiffY(sens) = DiffY0 + sens*longi ;

Quand on fais une commande +1 tout les offset se déplace dans la même direction donc c est +1 pour tous les offset.C est l Offset d'origine qui doit être positif ou négatif selon le cote ou le sens.

 

// initialisation des positions 

tableDePosition[0].longi=0;

tableDePosition[0].lateral=0;

tableDePosition[0].alti=0;

Ça je comprend pas .... Si c'est pas une erreur je suis très intéressé (ça ressemble beaucoup a un objet)

mais l approche des tableau peu être très  intéressante.

 

 

 ce qui est noté x et y en fait c'est bien ces diffX et diffY

Ca c'est OK. J'ai fais la différence parce que la partie "Cinematique_inverse" peut servir pour d'autre chose en créant un nouveau module utilisant la "Cinématique_inverse" je voulais que ça reste clair au niveau de "x,y,z" et ou les "Diff" n'auraient pas de sens.

"aff" c'est juste une variable qui sert d interrupteur pour afficher les données une seul fois (vu que la fonction est appelé dans le "loop")quand on envoie une commande.

je préfère la "Programmation Orienté Objet" c'est pour ça que j'ai utilisé cette structure, tu peux décider de modifier le comportement du thorax dans "Position_corps" sans te préoccuper du fonctionnement de l'IK ou des pieds du robot idem pour les autres modules ,quelque soit le comportement du thorax ou des pieds l'IK gère ce qu il se passe entre les deux.

je pense que ça peu être la racine du programme de ton robot mais tu dois la comprendre et la maîtriser sur le bout des doigt et tu verras que tu peux tout faire avec . Un robot sur roue avec des capteur, le faire tourner selon les obstacle c'est "facile", avec nos robot à pattes ça devient tout aussi "facile" avec la cinématique inversé.

La partie "TEST" n'est juste la que pour te montrer que ça marche avant de le mettre sur ton robot et j ai calibré mes commande sur 1 unité(cm)pas asses fin pour des beau mouvement et  c'est a remplacer par ton "protocol" maintenant que tu as les angles en degrés un simple "MAP" pour envoyer les données a tes servo .

ATTENTION c'est pas complet je ne t es pas mis les correction IK , limitation physique,Tempo, les genres de pas et les styles de marche  de ton robot pour deux raison :

1 ) je les connais pas toutes et c est a toi de décider ce que dois faire ton robot.

2 ) j' ai longtemps bloqué sur des détails ou une mauvaise approche parce que je travaillé seul dessus, ta vision n'est pas la mienne donc je compte sur toi pour m'en m'apporter de nouvelle ou une nouvelles approche (D’ailleurs merci Mike 118 niveau prog. je pense que ta solution va m apporter beaucoup).

moi j ai fais un petit truc pour une base de travail (désolé pour mon niveau de programmation les critiques son les bienvenu)

Pour mon exemple j ai utilisé les onglet ("fichier") disponible avec l IDE arduino ,le trie se fait par ordre alphabétique donc j ai placé une lettre avant le nom voulu pour les mettre dans le bonne ordre

Ouvres le moniteur serie pour tester le programme 

Ouvres le moniteur serie pour tester le programme

Voici les différent onglet ("fichier") que j ai créé:

A_declaration

/***********CONSTANTE**************/
const float coax = 3.6;
const int femur = 5;
const int tibia = 10;
const float largeur = 8.6;
const float longueur = 11.1;
const float hauteur_corps = 5.5;
const float montageServo = radians(45);

/********VARIABLE**************/
int aff = 0;
float alti = 0;
float lateral = 0;
float longi = 0;

/*********DEFINE**************/
#define empattement 7
#define avant 1
#define arriere -1
#define droite 1
#define gauche -1

/*Calcul d'angle de cinématique inversé pour patte à 3 dgrés de liberté*/
/*---------------------------------------------------------------------*/
//Ici on gère les servo 
// exemple : robot type fourmis on rajoute un servo entre le thorax et la queue
// je te le donne en etat de marche mais pas cles en main pour que tu comprenne son fonctionnement
//pour pouvoir faire tout ce que tu veux avec.
// Un indice sur ton premier probleme ton vecteur ne peut pas etre plus long que ta patte tendu! ;) 


//Calcul de la longueur du vecteur Alpha => Pied
//Base calcul = THEOREME DE PYTHAGORE
float Vecteur(float x, float y, float z) {
  float Resultat = sqrt(pow((sqrt(pow(x, 2) + pow(y, 2)) - coax), 2) + pow(z, 2));
  return Resultat;
}

//Calcul d'angles avec AL-KASHI(théorème de Pythagore généralisé)
float Angle(float adj1, float adj2, float opp) {
  float Resultat = acos((pow(adj1, 2) + pow(adj2, 2) - pow(opp, 2)) / (2 * adj1 * adj2));
  return Resultat;
}

//Calcul de l'angle ALPHA
//Rotation sur le plan (X,Z)
float AngleAlpha(float x, float y, float z) {
  float Alpha = (acos(z / Vecteur(x, y, z)) + Angle(Vecteur(x, y, z), femur, tibia));
  return Alpha;
}

//Calcul de l'angle BETA
//Rotation sur le plan (X,Z)
float AngleBeta(double x, double y, double z) {
  float Beta = Angle(femur, tibia, Vecteur(x, y, z));
  return Beta;
}

//Calcul de l'angle GAMMA
//Rotation sur le plan (X,Y)
float AngleGamma(float x, float y) {
  float Gamma = atan(y / x) + montageServo;
  return Gamma;
}

/*************************POSITION CORPS ROBOT**************************/
/*Référentiel du chassis*/
//Ici (on oublie qu il a des pattes ;))et on definie la position du thorax
//exemple : on rajoute un gyroscope avec roulis et tangage on pourra lui demander
//          de garder son plateau toujours de niveau que le sol soit en pente ou pas   

float OffsetX(int cote) {
  float Resultat = (largeur / 2) * cote + lateral;
  return Resultat;
}

float OffsetY(int cote) {
  float Resultat = (longueur / 2) * cote + longi;
  return Resultat;
}

float OffsetZ() {
  float Resultat = alti;
  return Resultat;
}

/******************************POSTION PATTES ROBOT******************************/
/*Référentiel des pieds*/
//ici on definie ou doivent etre les pied (fixe dans mon exemple)
//exemple :longeur et hauteur des pas pour la marche

float PiedX(int cote) {
  float Resultat = (largeur / 2 + ((coax + empattement) * cos(radians(90) + montageServo)))* cote ;
  return Resultat;
}

float PiedY(int sens) {
  float Resultat = (longueur / 2 + ((coax + empattement) * sin(radians(90) + montageServo))) * sens;
  return Resultat;
}

float PiedZ() {
  float Resultat = hauteur_corps / 2;
  return Resultat;
}

/****************MOUVEMENT ROBOT***************************************************/
/*Différentiel pour la cinématique inversé*/
//ici il s'agit du différenciel entre le thorax et le pied et donc la patte en elle meme
//exemple : tu rajoute un bras articulé c est ici que tu géres a quelle distance ce trouve
//          la main de ton bras du thorax

float DiffX(int cote) {
  float Resultat = abs(PiedX(cote) - OffsetX(cote));
  return Resultat;
}

float DiffY(int sens) {
  float Resultat = abs(PiedY(sens) - OffsetY(sens));
  return Resultat;
}

float DiffZ() {
  float Resultat = abs(PiedZ() + OffsetZ());
  return Resultat;
}

float Alpha_Patte(int sens, int cote) {
  float Resultat = degrees(AngleAlpha(DiffX(cote), DiffY(sens), DiffZ()));
  return Resultat;
}

float Beta_Patte(int sens, int cote) {
  float Resultat = degrees(AngleBeta(DiffX(cote), DiffY(sens), DiffZ()));
  return Resultat;
}

float Gamma_Patte(int sens, int cote) {
  float Resultat = degrees(AngleGamma(DiffX(cote), DiffY(sens)) * cote * sens);
  return Resultat;
}

//ici je me suis pas pris la tete ;))

void instruction() {
  Serial.println("Instruction de commande disponible :");
  Serial.println("commande Alti +/- => z/a");
  Serial.println("commande Lateral +/- => s/q");
  Serial.println("commande Longi +/- => x/w");
}

void reception() {
  char c = Serial.read();
  if (c != -1) {
    switch (c) {
      case 'z':
        alti = alti + 1; break;
      case 'a':
        alti = alti - 1; break;
      case 's':
        lateral = lateral + 1; break;
      case 'q':
        lateral = lateral - 1; break;
      case 'x':
        longi = longi + 1; break;
      case 'w':
        longi = longi - 1; break;
      default:
        instruction();
    }
    aff = 1;
  }
}

void Patte(int sens, int cote) {
  Serial.println(Alpha_Patte(sens, cote));
  Serial.println(Beta_Patte(sens, cote));
  Serial.println(Gamma_Patte(sens, cote));
}

void envoie() {
  if (aff == 1) {
    aff = 0;
    Serial.println("Patte avant droite");
    Patte(avant, droite);
    Serial.println("Patte avant gauche");
    Patte(avant, gauche);
    Serial.println("Patte arriere droite");
    Patte(arriere, droite);
    Serial.println("Patte arriere gauche");
    Patte(arriere, gauche);

  }
}

//sans commentaire ;)

void setup() {
  Serial.begin(9600);
  instruction();
}

void loop() {
  reception();
  envoie();
}

 

1/ Pourquoi tu applique deux fois pythagore dans la fonction Vecteur ?? 

 

2/ Pourquoi tu rajoute z/Vecteur(x,y,z) a alpha ?

 

3/  Comment fonctionne sens et cote ?

 

4/ Les variable (x,y,z) ces moi qui doit les définir avec une valeur ???

 

5/ Ces quoi la différence entre lateral,longi,alti et (x,y,z) ??

sens,cote,x,y,z ne sont pas des variable mais des arguments de fonction  

si tu regardes bien, mon système mathématique n'est construit que de fonction qui s'appellent les unes les autres

et elles définissent seule comment appliquer la cinématique inverse a chaque angle selon la patte

Je l'ai écris pour l appeler le plus naturellement possible

tu veux l angle alpha de la patte avant droite = AlphaPatte(avant,droite)

tout le reste se fais tout seul :

AlphaPatte appelle la fonction AngleAlpha(x,y,z)

AngleAlpha prend 3 argument (qui sont 3 fonction)

   x =  la distance x entre l Offset et le pied qui n'est pas la même selon si elle est à droite ou a gauche (cote)

   y =  la distance y entre l Offset et le pied qui n'est pas la même selon si elle est à l'avant ou l'arrière  (sens)

   Z = pour toi pour l instant pas d argument mais ça viendra (le miens avec gyro dois savoir s il est sur le ventre ou sur le dos  il prend en argument haut et bas

ect ..... 

donc tu vois bien que quand tu appels la fonction AlphaPatte toutes les autres sont appelé automatiquement avec les bon arguments .

BetaPatte(avant,gauche) et BetaPatte(arriere,droite) ne renvoient pas le même résultat mais elles appellent les fonctions nécessaire avec les bon argument pour que ça corresponde bien a l angle beta de la patte avant gauche et arrière droite.

Latéral commande de déplacement latéral (droite gauche) du CORPS du robot

Longi   commande de déplacement longitudinale (avant, arrière) du CORPS du robot

Alti       commande de déplacement altitude(monter, descendre) du CORPS du robot

Alors je sais que quand tu vas comprendre parfaitement comment ça marche, tu vas voir une façon beaucoup plus simple de le faire marcher sans Offset et sans les différentiel, mais ton IK sera figé. Cette structure te laisse la porte ouverte pour faire ce que tu veux.

exemple, comme moi, module Position corps ,et juste pour la moitié des Offset de mon robot (je t'épargne les équations)

Et la tu devrais comprendre pourquoi je te dis de bien structurer ton programme parce que ça prend très vite beaucoup de place 

sur ce que tu a fais (je l ai juste survolé pas regardé en détail et je je suis pas bien placé pour t aider en codage je vais laisser ça à d autre) mais j ai quand même vu des erreur.

dans le loop (je pense que tu l auras compris ) toute ces fonctions non rien a faire la, elle sont appelé par:

AlphaPatte

BetaPatte

GammaPatte

et même ces fonctions la, devrait être appelé par une boucle sur l'asservissement des servo

les arguments de fonction (x,y,z,sens,cote) ne se déclare pas se sont des arguments

tu peux créer une fonction pour les "serial print"

y a des erreurs .

 

 

#define Avant 1
#define Arriere 1
#define droite 1
#define gauche 1
#define bas 1
#define haut 1

#define Avant 1
#define Arriere -1
#define droite 1
#define gauche -1
#define bas 1
#define haut -1

il faut bien comprendre qu'une valeur comme "largeur/2" vaut pour la droite et la gauche

avec la fonction : OffsetX(cote)=largeur/2*cote

quand tu appels :Valeur+OffsetX(droite)    c'est égale à Valeur+(largeur/2)

                            Valeur+OffsetX(gauche) c est égale à Valeur-(largeur/2)

je trouve ça trop "fouillis" (avis perso, peut être a tord)

 

int Mouvement_Alpha_Patte(double sens, double cote)
{
Alpha_Patte = Angle_Alpha(Mouvement_DiffX(cote), Mouvement_DiffY(sens), Mouvement_DiffZ(sens));
Serial.print("Alpha_Patte=");
Serial.print(Alpha_Patte,DEC);
Serial.println();
}

je ne sais pas coder mais ça devrais ressembler plutôt à ça:

A L'AIDE Mike 118

int Alpha_Patte(double sens, double cote)
    {
    Resultat = Angle_Alpha(DiffX(cote), DiffY(sens), DiffZ));
    return Resultat;
    }

Et ce pour toutes tes fonction

ça je comprends pas:

 

 

//Test :
for(int i =0; i<=1; i++)
{
//Avant droit Servos (1)
Move_Servo(AVD0,Gamma_Patte);
Move_Servo(AVD1,Alpha_Patte);
Move_Servo(AVD2,Beta_Patte);
//Arrière droit Servos (2)
Move_Servo(ARD0,Gamma_Patte);
Move_Servo(ARD1,Alpha_Patte);
Move_Servo(ARD2,Beta_Patte);
//Avant gauche Servos (3)
Move_Servo(AVG0,Gamma_Patte);
Move_Servo(AVG1,Alpha_Patte);
Move_Servo(AVG2,Beta_Patte);
//Arrière gauche Servos (4)
Move_Servo(ARG0,Gamma_Patte);
Move_Servo(ARG1,Alpha_Patte);
Move_Servo(ARG2,Beta_Patte);
}

 GammaPatte, AlphaPatte, BetaPatte, de quoi? y a pas d'argument pour l IK !

//indiquer à l'IK de quelle patte il doit calculer cette angle
Move_Servo(AVD0,Gamma_Patte(avant,droite));
Move_Servo(ARD0,Gamma_Patte(arriere,droite));
Move_Servo(AVG0,Gamma_Patte(avant,gauche));

Bien qu'en Python le code et plus court, je pense que même en C tu peux réduire énormément il y a beaucoup de chose inutile ou mal structuré tu devrais bien comprendre la base de cinématique inversé que je t ai faite avant d' essayer de la coder sinon tu arriveras pas à faire marcher ton robot.Comme je n'ai fais que survoler ton code y a peut être d'autre erreur mais je pense que tu vas le retravailler.

 

 

Voir mon petit tutoriel ici  Si tu as des questions hésites pas !

Super le tuto je connaissais pas . Tu viens de me réconcilier avec arduino et du coup on peux optimiser le code que j ai fournis plus haut

Concernant la "règle" qui dis qu'on ne soustrait jamais une commande, c'est juste le fameux théorème de vaelan qui s applique à sa cinématique inversé qui dis : Si -(commande) alors démonte ton robot et remonte le comme il faut ) Blague a part , les commandes définissent un vecteur d'origine 0,0,0 (le centre du robot), sur (x,y ou z) , de direction - ou + et de longueur la valeur de la commande.

Donc si tu as un latéral de -1  c est un vecteur sur x vers la gauche de longueur 1 maintenant si tu fais -vecteur tu inverse le vecteur du coup si tu dis a un offset de droite +vecteur et a un offset de gauche -vecteur tu vas casser quelque chose ) J ai voulu faire une explication simple mais je me rends compte qu avec un langage plus matheux ça aurais était peut-être un peu plus clair, désole.

alors t en ai ou AlexBot? ca avance? 

On va continuer et développer ma logique d'IK plutot sur mon post parce que ca devient un peu trop envahissant pour AlexBotMaker et je développerais un peu plus sur la marche et un point important , dont j ai fais allusion au début de mon explication, à savoir son centre de gravité.

vieartificielle

 

 

Ce robot restera en équilibre à la condition que la projection de son centre de gravité soit en permanence dans le polygone de sustentation. Ce polygone est délimité par tous les points de contacts au sol.

Je reste  dispo si tu a des problème avec ton robot Alex

Au vues de ta vidéo il semble qu il y ai un problème avec le "longi".

"alti" et "lateral" à l'air OK  .

Avec Parkinson c'est difficile de voir quel mouvement est inversé.Le code de l'IK tu l'as modifié ou il est comme l'original? 

 

 

const float largeur = 8.6;
const float longueur = 11.1;

Tu dois déjà commencer par changer ça par:

const float largeur = 11.1;
const float longueur = 8.6;

 

 

#define avant 1
#define arriere -1
#define droite -1
#define gauche 1

La tu dois bien faire attention que tes servo soit bien monté comme sur mon schéma sinon tu devras adapter

Considère ton robot comme étant un plan Orthonormés dont son centre est le repère (0,0,0) , ce qui veut dire que si avant 1 et arriere -1 alors droite 1 et gauche -1

La tu vois que j ai des Offset avec des valeurs absolu identique = (3,2)

soit B (3*droite,2*avant) / (3*1,2*1) = (3,2)

       A (3*gauche,2*avant) / (3*(-1),2*1) = (-3,2)

       D (3*gauche,2*arriere) / (3*(-1),2*(-1)) = (-3,-2)

       C (3*droite,2*arriere) / (3*1,2*(-1)) = (3,-2)

Et il sont tous à leur place. Il s'agit de placement d'Offset et pas d inversion d'angle(je vais vérifier le prog que je t'ai fais, des fois que je me soit trompé)

Si t'as besoin de précision sur des détails que tu comprends pas je suis dispo y'a qu'a demander

intervertis les servos:

                 Beta avant droite avec Beta arriere droite

et

                 Beta avant gauche avec Beta arriere gauche

soit ils sont pas branchés sur la bonne Pin soit il y a une erreur sur la prog de distribution

au niveau des batteries Lipo elles sont de 3,7 volt par élément. j'alimente mes servo avec une 2S 1950mAH soit 7,4volt .Temp de recharge de 30 a 45 MN mais bon j'hérite du matériel de modélisme que je possédais déjà et ça demande a être manié avec prudence.

Sinon en NiMh 1,3 volt par élément il me semble moins dangereux a manipuler mais plus contraignant a l'entretien parce qu elle garde une mémoire de charge du coup il faut toujours les décharger complètement avant de les recharger

 

 

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  

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. 

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,

  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      

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 :  

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

+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

mon robot est un hexapode;) son petit nom CR6VA1 

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

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 

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 )

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