Aller au contenu


Contenu de Vaelan

Il y a 45 élément(s) pour Vaelan (recherche limitée depuis 03-avril 13)



#73726 Oracid - Mon imprimante 3D Dagoma Discovery 200

Posté par Vaelan sur 13 septembre 2016 - 06:48 dans Impression 3D et Imprimantes 3D

Le tube PFTE n a t il pas un defaut ?



#73046 Oracid - Mon imprimante 3D Dagoma Discovery 200

Posté par Vaelan sur 20 août 2016 - 04:27 dans Impression 3D et Imprimantes 3D

Ç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 

Discovery200. Elle a l'air d'avoir tout ce qui me manquait , le prix , la simplicité , un SAV français.... Il me manque juste un avis objectif sur le bruit qu'elle émet. Je suis en appartement (pas de sous sol et encore moins d atelier pour la mettre, elle devra rester dans mon bureau) du coup je me pose la question niveau vibration pour les voisins et niveau bruit dans l appartement (si elle doit tourner plusieurs heure il faudrait quand même qu'elle soit relativement discrète surtout si elle doit tourner la nuit ;)



#73016 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 19 août 2016 - 01:48 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

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




#72993 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 18 août 2016 - 07:56 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

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? 




#72979 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 17 août 2016 - 10:06 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

 

 

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

quad orthonormees.jpg.png

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




#72911 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 14 août 2016 - 09:33 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

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




#72907 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 14 août 2016 - 08:52 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

 

Offset translaté arrière gauche = -Offset + (-1) 

Offset translaté arrière droite = Offset +(-1)

Je suppose que c est ça que tu comprends pas?

 

en faite ca correspond a :

Offset translaté arrière gauche = -Offset + (lateral) 

Offset translaté arrière droite = Offset +(lateral)

 

Au final la radio (ou autre moyen de controle) ne dois controler que le centre du robot. 

sur une radio les manches symbolise le centre du robot.

continuons avec l'exemple de commande latéral:

coordonnée 0,0,0

Aurora_9 000..png

coordonnée 0,5,0

Aurora_9 050..png

coordonnée 0,-5,0 

Aurora_9 0-50..png




#72901 Robot bipède pour la Toulouse Robot Race 2016

Posté par Vaelan sur 13 août 2016 - 08:31 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

Je te souhaite bonne chance, bien que vu les capacité de ton robot tu n'en ai peu être pas besoin  :ok:




#72900 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 13 août 2016 - 07:59 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

Désole un peu en retard pour l explication

 

 

 

Si je veux bouger le centre du robot dans de DX=1  suivant x je vais bien avoir DiffX patte droite (avant ou arrière ) = 9 = DiffX0 -DX 
Et pour les pattes gauche  DiffX=11 = DiffX0 + DX ... 

 

En faite ma cinématique ne marche pas comme ça . Ce qui définît l'empattement c'est les DiffX,Y ou Z (Différentiel) a partir des Offset et position des pieds (Référentiel) .

 

Alors oui y a bien un empattement définit par défaut , mais il faut bien une position de départ ;)

 

Le but étant de ne contrôler que le centre du robot, chaque commande peut être considéré un vecteur partant de Z=0  X=0 Y=0

un latéral de +1 c est un vecteur d'origine  (Z=0  X=0 Y=0) à ( Z=0  X=1 Y=0)

un latéral de -1 c est un vecteur d'origine  (Z=0  X=0 Y=0) à  (Z=0  X=-1 Y=0)

donc on aura toujours "Offset + commande"

exemple pour un latéral de -1:

Offset translaté avant droite = Offset physique + vecteur (( 0 , 0 , 0) => ( 0 , -1 , 0))

Offset translaté avant gauche = -Offset + vecteur (( 0 , 0 , 0) => ( 0 , -1 , 0))

On sait que le vecteur est définit par la droite de l axe x du plan (x,y) passant par le centre du robot on peut donc écrire:

Offset translaté arrière gauche = -Offset + (-1) 

Offset translaté arrière droite = Offset +(-1)

 

Je vais pas dire "on fait la même chose pour la marche" parce qu il faut quelque chose d'un peu plus complet mais on garde le même principe, et  tout nos référentiel (Offset et Pied) sont calculé.

 

Le différentiel entre A et B (nos référentiel) permet de calculer l'empattement dynamiquement 

 

Et enfin  les trois différentiel permettent de calculé tout les angles

 

quad vecteur.png

 

Avec ce début d IK j'ai pas d'exemple qui me viens a l esprit mais sur mon robot j'ai prévu en plus le roulis, tangage, et lacet (avec des méthode de marche bien entendu et d'autre chose .... ;)) je compte lui monter, pour ceux qui connaissent, un "Flymentor" c' est un gyro 3 axes avec accéléromètre et capteur de mouvement au sol (recupéré sur un de mes hélico) il va gérer le lacet et le tangage pour un mise a niveau du thorax.Grace à se système de différentiel quelque soit la correction d assiette du gyro qui sera appliqué, je pourrais toujours utiliser mon latéral ou le faire marcher sans que les différents mouvement soit en conflit les uns avec les autres (dans les limite physique du robot). 




#72887 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 12 août 2016 - 06:51 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

En faite tu confonds les référentiel et les différentiel les commandes n'agissent pas directement sur DiffX mais plutot sur OffsetX (pas encore de commande sur les pieds mais Alex va les rajouter j en suis sur ;))  . la j ai pas le temp , je te fais un schéma ce soir




#72884 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 11 août 2016 - 09:03 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

 

 

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? 




#72877 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 10 août 2016 - 10:21 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

 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.




#72876 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 10 août 2016 - 09:28 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

"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).

 

 

 

 




#72874 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 10 août 2016 - 05:39 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

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 

 

Capture IDE arduino.PNG

 

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

 

 B_Cinematique_inverse:

/*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;
}

C_Position_Corps:

/*************************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;
}

D_Position_Patte:

/******************************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;
}

E_Mouvement:

/****************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;
}

F_TEST

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

  }
}

G_Process

//sans commentaire ;)

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

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

Voila j'espère que ça va t'aider ;)

 
 
 
 

 

 




#72793 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 06 août 2016 - 12:06 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

 

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

 

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

 


double Pythagore.png

 

 

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)

CR6 Multi-vue.png

 

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.




#72777 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 05 août 2016 - 12:03 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

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




#72755 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 04 août 2016 - 04:23 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

Petit precision parce que c est pas tres clair dans mes screen shoot :

DiffX et DiffY sont des valeurs absolu




#72754 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 04 août 2016 - 04:15 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

hello

Désole d avoir était aussi long j ai pas eu trop le temps mais j ai fait ça pour ton robot

 

alors pour commencer comme je savais pas comment est monté ton robot je suis partis sur cette base

montage servo vue dessus.png

montage servo vue face.png

 

tu pourras corriger si ton robot est monté différemment

 

pour la cinématique elle est sur géogébra parce que je l'ai testé virtuellement avant de te la proposer

IK 1.png

IK 2.png

désolé c'est un peu petit, mais tu peux agrandir en ouvrant le lien dans une nouvelle fenêtre(je sais pas comment le mettre en plus grand)

 

Avec ça tu as une base qui fonctionne

 

Si, comme moi, tu veux rajouter le roulis,tangage,lacet ou autre mouvement de corps c est dans position corps que ça se passe.

L amplitude des pas de chaque patte ou position "d'attitude" par exemple c'est dans position pattes  qu il faut le définir.

Le style de marche vecteur de marche et direction c est dans Mouvement

si tu rajoute des éléments a ton robot(un bras articulé par exemple) il faudra modifié la cinématique inversé pour qu elle le prenne en compte

 

et tu distribue tout ca avec une boucle

la définition est simple:

servo1 = GammaPatte(avant,droite)

servo2 = AlphaPatte(avant,droite)

servo3 = BetaPatte(avant,droite)

servo4 = GammaPatte(avant,gauche)

ect......

 

Un lien avec la cinématique fonctionnel, il te suffit de bouger les curseurs vert en haut de la page.Je n'ai pas résolu le déplacement visuel de la diagonal pour que tu vois bien que le pied n'est pas un point fixe sur la page mais que c est bien la cinématique qui gère les angles

 

https://www.geogebra.org/m/nU9jakAj

Voila ;)




#72665 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 31 juillet 2016 - 07:29 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

en faite moins il y a de patte plus c est dure sur mon hexapode j ai juste le risque que les patte se touche mais l IK peut définir les limites des pattes vu qu elle calcul les angles .

 

Sur un quadrupède dans l idéale il faut que le point centre se déplace selon le centre de gravité donc des Offset en changement permanent, bon je veux pas effrayer AlexBotMaker c est pas obligatoire ça dépendra des performance que tu recherches pour ton robot.

 

Pour un bipède sauf surdimensionner ses pieds il faudra obligatoirement un accéléromètre et un gyroscope et je ne pense pas que ma méthode soit la bonne approche;) j essayerais peut être un jour .

 

sur le même principe ça peut aussi s appliquer a un bras articulé

 

je vais essayer de te faire un petit truc sur géogébra avec les paramètre de ton robot et comment mettre en place l IK mais ne connaissant pas le sens ni les angle de montage des servo Coax il faudra que tu corriges .




#72649 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 31 juillet 2016 - 01:32 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

je suis pas très bon pédagogue désolé.

 

je vais essayer de te donner mon raisonnement de programmation pour mon robot, ça t aidera peut être à comprendre ce qu est l'IK.

 

J'ai fait un parallèle avec le vivant:

 

Dans notre environnement on reçois des instructions de notre entourage(patron ,professeur,amis......)

Ça c est la partie communication du robot (télécommande, port série, bluetooth, wifi, certain capteur......)

 

Si on me demande d'avancer je décide consciemment comment (en marchant, en courant/ je commence avec le pied droit, le pied gauche/ j y vais a quatre patte.......)

Ça c est la partie Gaits de mon robot( on pourrais lui demander d'aller à l'endroit X au lieu de lui dire d'avancer , avec un système gps il pourrait le faire et c est ici que ça se passe aussi.

 

et pour finir quand tu marches tu ne décide pas consciemment de combien tes muscles doivent se contracter pour que tu puisse marcher on ne connais même jamais les valeurs associer.

Ça c est l IK (il gère tout les servo sans que l on ne connaisse jamais leurs valeurs)

 

pourquoi faire cette différence entre l IK et la marche ? Simplement parce que l IK peut être associer a tout ce qui concerne le robot , en plus de la marche on peut imaginer des réflexe lié a des capteur , des position à adopter..... ce système permet de combiné ce que tu veux.

 

exemple avec un IK complet : tu lui demande en posture de se pencher a gauche avec une torsion a droite en allant a telle endroit avec telle démarche ..... l ik va calculer tout les angles malgré tout ces paramètre venant de différent endroit de ton programme sans que tu ne connaisse jamais la valeur de tes servo 

dans se cas chaque nouveau paramètre appliqué à l IK dois prendre en compte la modification de  l Offset par le paramètre précèdent.

 

Dans le cas simplifié que je t'ai présenté plus haut l IK et la marche ne sont qu une seul chose et rien d autre ne sera appliqué dessus , demander au centre contrôlé ou a chaque patte d avancer c est pareil puisque tout les Offset sont ceux d'origine et ne peuvent pas être modifié par autre chose.

 

pour les angles, alpha beta gamma, sont indissociable. Chacun d eux modifie les autres, ainsi i1 a un empattement par défaut qui définit l emplacement du pied du robot (le vecteur de marche passera par la)  , si tu applique un latéral de 2 vers la gauche l Offset_X de droite sera a +2 et celui de gauche sera a -2, gamma et i1 seront modifiés et par conséquent alpha et beta aussi.Il n est pas question de marche mais bien de garder les pieds du robot à leur place alors que son corp se déplace!!

OffsetX =longueur/2 + deplacementX

 

lateral gauche.png

 

 

il en va de même pour la marche , le pied de ta patte devra courir le long de ton vecteur de marche et modifiera tout les angles en même temps (voir schéma IK simplifié plus haut)

 

ton IK connaissant l Offset et la position d origine du pied de ta patte peux calculer gamma et la longueur total de la patte, en soustrayant la longueur du coax il obtiens i1 avec i1 il peux calculer alpha et beta 

 

Voila pour le principe

 




#72606 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 30 juillet 2016 - 12:03 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

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!..

 

principe.png

 

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




#72563 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 28 juillet 2016 - 09:37 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

 

 

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  




#72490 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 26 juillet 2016 - 10:06 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

mon robot est un hexapode;) son petit nom CR6VA1 

 




#72488 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 26 juillet 2016 - 09:36 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

exemple du mouvement de Lacet

position initial: Les Offset sont facile à définir

quad dessus.jpg.png

 

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

quad torsion.jpg.png

 

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

 




#72486 Robot Quadrupède Arduino Uno

Posté par Vaelan sur 26 juillet 2016 - 07:22 dans Robots à pattes et jambes, humanoïdes, bipèdes, quadrupèdes, hexapodes ...

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 

quadrupede explication IK.jpg

 

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