Tu peux suivre mon projet sur mon robot quadrupède Arduino uno r3. Si tu as des questions n'hésite pas.

A+ Alex.

Voila ! ça marche mieux avec la batterie ! Plus de tremblement !

Maintenant je vais vérifier mon problème avec longi !

 

Oui j'ai un problème avec longi je suis d'accord ^^
Jai modifier le programme, j'ai échanger la place de longueur et largeur, vu que je suis dans l'autre sens avec le robot.
parcontre ya moyen que j'ai fait un truc un peu nul pck j'ai mis la configuration avec les -1 comme dit pour avant arrière etc
Et sa ma déplacer certains moteur se que je voulais pas donc ensuite j'ai détacher les moteur et je les ai remis à leur place initiale. Mais j'ai pas trop réfléchi en vrai pck jpense que à cause de sa j'ai du modifier la porte du moteur. Il faut que je vérifie vite fait sa. Après c'est vrai que le robot à du mal,déjà à cause de l'alimentation. j'alimente la carte et les moteu, donc quand les 12 moteur sont utiliser l'amperage augmente la tension chute et la carte n'est plus alimente tu t'imagine le délire... Mais sa existe pas des batterie lithium qui tourne sous 6V si ? Généralement ces 9V donc il me faut un régulateur de tension en plus... Et j'ai plus de place sur le robot... Donc la je sais pas trop quoi faire.. Et les accu 14h de recharge...XD puis défois je me dit aussi que j'aurai du faire les tibia plus grand.. Il a pas bcp de liberté je trouve après c'est mon impression.
si quelqu'un a une batterie et le chargeur allant avec à me recommander se serait sympa merci d'avance

Ok alors ca va ! Mdr c'est bien se que j'avais changé ! donc j'étais sur la bonne voie

 

Je vous présente Frankenstein !

 

[media][media]

Alors la je suis tomber sur un nouveau problème ! ^^

Je n'arrive pas a trouver la configuration pour calibrer le robot !

 

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

 

Si je mais cette configuration ou toute les autre possible, je les ai toute essayer mon robot ne met pas les pattes au bon endroit mais jai aussi des doute par rapport au faite dans quel sens que prend mon robot ?

 

pour l'instant il n'y a que l'altitude qui marche bien, latertal et longi sa le fait mais pas très bien encore ^^

 

Donc ben les servo qui se son bouger je les est détacher et remise a leur place d'origine pour garder les #define -1 et tout.

Avant si je voulait que toute les pattes soit a la même place je devait laisser soit 1 partout ou soit -1 partout lol

 

Car sur geogebra ton robot est dans l’autre sens que le mien lol moi ma symétrie c'est entre devant et derrière c'est entre droite et gauche.

Si ta une idée ou je doit chercher.. ou quelle est la meilleur chose a faire dans ce cas la 

Salut ! désolée pour le retard, j'ai pas pu travailler dessus dernièrement j’étais sur Caen !

J'ai un peu survolée de se que vous avez discutée !

mike118 mon premier programme je l'avais fait en orienté objet, avec genre pattes, articulation, corps c'est vrai que sa peut être pas mal

après je m'y connais pas a fond en orienté objet !

 

Sinon sa dérange pas que vous discutiez ici de toute façon au final sa me concerne ^^ donc j'en apprend toujours un peu plus !

Je vais essayer de trouver un créneau pour avancer dans le robot

Nickel chrome ton programme

juste "aff" c'est quoi ? sa n'apparaissait pas avant

Puis y'a effectivement le faite que je mettais pas en radians comme ta fait radian(90) ! Donc sa pourrait expliquer des valeurs incorrect. Pour les différent onglet j'ai pas fait sa parce que a un moement donnée j'avais l'impression que les informations ne passait pas pck les angle restait bloquer a 90deg meme si je changeais alti,longi,lateral donc sa me rendait dingue lol je comprenais pas donc j'ai regarder que mon programme passait bien dans toute les méthode puis voila j'en suis la pour l'instant.

 

Merci mike118 pour ton avis sur le programme ! Je vais tenir compte des remarques, je me rapproche du but.

Par contre concernant le mappage des servos c'est dans ma partie protocole pour mon contrôleur de servomoteur que c'est directement définie. 

Ok j'ai apporté certaine modification, en tout cas c'est ouf ton travaille ! chapeau bas !

Sinon j'ai encore un problème avec l'angle gamma je suis a 45deg partout au lieu de 90deg

Puis j'essaye de modifier les valeur alti et longi etc mais sa ne fait rien donc je pense que j'ai un souci quelque part au niveau du programme..

Je te tiens au jus si j'ai du nouveau !

Bon ben enfaite j'ai déjà tout codé lol

J'ai de nombreuse question ^^

#include <SoftwareSerial.h>
#include <Servo.h>
#include "Constante.h"

/*******************************************/
/*  ALEXANDRE - VAELAN   ROBOT-MAKER.COM   */
/*******************************************/  

/*Robot Quadrupède 3DOF:

-> Arduino UNO R3 
-> Mini Maestro 12
-> Batterie Accu 6V
-> Liaison série 
*/

          /*LB	  LF*/		
    	   /*	   */
    	    /******/
            /******///-----> FORWARD
    	    /******/
    	   /*      */
    	  /*RB    RF*/
    

//Avant droit Servos (1)
#define AVD0 0
#define AVD1 1
#define AVD2 2
//Arrière droit Servos (2)
#define ARD0 3
#define ARD1 4
#define ARD2 5
//Avant gauche Servos (3)
#define AVG0 6
#define AVG1 7
#define AVG2 8
//Arrière gauche Servos (4)
#define ARG0 9 
#define ARG1 10
#define ARG2 11

void setup()
{
  
  Serial.begin(9600);  //ecrire sur le port serie
  Maestro_Serial.begin(9600); //Liaisons série TX -> RX
  
  
}

void loop()
{
  
  lateral=0;
  longi=0;
  alti=5;
  
    //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);
    }
}


/***********************CINEMATIQUE INVERSE SIMPLE (Longi,lateral, alti)*******************************/

 
int Vecteur(double x, double y, double z)    //Calcul de l'Hypothénuse (THEOREME DE PYTHAGORE)
 {
 Hypothenuse = sqrt(pow(pow(x,2)+pow(y,2)-COAX,2));
 L = sqrt(Hypothenuse + pow(z,2));
 Serial.print("Vecteur=");
 Serial.print(L,DEC);
 Serial.println();
 return L;
 
 }
 
int Calcul_Angle(double adj1,double adj2,double opp)   //Fonction pour calculer les angles (AL-KASHI)
 {
 Angle = acos((pow(adj1,2)+ pow(adj2,2)) - pow(opp,2)/ (2*adj1*adj2));
 return Angle;
 }
 
/***************************************************************/

int Angle_Alpha(double x,double y,double z)  //Calcul de l'angle ALPHA (ATTENTION la fonction Acos retourne des radians)Mouvement vertical
 {
 Alpha = acos(z/Vecteur(x,y,z))+Calcul_Angle(Vecteur(x,y,z),FEMUR,TIBIA);
 Alpha = Alpha*57,3;
 Serial.print("Alpha=");
 Serial.print(Alpha,DEC);
 Serial.println();
 return Alpha;
 }
 
int Angle_Beta(double x,double y,double z) //Calcul de l'angle BETA (ATTENTION la fonction Acos retourne des radians) Mouvement vertical
 {
 Beta = acos(Calcul_Angle(FEMUR,TIBIA,Vecteur(x,y,z)));
 Beta = Beta*57,3;
 Serial.print("Beta=");
 Serial.print(Beta,DEC);
 Serial.println();
 return Beta;
 }

int Angle_Gamma(double x, double y)  //Calcul de l'angle GAMMA (ATTENTION la fonction Acos retourne des radians) Mouvement horizontal
 {
  Gamma = atan(y/x)+ MontageServo;
  Gamma = Gamma*57,3;
  Serial.print("Gamma=");
  Serial.print(Gamma,DEC);
  Serial.println();
  return Gamma;
 }

/*************************POSITION CORPS ROBOT**************************/ 

int Calcul_OffsetX(double cote)
{
 OffsetX = (X_LONGEUR/2)*cote + longi;
 Serial.print("OffsetX=");
 Serial.print(OffsetX,DEC);
 Serial.println();
 return OffsetX;
}

int Calcul_OffsetY(double cote)
{
 OffsetY = (Y_LARGEUR/2)*cote + lateral;
 Serial.print("OffsetY=");
 Serial.print(OffsetY,DEC);
 Serial.println();
 return OffsetY;
}

int Calcul_OffsetZ()
{
 OffsetZ = alti;
 Serial.print("OffsetZ=");
 Serial.print(OffsetZ,DEC);
 Serial.println();
 return OffsetZ;
}

/******************************POSTION PATTES ROBOT******************************/

int Calcul_PiedX(double cote)
{
  PiedX = (Y_LARGEUR/2 + (COAX + EMPATTEMENT)*cos(90-MontageServo))*cote;
  Serial.print("PiedX=");
  Serial.print(PiedX,DEC);
  Serial.println();
  return PiedX;
}

int Calcul_PiedY(double sens)
{
  PiedY = (X_LONGEUR/2 + (COAX + EMPATTEMENT)*sin(90-MontageServo))*sens;
  Serial.print("PiedY=");
  Serial.print(PiedY,DEC);
  Serial.println();
  return PiedY;
}

int Calcul_PiedZ()
{
  PiedZ = HAUTEUR_CORPS/2;
  Serial.print("PiedZ=");
  Serial.print(PiedZ,DEC);
  Serial.println();
  return PiedZ;
}


/****************MOUVEMENT ROBOT***************************************************/

int Mouvement_DiffX(double cote)
{
  DiffX = abs(Calcul_PiedX(cote) - Calcul_OffsetX(cote));
  Serial.print("DiffX=");
  Serial.print(DiffX,DEC);
  Serial.println();
  return DiffX;
}

int Mouvement_DiffY(double sens)
{
  DiffY = abs(Calcul_PiedY(sens) - Calcul_OffsetY(sens));
  Serial.print("DiffY=");
  Serial.print(DiffY,DEC);
  Serial.println();
  return DiffY;
}

int Mouvement_DiffZ(double sens)
{
  DiffZ = abs(PiedZ + OffsetZ);
  Serial.print("DiffZ=");
  Serial.print(DiffZ,DEC);
  Serial.println();
  return DiffZ;
}

/****************************************************************/

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

int Mouvement_Beta_Patte(double sens, double cote)
{
  Beta_Patte = Angle_Beta(Mouvement_DiffX(cote), Mouvement_DiffY(sens), Mouvement_DiffZ(sens));
  Serial.print("Beta_Patte=");
  Serial.print(Beta_Patte,DEC);
  Serial.println();
}

int Mouvement_Gamma_Patte(double sens, double cote)
{
  Gamma_Patte = Angle_Gamma(Mouvement_DiffX(cote), Mouvement_DiffY(sens))*cote*sens;
  Serial.print("Gamma_Patte=");
  Serial.print(Gamma_Patte,DEC);
  Serial.println();
}


/*****************PROTOCOLE*****************************/

void Move_Servo(unsigned char servo, unsigned int target){
	
	target = (map(target, 0, 180, 992, 2000) * 4); //Map the target angle to the corresponding PWM pulse.
	
	byte command[] = {
	PROTOCOL_BYTE, DEVICE_NUM, SET_TARGET_BYTE, servo, target & POLOLU_BIT_MASK, (target >> 7) & POLOLU_BIT_MASK};
	
	for(int i = 0; i < 6; i++)
	{
	Maestro_Serial.write(command[i]);
	}
}

void Set_Speed(unsigned char servo, unsigned int vitesse)
{
	byte command[] = {
	PROTOCOL_BYTE, DEVICE_NUM, SPEED_BYTE, servo, vitesse & POLOLU_BIT_MASK, (vitesse >> 7) & POLOLU_BIT_MASK};
	for(int i = 0; i < 6; i++)
	{
	Maestro_Serial.write(command[i]);
	}
}

#include <SoftwareSerial.h>
#include <Servo.h>

/*--------------------PROTOCOLE----------------------------*/
#define SET_TARGET_BYTE 0x04 // represents Pololu protocol set target command
#define DEVICE_NUM 0x0C // default device number for Pololu protocol
#define PROTOCOL_BYTE 0xAA // Pololu protocol identifier (0xAA)
#define POLOLU_BIT_MASK 0x7F
#define SPEED_BYTE 7
#define GETMOVING_STATE 0x13
/*--------------------Mini-Maestro 12----------------------*/
#define rxPin 3  // pin 3 connected to PololuSerial TX (not used in this example)
#define txPin 4  // pin 4 connected to PololuSerial RX
SoftwareSerial Maestro_Serial = SoftwareSerial(rxPin, txPin);
/*---------------XBEE S1-------------------------------*/
uint8_t pinRx = 12, pinTx = 11; //Xbee Tx/Rx
SoftwareSerial xbee(pinRx , pinTx);
/*------------------------------------------------*/

/***********CONSTANTE*************(cm)*/
const int COAX=3.6; 
const int FEMUR=5; 
const int TIBIA=10; 
const int Y_LARGEUR=8.6;
const int X_LONGEUR=11.1;     
const int HAUTEUR_CORPS=5.5;
const int DISTANCE_patte_G=6;
const int MontageServo=45;
/********VARIABLE**************/
double alti=0;
double lateral=0;
double longi=0;
double x=0;
double y=0;
double z=0;
double L=0;
double Hypothenuse=0;
double Angle=0;
double adj1=0;
double adj2=0;
double opp=0;
double Alpha=0;
double Beta=0;
double Gamma=0;
double cote=0;
double sens=0;
double OffsetX=0;
double OffsetY=0;
double OffsetZ=0;
double PiedX=0;
double PiedY=0;
double PiedZ=0;
double DiffX=0;
double DiffY=0;
double DiffZ=0;
double Alpha_Patte=0;
double Beta_Patte=0;
double Gamma_Patte=0;
/*********DEFINE**************/
#define HAUTEUR 9
#define EMPATTEMENT 7
#define Avant 1
#define Arriere 1
#define droite 1
#define gauche 1
#define bas 1
#define haut 1
/*********************/
#define NEUTRE 1500
#define FEMUR_HAUT 1900
#define FEMUR_BAS 1000
#define TIBIAS_HAUT 1300
#define TIBIAS_BAS 1550
#define COAX_AVDROIT 1900
#define COAX_ARRDROIT 1400
#define COAX_AVGAUCHE 1100
#define COAX_ARRGAUCHE 1600
#define TOURNER_DROITE 1100
#define TOURNER_GAUCHE 1900
/*******RAPIDE*******/
#define Temps 200
#define Temps2 220
#define Temps3 800
/*******LENT********
#define Temps 50
#define Temps2 60
#define Temps3 300
/****************/

Voila, il ya tout

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

Effectivement, il me manquait beaucoup de chose ! Mdr

Bon je vais essayer de tout reprendre et essayer de comprendre se qui se passe avant de tout coder ! :-)

Mais en tout cas Merci d'avance pour ton aide ! C'est du beau taff !!

 

Dès que j'aurai programmé je posterai des vidéos du robot :-)

Salut Jekert ! Ce serait cool que tu mette quelques photos de ton robot, la mécanique m'intéresse beaucoup aussi !

Surtout quand c'est en métal Tu as une fraiseuse numérique ?

 

Ne tqt pas comme ta pu le remarquer moi-même je suis loin du compte avec la cinématique inverse ! lol

 

Je vais jeter un coup d'oeil, je ne connaissait pas ALLBOT !

Moi je projette de refaire un robot carré, totalement carré avec un système de rack pour ranger les cartes,  quelque chose de simple à réaliser et peut chère pour que se soit accessible pour un grand nombre, un matériaux léger et qu'on peut découpé au cutter.

Sa permettra aux fan de robotique de s'en procurer un pour pas chère même si ils ont d'autre projets en cours en ayant qu'a prendre ma cinématique de base et la retravailler a leurs façon. Je vais faire un document PDF complet du montage etc.. peut être plus vidéo. A voir !

 

Voila, en tout cas si ta des question sur le quadrupède demande ! après je suis pas un pro surtout en prog.

Sinon poste ton robot

J'ai regardée le sujet ! il est pas mal avancée et ces programmes sont plus structurées que les miens ^^

Je vais voir avec lui quand il se lancera plus en détails dans la prog !

Moi je galère la mais je compte en faire un pareil mais avec une base toute carrée et des système de rack pour les cartes mon idées de base pour mon robot mais pas top puis alléger le poids aussi

 

Mais la, ce qui me rend dingue c'est la cinématique ! xD

J'ai l'impression de comprendre quelque chose un jour puis le lendemain je comprend plus rien... lol

 

@Vaelan

J'ai commencée à faire se que j'ai cru comprendre de se que tu m'a dit :

/*****Mesure********* (cm)*/
const int COAX =6; 
const int FEMUR =7; 
const int TIBIAS=9.5; 
/**************************/
const int X_LONGEUR=11.1;
const int Y_LARGEUR=8.6;     //centre vers l'extrémité des pattes
const int HAUTEUR_CORPS=5.5;
const int DISTANCE_patte_G=6;
/**********************/
#define HAUTEUR 9+deplacementcentreZ        //que j'ajoute a l'un ou a l'autre ne changera que la valeur de lhypothénuse...
#define EMPATTEMENT 7+deplacementcentreX 


void IK()
{
  //IK simple (hauteur , latéral , longitudinal ) :
  
  L = sqrt(pow(HAUTEUR,2)+pow(EMPATTEMENT,2)); //Calcul de l'hypothénuse 
  Serial.print(L, DEC);
  Serial.println();
 
  /***Al-Kashi***/
   gamma1 = atan(X_LONGEUR/Y_LARGEUR);   //L'angle gamma est'il bon ? est-ce normal que je doivent rajouter 45°?????
   alpha1 = acos((pow(FEMUR,2)+ pow(L,2) - pow(TIBIAS,2))/ (2*FEMUR*L));
   beta1 = acos((pow(FEMUR,2) + pow(TIBIAS,2) - pow(L,2))/ (2*FEMUR*TIBIAS));
  
   alpha1 = alpha1*57.3;
   delay(50);
   alpha2 = 90 - alpha1;
   delay(50);
   alpha = alpha1 + alpha2;
   delay(50);
   beta=180-(beta1*57.3);
   gamma=(gamma1*57.3)+45;
   
   Serial.print(alpha, DEC);
   Serial.println();
   Serial.print(beta, DEC);
   Serial.println();
   Serial.print(gamma, DEC);
   Serial.println();
   
}

void Offset()
{
   Offset_X = (Y_LARGEUR / 2) +  deplacementcentreX;
   Offset_Y = (X_LONGEUR / 2) +  deplacementcentreY;
   Offset_Z = HAUTEUR - (HAUTEUR_CORPS / 2) + deplacementcentreZ;
   delay(50);
   IK();
}

/**************Demarche*****************/
void Move()
{
  deplacementcentreX=0;
  deplacementcentreY=0;    // modifier les valeur ici revient a modifier l'hypothénuse donc l'extrémité de la patte...
  deplacementcentreZ=0;
  Offset();
  delay(2000);
  
   alpha = alpha*16.6;  //degrée -> PWM
   beta = beta*16.6;
   gamma = gamma*16.6;
   
    Deplacement(16,gamma,Temps);  //test sur une patte pour voir la reaction
    Deplacement(17,alpha,Temps);  
    Deplacement(18,beta,Temps);
}

Le problème c'est que sa n'a pas véritablement de sens se que je fait, que j'agisse sur l'empattement ou sur la hauteur ne change rien.... Sa modifie effectivement l’hypoténuse mais je peux pas gérer la hauteur a proprement dit... Donc je comprend pas comment je peux faire interagir mes offset avec mes angles ...... Puis y'a gamma aussi au quel je doit rajouter 45° sans savoir pourquoi ?

c'est bien atan(x/y);
Donc voila euh je suis a nouveau paumé xD

Justement j'aimerai aussi faire un vrai tutoriel bien expliquer pour le quadrupède sa se fait quand même beaucoup plus maintenant se type de robot.

J'aimerai refaire le mien en plus petit et le moins chère possible pour que n'importe qui puisse le refaire se serait cool !

Du début à la fin la mécanique, les branchement, la prog...etc

J'imagine que c'est possible

mais encore en pire, je pense que, plus il y a de pattes plus c'est dure !

void IK()
{
  //IK simple (hauteur , latéral , longitudinal ) :
  
  L = sqrt(pow(HAUTEUR,2)+pow(EMPATTEMENT,2)); //Calcul de l'hypothénuse (Pythagore)
  Serial.print(L, DEC);
  Serial.println();
 
  /***Al-Kashi***/
   gamma1 = atan(12/16); //Angle du COAX distance séparant le centre du robot et l'extrémité des pattes.

   alpha1 = acos((pow(FEMUR,2)+ pow(L,2) - pow(TIBIAS,2))/ (2*FEMUR*L)); //Angle du FEMUR
   beta1 = acos((pow(FEMUR,2) + pow(TIBIAS,2) - pow(L,2))/ (2*FEMUR*TIBIAS)); //Angle du TIBIAS
   
   Offset_Y = (X_LARGEUR / 2) +  deplacementcentreY;
   Offset_X = Y_LONGEUR / 2 +  deplacementcentreX;
   Offset_Z = HAUTEUR - (HAUTEUR_CORPS / 2) + deplacementcentreZ;
  
   alpha1 = alpha1*57.3;
   delay(50);
   alpha2 = 90 - alpha1;
   delay(50);
   alpha = alpha1 + alpha2;
   delay(50);
   beta=180-(beta1*57.3);
   gamma=(gamma1*57.3)+90;
   
   Serial.print(alpha, DEC);
   Serial.println();
   Serial.print(beta, DEC);
   Serial.println();
   Serial.print(gamma, DEC);
   Serial.println();
   
 
}


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

void avancer()
{  
   IK();
   delay(200);
   int i=0;
   alpha = alpha*16.6;
   beta = beta*16.6;
   gamma = gamma*16.6;
  
   for(i=0; i<=1 ; i++)
  { 
    Deplacement(21,beta,Temps);
    Deplacement(17+3*i,alpha+450,Temps);  //leve patte (j'ajoute une valeur en PWM pour soulever la patte)
    delay(Temps2);
    Deplacement(16+3*i,gamma+400,Temps); //avance en l'ai
    delay(Temps2);
    Deplacement(17+3*i,alpha,Temps);  //reviens au sol
    Deplacement(16+3*i,gamma-250,Temps3); //ramene la patte qui tire le corp
  }
    
   for( i=2; i<=3; i++)
  { 
    Deplacement(27,beta,Temps);
    Deplacement(17+3*i,alpha+450,Temps);
    delay(Temps2);
    Deplacement(16+3*i,gamma-400,Temps); 
    delay(Temps2);
    Deplacement(17+3*i,alpha,Temps);
    Deplacement(16+3*i,gamma+250,Temps3); 
  }    
}

Voila se que j'ai fait :  Tu pourra remarquer que dans avancer j'ai mis alpha, beta et gamma sur les servomoteur. Puis je fait moins ou plus une valeur pour monter, descendre avancer ou reculer les pattes.

 

dans void setup()  :

Mise en marche initialisation de tout les servomoteur a 90° ou 1500 PWM.

 

ensuite :

Lancement méthode IK :

 

Calcul...

Hypothénuse = 11

Alpha = 90

Beta = 93

Gamma = 90

 

Donc c'est bon ? il me retourne les vrai valeur des angles ? c'est correct ? (a part pour le tibias petit décalage du au dimensions peut etre)

 

Maintenant ou je fait intervenir les Offset dans mon programme ?

 

/*****Mesure********* (cm)*/
const int COAX =6;
const int FEMUR =7;
const int TIBIAS=9.5;
/**************************/
const int X_LARGEUR=8.6;
const int Y_LONGEUR=11.1;     //centre vers l'extrémité des pattes
const int HAUTEUR_CORPS=5.5;   //epaissseur du corps du robot
const int DISTANCE_patte_G=6; 
/**********************/
#define HAUTEUR 9   //distance entre le sol et le haut du robot
#define EMPATTEMENT 7

 

double deplacementcentreX=0; // je les initialises a 0 ?

double deplacementcentreY=0;

double deplacementcentreZ=0;

 

Offset_Y = (X_LARGEUR / 2) + deplacementcentreY;
Offset_X = Y_LONGEUR / 2 + deplacementcentreX;
Offset_Z = HAUTEUR - (HAUTEUR_CORPS / 2) + deplacementcentreZ;

 

Dans mon propre programme je voit pas ou faire intervenir les offset enfaite ^^

Non lol je veux pas aller super vite !
C'est juste que je veux comprendre la base pour pas galèrer ensuite..

le problème avec le alpha je l'avais remarquer et corriger mais merci ^^
Sinon normalement cette partie du programme est juste pour le coax c'est arctan(x/y) non ? Après pour les vecteur de direction il me faut tout de même les offset non ?
OffsetX =longueur/2 + deplacementX
Le déplacementenX je l'initialise à 0 au commencement non? Ensuite je ke modifierai pour lui dire de marcher dans un sens ou dans un autre en appelant une gait ?

void IK()
{
  //IK simple (hauteur , latéral , longitudinal ) :
  
  L = sqrt(pow(HAUTEUR,2)+pow(EMPATTEMENT,2)); //Calcul de l'hypothénuse (Pythagore)
  Serial.print(L, DEC);
  Serial.println();
 
  /***Al-Kashi***/
   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));
   
   Offset_Y = (X_LONGEUR / 2) +  deplacementcentreY;
   Offset_X = Y_LARGEUR / 2 +  deplacementcentreX;
   Offset_Z = HAUTEUR - (HAUTEUR_CORPS / 2) + deplacementcentreZ;
  
   alpha = alpha*57.3;
   beta = beta*57.3;
   //bet = 180 - beta;
   
   Serial.print(alpha, DEC);
   Serial.println();
   Serial.print(beta, DEC);
   Serial.println();

}


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

void Move()
{
    IK();
   delay(1000);
   alpha = alpha*16.6;
   beta = beta*16.6;
   Serial.print(alpha, DEC);
   Serial.println();
   Serial.print(beta, DEC);
   Serial.println();
  
   for(int i=0; i<=3 ; i++)
  { 
  Deplacement(16+3*i,NEUTRE,Temps); //coax
  Deplacement(17+3*i,alpha,Temps); //FEMUR
  Deplacement(18+3*i,beta,Temps); //TIBIAS
  }
 
}

/*****Mesure********* (cm)*/
const int COAX =4.5;
const int FEMUR =5.3;
const int TIBIAS=9.5;
/**************************/
const int Y_LARGEUR=8.6;
const int X_LONGEUR=11.1;     //centre vers l'extrémité des pattes
const int HAUTEUR_CORPS=5.5;
const int DISTANCE_patte_G=6;
/**********************/
#define HAUTEUR 5
#define EMPATTEMENT 8

Si je varie la HAUTEUR et L'empattement sa ne correspond absoluement pas si je mesure avec une regle ...

Je suis paumé la j'applique les angles au bon servo mais je n'arrive toujours pas a cerné la logique.

Je voit pas comment faire bouger le centre de mon robot ? vu que ces mes pattes que je doit faire bouger..... informatiquement parlant je voit pas du tout la ... même si j'ai compris que c'est le centre qui bouge et les pattes qui suivent c'est plus facile a dire qu'a faire xD

J'ai essayé se que tu m'a dit de faire, j'ai mis l'angle alpha pour le FEMUR et l'angle Beta pour TIBIAS j'ai bien regarder que sa soit le bon angle !

Mais lorsque je modifie l(empattement ou la hauteur je comprend pas la logique je n'arrive pas a lever le robot plus haut ou étirer sa patte avec l'empattement..

je bug encore un peu sur le problème la lol

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

 

Moi mon problème n'est pas de reprendre ces calculs ou Al-kashi 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 ^^

Et on peut le voir sur le forum ?

Du moins y a un post à sont sujet ?

 

Edit : vu

 

Y'a une vidéo de sont robot a Vaelan sur la page 1 de mon post

Désolée du retard !

  
/*****Mesure********* (cm)*/
const int COAX =3.6; 
const int FEMUR =5; 
const int TIBIAS=10; 
/**************************/
const int Y_LARGEUR=8.6;
const int X_LONGEUR=11.1;    
const int HAUTEUR=5;
const int HAUTEUR_CORPS=5.5;
const int EMPATTEMENT=8;
const int DISTANCE_patte_G=6;

void IK()
{
  //IK simple (hauteur , latéral , longitudinal ) :
  double deplacementcentreX;
  double deplacementcentreY;
  double deplacementcentreZ;
  
  double Offset_Y = (X_LONGEUR / 2) +  deplacementcentreY;
  
  double Offset_X = Y_LARGEUR / 2 +  deplacementcentreX;
  
  double Offset_Z = HAUTEUR - (HAUTEUR_CORPS / 2) + deplacementcentreZ;

  double L = sqrt(pow(HAUTEUR,2)+pow(EMPATTEMENT,2)); //Calcul de l'hypothénuse (Pythagore)
  Serial.print(L, DEC);
  Serial.println();
  
  /***Al-Kashi***/
  
  double alpha = acos((-pow(FEMUR,2) + pow(TIBIAS,2) + pow(L,2))/ (2*TIBIAS*L));  
  double beta = acos((pow(FEMUR,2) - pow(TIBIAS,2) + pow(L,2))/ (2*FEMUR*L));
  double gamma = acos((pow(FEMUR,2) + pow(TIBIAS,2) - pow(L,2))/ (2*FEMUR*TIBIAS));
  
   alpha = alpha*57.3;
   beta = beta*57.3;
   gamma = gamma*57.3;
  Serial.print(alpha, DEC);
  Serial.println();
  Serial.print(beta, DEC);
  Serial.println();
  Serial.print(gamma, DEC);
  Serial.println(); 
}

hypothenuse = 9.4339809417

//en degrée :
alpha = 29.6365776062
beta = 81.4718017578
gamma = 68.9048843383  
 

Quand pense-tu, cela te semble correcte ?

J'ai pris toutes les dimensions que tu m'a montrée sur t'es schéma

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 !

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

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

 

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

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

 

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

 

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

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

ça réduit la taille du programme efficacement !

 

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

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

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

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

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

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


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


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

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


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


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


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

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


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

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

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

#define TOURNER_DROITE 1100
#define TOURNER_GAUCHE 1900

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

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

Merci pour ta réponse

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

 

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

quelle théorème tu utilisait ?

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

 

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

D'accord j'ai bien tout relu ^^

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

//Robot.ino

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

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

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

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


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



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



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

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


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


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

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

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