348 réponses à ce sujet

[Path]

Ok énorme !! Merci

[Oracid]

Pour un robot d'amateur, il se dégage une sensation de puissance impressionnante.
Peut-être qu'une vidéo avec une séquence de mouvements mettrait bien en valeur cette puissance.
Encore bravo.

[Melmet]

Franchement rien a dire que BRAVO

 

Ca donne envie d'avoir le même a la maison )  

 

Vivement la suite ou tu déplace les axes avec des coordonnées cartésiennes par ex . 

[Telson]

C'est propre, c'est beau, ça répond bien au commande, c'est génial !!

[Donovandu88]

Merci les gars.
@Oracid, il n'est pas si puissant que ça. Je suis en train d'imprimer des réducteurs pour avoir plus de couple.
D'autres vidéos viendront ensuite.

@Melmet, les coordonnées c'est pour bientôt, la j'essaye de tout faire fonctionner correctement.
Je n'ai pas montré dans la vidéo mais lorsque je rentre des angles impossible à atteindre, l'écran m'affiche un message avec les différents angles possibles. Pour éviter les collisions.

@Telson, oui, je suis assez satisfait de mon clavier et de la réactivité.

[Donovandu88]

Aujourd’hui, je vais essayer de mettre au point un petit algorithme qui va me permettre d'avoir des mouvements plus fluide.

 

En gros, actuellement lorsque tous les axes bougent en même temps, certains finissent leurs mouvements avant les autres vu qu'ils ont moins de trajet à faire (voir la fin de ma vidéo). Donc la je vais me baser sur l'axe qui à le plus de trajet à faire pour lui attitrer sa vitesse maximum tandis que pour les autres, la vitesse sera réduit de manière proportionnel afin que les mouvements finissent tous en même temps.

[arobasseb]

j'avais fait cet exemple dans lequel je faisait bouger deux servo, à des angles différents mais sur le même laps de temps 

 

http://www.robot-maker.com/forum/topic/11614-robot-bipede-amhnemus/?p=87519

 

si ça peut aider

[Donovandu88]

j'avais fait cet exemple dans lequel je faisait bouger deux servo, à des angles différents mais sur le même laps de temps 

 

http://www.robot-maker.com/forum/topic/11614-robot-bipede-amhnemus/?p=87519

 

si ça peut aider

 

Merci, je ne sais pas si avec la librairie que j'utilise (AccelStepper) si je peux procéder de ta manière. 

Je connais : 

- les "steps/angle voulu" de chaque moteur 

- la  vitesse en "step/sec" de chaque moteur

 

Donc à partir de la, je diminue la vitesse en step/sec des moteurs de façon proportionnel pour que tout le monde arrivent en même temps.

[Telson]

C'est exactement ça.

 

En ce qui me concerne je prend la variation d'angle de chaque servomoteur. Je recherche la variation max et à ce servo, je lui attribue la vitesse max. Pour les autres je fais tout simplement la règle en 3 pour obtenir une proportionnalité.....

[Oracid]

Ce programme est sensé répondre à ce type de problème, http://www.robot-maker.com/forum/topic/11367-yorkshire-mon-petit-quadrupede/?p=84015

[Donovandu88]

C'est exactement ça.

 

En ce qui me concerne je prend la variation d'angle de chaque servomoteur. Je recherche la variation max et à ce servo, je lui attribue la vitesse max. Pour les autres je fais tout simplement la règle en 3 pour obtenir une proportionnalité.....

 

C'est ce que je veux faire aussi. C'est quoi la règle de 3?

 

Ce programme est sensé répondre à ce type de problème, http://www.robot-maker.com/forum/topic/11367-yorkshire-mon-petit-quadrupede/?p=84015

Et avec ton code, Oracid, tous les servos finissent en même temps?

[Donovandu88]

Pour l'instant j'ai réussi à avoir un résultat avec ça :

Avec : 

Mouvements_moteurs(35, 10, 0, 0,0); //Rotation 1, Bras 1, Bras 2, Rotation 2, Bras 3 

void Mouvements_moteurs(int Rotation1, int Bras1, int Bras2, int Rotation2, int Bras3){
  float temps_mouvement;
  float Angle[6];  //Déclaration du tableau pour les différents angles
  Angle[0] = 1;  
  Angle[1] = Rotation1;  
  Angle[2] = Bras1;  
  Angle[3] = Bras2;  
  Angle[4] = Rotation2; 
  Angle[5] = Bras3; 

  for(int i = 0; i <= 5; i++){  
    Angle[0] = max(Angle[0],Angle[i]);  //Comparaison des valeurs pour avoir la plus grande.
  }
  
  
   if(Angle[0] == Rotation1){
   vitesse_Rotation1 = 1000.0;
   calcul_step = (Rotation1/0.1)/(1.8/4); //0.1 correspond au rapport menant/mené donc 10/100 ; 1.8°/Step ; 4 = 1/4
   temps_mouvement = calcul_step/vitesse_Rotation1;
   stepper_rotation1.moveTo(calcul_step);
   stepper_rotation1.setMaxSpeed(vitesse_Rotation1);
}
          else{
          calcul_step = (Rotation1/0.1)/(1.8/4); //0.1 correspond au rapport menant/mené donc 10/100 ; 1.8°/Step ; 4 = 1/4
          vitesse_Rotation1 = calcul_step/temps_mouvement;
          stepper_rotation1.moveTo(calcul_step);
          stepper_rotation1.setMaxSpeed(vitesse_Rotation1);
          }

   if(Angle[0] == Bras1){
   vitesse_Bras1 = 1000.0;
   calcul_step = (Bras1/0.1299)/(1.8/8); //0.1299 correspond au rapport menant/mené donc 10/77 ; 1.8°/Step ; 8 = 1/8
   temps_mouvement = calcul_step/vitesse_Bras1;
   stepper_bras1.moveTo(calcul_step);
   stepper_bras1.setMaxSpeed(vitesse_Bras1);
}
          else{
          calcul_step = (Bras1/0.1299)/(1.8/8); //0.1299 correspond au rapport menant/mené donc 10/77 ; 1.8°/Step ; 8 = 1/8
          vitesse_Bras1 = calcul_step/temps_mouvement;
          stepper_bras1.moveTo(calcul_step);
          stepper_bras1.setMaxSpeed(vitesse_Bras1);
          }


  while(stepper_rotation1.isRunning() || stepper_bras1.isRunning()){ 
  stepper_rotation1.run();stepper_bras1.run();
  Menu = 1;}

}

[Oracid]

Et avec ton code, Oracid, tous les servos finissent en même temps?

L'utilisation est très simple.
- Tu indiques le nombre de servos.
- Tu fais autant de lignes dans le tableau que de servos. Les lignes ont le même nombre de cases, éventuellement modifiable.
- Tu mets les positions successives que les servos doivent atteindre.
- Si un servo ne bouge pas, il faut répéter sa dernière position.

C'est toi qui décide en fonction des données si tes servos s'arrêtent ou pas en même temps.
Tu fais comme tu veux.

Remarque, pour exécuter la fonction Cinematique() une seule fois, il suffit de l'appeler dans le setup() et de la supprimer dans le loop().

[Donovandu88]

D'accord. L'utilisation des tableaux, je le ferais sûrement pour faire des suites d'angles lorsque j'utiliserai le mode "Coordonnées".

[Donovandu88]

J'ai utilisé la méthode de Telson, chercher la variation maximum et lui attribuer la vitesse max.

Voila ce que j'ai réussi à pondre :

//on appel la fonction comme ceci :

Mouvements_moteurs(50, 20, 0, 0, 15); //Rotation 1, Bras 1, Bras 2, Rotation 2, Bras 3



void Mouvements_moteurs(int Rotation1, int Bras1, int Bras2, int Rotation2, int Bras3){
  int boucle = 0;

  float temps_mouvement;
  float Variation_angle[6];  //Déclaration du tableau pour les différents angles et calcul des variaitions d'angle (absolu)

  Variation_angle[0] = 1;  
  Variation_angle[1] = abs(position_Rotation1-Rotation1);  
  Variation_angle[2] = abs(position_Bras1-Bras1);  
  Variation_angle[3] = abs(position_Bras2-Bras2); 
  Variation_angle[4] = abs(position_Rotation2-Rotation2);
  Variation_angle[5] = abs(position_Bras3-Bras3); 


for(int i = 0; i <= 5; i++){  
    Variation_angle[0] = max(Variation_angle[0],Variation_angle[i]);  // Compare les valeurs pour connaitre la plus grande variation.
  }

  //J'assigne à chaque moteur sa futur position 

   Calculs_step_moteur(Rotation1, 1); 
   stepper_Rotation1.moveTo(calcul_step);
   position_Rotation1 = Rotation1;

   Calculs_step_moteur(Bras1, 2);
   stepper_Bras1.moveTo(calcul_step);
   position_Bras1 = Bras1;

   Calculs_step_moteur(Bras2, 3);
   stepper_Bras2.moveTo(calcul_step);
   position_Bras2 = Bras2;

   Calculs_step_moteur(Rotation2, 4);
   stepper_Rotation2.moveTo(calcul_step);
   position_Rotation2 = Rotation2;

   Calculs_step_moteur(Bras3, 5);
   stepper_Bras3.moveTo(calcul_step);
   position_Bras3 = Bras3;
   
while(boucle != 2){
  
    if(Variation_angle[0] == Variation_angle[1]){ //********* Rotation 1 *********
    Calculs_step_moteur(Variation_angle[1], 1);
    temps_mouvement = calcul_step/vitesse_Rotation1;
  }
      else{
    Calculs_step_moteur(Rotation1, 1);
    vitesse_Rotation1 = calcul_step/temps_mouvement;
    stepper_Rotation1.setMaxSpeed(vitesse_Rotation1);
  }
  

    if(Variation_angle[0] == Variation_angle[2]){ //********* Bras 1 *********
     Calculs_step_moteur(Variation_angle[2], 2);
     temps_mouvement = calcul_step/vitesse_Bras1;
  }
      else{
    Calculs_step_moteur(Bras1, 2);
    vitesse_Bras1 = calcul_step/temps_mouvement;
    stepper_Bras1.setMaxSpeed(vitesse_Bras1);
  }
  

    if(Variation_angle[0] == Variation_angle[3]){ //********* Bras 2 *********
    Calculs_step_moteur(Variation_angle[3], 3);
    temps_mouvement = calcul_step/vitesse_Bras2;
  }
      else{
    Calculs_step_moteur(Bras2, 3);
    vitesse_Bras2 = calcul_step/temps_mouvement;
    stepper_Bras2.setMaxSpeed(vitesse_Bras2);
  }


    if(Variation_angle[0] == Variation_angle[4]){ //********* Rotation 2 *********
    Calculs_step_moteur(Variation_angle[4], 4);
    temps_mouvement = calcul_step/vitesse_Rotation2;
  }
      else{
    Calculs_step_moteur(Rotation2, 4);
    vitesse_Rotation2 = calcul_step/temps_mouvement;
    stepper_Rotation2.setMaxSpeed(vitesse_Rotation2);
  }


    if(Variation_angle[0] == Variation_angle[5]){  //********* Bras 3 *********
    Calculs_step_moteur(Variation_angle[5], 5);
    temps_mouvement = calcul_step/vitesse_Bras3;
  }
      else{
    Calculs_step_moteur(Bras3, 5);
    vitesse_Bras3 = calcul_step/temps_mouvement;
    stepper_Bras3.setMaxSpeed(vitesse_Bras3);
  }
boucle ++ ;
}

 
 if(hors_limite == true){
 while(stepper_Rotation1.isRunning() || stepper_Bras1.isRunning() || stepper_Bras2.isRunning()|| stepper_Rotation2.isRunning() || stepper_Bras3.isRunning()){
 stepper_Rotation1.run();stepper_Bras1.run();stepper_Bras2.run();stepper_Rotation2.run();stepper_Bras3.run();
  }
 }
 // On remt la vitesse maximal pour chaque moteur pour les prochaines fois
vitesse_Rotation1 = 1000.0;
vitesse_Bras1 = 1000;//1000
vitesse_Bras2 = 800.0; //3000
vitesse_Rotation2 = 250.0;
vitesse_Bras3 = 500;//500
 stepper_Rotation1.setMaxSpeed(vitesse_Rotation1);stepper_Bras1.setMaxSpeed(vitesse_Bras1);stepper_Bras2.setMaxSpeed(vitesse_Bras2);stepper_Rotation2.setMaxSpeed(vitesse_Rotation2);stepper_Bras3.setMaxSpeed(vitesse_Bras3);
}

void Calculs_step_moteur(int angle, int moteur_step){ //fonction qui calcul les steps moteur et évite les hors-limites
    
  switch(moteur_step){
  case 1:  //Rotation 1 
     calcul_step = (angle/0.1)/(1.8/4); //0.1 correspond au rapport menant/mené donc 10/100 ; 1.8°/Step ; 4 = 1/4
     if ((calcul_step < -888.9)  || (calcul_step > 5111.2)){ //limite Rotation 1 à -40° et +230°
     lcd.clear(); lcd.print(" Hors limites !  ");lcd.setCursor(0, 1);lcd.print("Max 230");lcd.print((char)223);lcd.print(" Min -40");lcd.print((char)223);
     delay(2300); 
     hors_limite = false;
     return;
     }
     break;
    
  case 2:  //Bras 1
     calcul_step = (angle/0.1299)/(1.8/8); //0.1299 correspond au rapport menant/mené donc 10/77 ; 1.8°/Step ; 8 = 1/8
     if ((calcul_step < -3422)  || (calcul_step > 3422)){ //limite Rotation 1 à -100° et +100°
     lcd.clear(); lcd.print(" Hors limites !  ");lcd.setCursor(0, 1);lcd.print("Max 100");lcd.print((char)223);lcd.print("Min -100");lcd.print((char)223);
     delay(2300);  
     hors_limite = false;
     return;   
     }
     break;
    
  case 3:  //Bras 2
     calcul_step = (angle/(0.1639/5))/(1.8/2); //0.1639 correspond au rapport menant/mené donc 10/61 ; 1.8°/Step ; 2 = 1/2
     if ((calcul_step < -4068)  || (calcul_step > 4068)){ //limite Rotation 1 à -120° et +120°
     lcd.clear(); lcd.print(" Hors limites !  ");lcd.setCursor(0, 1);lcd.print("Max 120");lcd.print((char)223);lcd.print(" Min -120");lcd.print((char)223);
     delay(2300); 
     hors_limite = false;
     return;    
     }
     break;

  case 4:  //Rotation 2
     calcul_step = angle/(1.8/4); // 1.8°/Step ; 4 = 1/4
     if ((calcul_step < -100000)  || (calcul_step > 100000)){ //limite Rotation 1 à -40° et +230°
     lcd.clear(); lcd.print(" Hors limites !  ");lcd.setCursor(0, 1);lcd.print("Max 230");lcd.print((char)223);lcd.print(" Min -40");lcd.print((char)223);
     delay(2300);
     hors_limite = false;
     return;     
     }    
     break;

  case 5:  //Bras 3
     calcul_step = (angle/0.2222)/(1.8/4); //0.2222 correspond au rapport menant/mené donc 10/45 ; 1.8°/Step ; 4 = 1/4 
     if ((calcul_step < -1000.2)  || (calcul_step > 1000.2)){ //limite Rotation 1 à -100° et +100°
     lcd.clear(); lcd.print(" Hors limites !  ");lcd.setCursor(0, 1);lcd.print("Max 100");lcd.print((char)223);lcd.print("Min -100");lcd.print((char)223);
     delay(2300); 
     hors_limite = false;
     return;    
     }    
     break;

 }
 valeur_Angle = "";
}

Le problème que j'ai, c'est que la premiers fois ça fonctionne bien, tous les mouvements finissent en même temps et la seconde fois, j'ai un soucis avec les vitesses. les mouvements vont bien à leurs nouvelles positions mais hyper lentement. 

[Telson]

Règle en 3 !!! Elle est bonne celle là !!! Excuse moi. C'est la règle de proportionnalité ou produit en croix .....Désolé !!!

 

 

j'utilise deux tableaux contenant les anciens angles des servomoteurs et les nouveaux à atteindre et ces fonctions :

 

        //Calculs les variations des angles
        Var_Angle();
        //Recherche la variation des angles
        Rech_Var_Max();
        //Calculs la vitesse des servomoteurs
        Calcul_Speed();
        //TRANSFERT DES NOUVEAUX ANGLES DANS old angles
        Transfert_Angle();

 

Voici les fonctions :

 

////calcul des variations d’angle pour chaque servomoteur.
void Var_Angle()
{
        for (int i = 1 ;i<=18 ;i++)
        {
            VarAngle[i] = abs(OldAngle[i] - NewAngle[i]);
        }
}//FIN :: Void Var_Angle()

////////////////////////////////////////////////////////////////////////////////
////Calcul de la vitesse de chaque servomoteur
void Calcul_Speed()
{
    for( int i = 1; i <= 18; i++ )
    {
        if (VarMax==0)
        {
            Speed[i] = 0;
        }
        else if (VarMax>0)
        {

            Speed[i] = ( VarAngle[i] * SpeedMax ) / VarMax; // C'est ça la règle dès 3!!! heu non la règle en croix !!!
        }
    }
}//FIN :: Void Calcul_Speed()


/////////////////////////////////////////////////////////////////////////////////////
////Recherche de la variation maximale, avec la fonction Rech_Var_Max
void Rech_Var_Max()
{
    VarMax = 0 ;
        for(int i=1; i<=18; i++)
        {
                if(VarAngle[i] > VarMax)
                {
                VarMax = VarAngle[i];
                }
        }
}//FIN :: Void Rech_Var_Max()


///////////////////////////////////////////////////////////////////////////////////
////Transfère les nouveaux angles dans le tableau des anciens angles
void Transfert_Angle()
{
    for( int i = 0; i <= 18; i++ ) // for( int i = 1; i <= 18; i++ )
    {
            OldAngle[i] = NewAngle[i];
    }

}//FIN :: Void Transfert_Angle()

 

.......toute remarque et bonne à prendre ......

[arobasseb]

Moi ce que je vais dire ne vas pas forcément faire avancer le schmilblick, plutôt essayer d'améliorer le temps d'exécution du code ou sa lecture.

 

Premier conseil :  dans ton code tu écris tu écris 1.8 / 4   dans ce cas il vaut mieux écrire directement le résultat dans le code (je ne suis pas sur que je compilateur le fasse tout seul) car une division est coûteuse en temps processeur.

 

Deuxième conseil : tu fais un case  dans lequel tu effectues le même traitement en modifiant que certaines valeurs 

 

 

calcul_step = (angle/0.1299)/(1.8/8); //0.1299 correspond au rapport menant/mené donc 10/77 ; 1.8°/Step ; 8 = 1/8
if ((calcul_step < -3422) || (calcul_step > 3422)){ //limite Rotation 1 à -100° et +100°
lcd.clear(); lcd.print(" Hors limites ! ");lcd.setCursor(0, 1);lcd.print("Max 100");lcd.print((char)223);lcd.print("Min -100");lcd.print((char)223);
delay(2300);
hors_limite = false;
return;
}

 

je pense qu'il serait plus judicieux de créer un objet Param_CalculStepMoteur qui contient les valeur limite de seuil et des divisions, ensuite tu fait un tableau que tu initialises avec tous tes objets et du coup au lieu de faire un case tu fais :

void Calculs_step_moteur(int angle, int moteur_step){ //fonction qui calcul les steps moteur et évite les hors-limites
Param_CalculStepMoteur param = monarray[moteur_step]; //attention à l'indice du tableau qui commence à 0

 calcul_step = (angle/pram.coef1)/(param.coef2); //0.1299 correspond au rapport menant/mené donc 10/77 ; 1.8°/Step ; 8 = 1/8
     if ((calcul_step < param.seuil_min)  || (calcul_step > param.seuil_max)){ //limite Rotation 1 à -100° et +100°
     lcd.clear(); lcd.print(" Hors limites !  ");lcd.setCursor(0, 1);lcd.print("Max 100");lcd.print((char)223);lcd.print("Min -100");lcd.print((char)223);
     delay(param.delais);  
     hors_limite = false;
     return;   
     }
}

Je ne sais pas si c'est très clair

 

Voilà pour mes conseils, si quelqu'un à quelque chose à ajouter il est le bienvenue.

 

[Donovandu88]

Merci les gars, je vais essayer d'adapter ça sur mon programme.
Je ne suis pas un grand codeur donc je vais essayer de déchiffrer.
@arobasseb, je vais voir et surtout étudier les "objets" sous Arduino car je ne connais pas encore.
Le faite de tout décortiquer en division c'est surtout pour savoir d'où viennent chaque valeur. Savoir ce que je calcul.

[arobasseb]

Le faite de tout décortiquer en division c'est surtout pour savoir d'où viennent chaque valeur. Savoir ce que je calcul.

Le calcul tu peux le mettre dans le commentaire du coup 🙂

[Donovandu88]

Oui au pire.
J'y pense, ta solution c'est de mettre toutes les valeurs dans des tableaux en faite. Et de tout prendre via un seul calcul.