348 réponses à ce sujet

[Mike118]

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. 

 

 

Je peux me tromper mais quick guess comme ça : dis moi ton problème d'aller lentement , c'est pas par ce que tu essaye d'aller dans l'autre sens et que tu as des angles négatifs et que le " max " de tes angles et donc celui dont la valeur absolue est la plus faible ??  

Essaye ton code en allant deux fois dans le même sens juste pour vérifier avec tout tes angles positifs =) 

 

Si l'erreur est bien là je te laisse essayer de corriger par toi même normalement j'ai donné suffisamment de détails pour que tu trouves  

Sinon je vais regarder ça un peu plus en détails car on peut pas laisser un si beau bras robot avec un petit problème de code comme ça =) 
ça me fait penser au super robot de Pascal aka serveur perso qu'on pouvait piloter à distance et qui avait un super lidar,  mais qui était pas capable de se localiser dans la carte , planifier une trajectoire et éviter un obstacle   ( Heureusement  maintenant on a remédié à ces 3 points avec le robot de pascal ) 

 

[Donovandu88]

Je ferai le test ce soir alors. Et lorsque ça marchera, j'essayerai d'optimiser le code avec des objets.

[Donovandu88]

Je viens d'essayer en mettant des premiers angles aux articulations et ensuite mettre des angles plus élevés, et c'est pareil, la vitesse n'est pas forcément lente mais les mouvements ne finissent pas en même temps. Faut que je me replonge dedans quand je pourrai.

[Mike118]

Bon... 

et si tu essaye ça : 

// Code écrit par Mike118 le 20/10/2017 pour Donovandu88
// Structure de code pour le contrôle de son bras robot BCN3D Moveo
// Ce bras est piloté par 5 moteurs pas à pas
// Le code présenté est compatible avec tout type d'arduino
//
// To do 
//=> Modifier les #define pour correspondre au câblage 
// Bonus pour la suite : 
//=> Ajouter le contrôle des pin Enable dans les fonctions d'initialisation et setSpeed
//=> Faire une fonction qui active ou désactive chaque moteurs et tous les moteurs
// NB : la librairie fait la gestion des pin enable hesitez pas à jeter un oeil à la lib ;)
// => Ajouter un tableau des limites de positions pour chaque axes
// => Convertir les commandes de nombre de pas en angles
// et beaucoup d'autres choses encore ...

#include <AccelStepper.h>

#define NBMOTORS 5

#define EN0 2
#define EN1 3
#define EN2 4
#define EN3 5
#define EN4 6

#define STEP0 7
#define STEP1 8
#define STEP2 9
#define STEP3 10
#define STEP4 11

#define DIR0 12
#define DIR1 13
#define DIR2 A0
#define DIR3 A1
#define DIR4 A2

AccelStepper stepper0(AccelStepper::DRIVER, STEP0, DIR0, 0, 0, 0);
AccelStepper stepper1(AccelStepper::DRIVER, STEP1, DIR1, 0, 0, 0);
AccelStepper stepper2(AccelStepper::DRIVER, STEP2, DIR2, 0, 0, 0);
AccelStepper stepper3(AccelStepper::DRIVER, STEP3, DIR3, 0, 0, 0);
AccelStepper stepper4(AccelStepper::DRIVER, STEP4, DIR4, 0, 0, 0);

AccelStepper stepper[NBMOTORS] = {stepper0, stepper1, stepper2, stepper3, stepper4};

void initStepper(uint8_t i) {
    stepper[i].setMaxSpeed(10000000);
    stepper[i].setSpeed(0);
    // Mettre les enable
}

void initAllSteppers() {
    for (uint8_t i = 0; i < NBMOTORS; i++) {
        initStepper(i);
    }
}

void setSpeedStepper(uint8_t number, float speed) {
    // Gestion du enable si on décide de le faire ici
    stepper[number].setSpeed(speed);
}

void runSpeedSteppers() {
    for (uint8_t i = 0; i < NBMOTORS; i++) {
        stepper[i].runSpeed();
    }
}

void runSteppers(){
    for (uint8_t i = 0; i < NBMOTORS; i++) {
        stepper[i].run();
    }
}

void stopSteppers() {
    for (uint8_t i = 0; i < NBMOTORS; i++) {
        setSpeedStepper(i, 0);
    }
}

void SteppersMoveTo(int16_t pos0, int16_t pos1, int16_t pos2, int16_t pos3, int16_t pos4){
    int16_t positionsToGo[NBMOTORS]; 
    int16_t absDeltaPositions[NBMOTORS];
    uint16_t maxAbsDeltaPosition = 0;
    uint16_t stepperMaxSpeed = 1000;
    positionsToGo[0] = pos0;
    positionsToGo[1] = pos1;
    positionsToGo[2] = pos2;
    positionsToGo[3] = pos3;
    positionsToGo[4] = pos4;
    for (uint8_t i = 0; i < NBMOTORS; i++) {
        stepper[i].moveTo(positionsToGo[i]);
        absDeltaPositions[i] = abs(stepper[i].distanceToGo());
        if( absDeltaPositions[i] > maxAbsDeltaPosition ){
            maxAbsDeltaPosition = absDeltaPositions[i];
        }
    }
    for (uint8_t i = 0; i < NBMOTORS; i++) {
        setSpeedStepper(i,(stepperMaxSpeed * absDeltaPositions[i] ) / maxAbsDeltaPosition);
    }
    while (stepper[0].distanceToGo() || stepper[1].distanceToGo() || stepper[2].distanceToGo() || stepper[3].distanceToGo() || stepper[4].distanceToGo()){
        runSteppers();
    }
}

void setup() {
    initAllSteppers();
}

void loop() {
   SteppersMoveTo(0, 0, 0, 0, 0); 
   SteppersMoveTo(50, 20, 10, 10, 15);
}

en ayant bien entendu modifié les #define =) 
ça donne quoi ? 

[Donovandu88]

Whouaww !!
J'essayerai ton code ce soir.
C'est vraiment gentil de ta pars d'avoir pris sur ton temps pour mon robot. Surtout pour écrire un code si beau ^^ Merci

[Mike118]

Quand je vois de beaux projets comme le tiens partagé et tout et qu'il manque juste un petit bout que je peux apporter sans me donner trop de peine ... ^^ Je peux pas m'empêcher de participer  

J'ai fais pareil avec d'autres, dont le robot de serveur perso pour  : la localisation, la planification de trajectoire dans les différentes pièces et l'évitement dans une pièce =) 

 

Bon par contre garde en tête que j'ai fais ça vite fait donc c'est possible que j'ai glissé une erreur quelque part. Si c'est le cas je me remettrais dessus pour la corriger si tu ne trouves pas toi même =) 

Ce qui est important surtout c'est de voir que j'ai rangé tes moteurs dans des tableaux pour faciliter leur manipulation et limiter les lignes de code =) 
Je t'ai mis un exemple de fonction de paramétrage pour 1 moteur et la fonction qui l'appel pour tous les moteurs, ( init )  pour indiquer comment faire ce genre de chose pour avoir un code plus propre avec moins de lignes =) 

 

Après j'attend une super vidéo où ton bras écrit " Robot Maker " sur une feuille !
 

[Donovandu88]

Bon, hier soir je suis rentré plus tard du travail. Ce matin je fini le transfert d'une pelleteuse et j'espère pour essayer ton code après.
C'est peut être parce que mes moteurs n'ont pas la même vitesse maximale qu'il y a un soucis.
Pour écrire avec le robot, il faudra que j'arrive à faire un sorte de G-code avec des coordonnées pour les moteurs, comme sur une imprimante 3D je pense.

[Donovandu88]

J'ai essayé ton code tel quel en modifiant les defines et j'ai bien des mouvements positifs ou négatifs sur mes axes mais ils ne finissent quand même pas en même temps.

Pour que ton code fonctionne, j'ai du ajouter un setAcceleration dans l'initialisation des moteurs.

J'ai donc essayé de l'adapter sur mon code pour lui attribuer directement mes calculs de step/angle mais j'ai pas eu de super résultat.

 

Cette semaine, je pars en déplacement (à partir de ce soir) donc je ne pourrai pas me re-pencher dessus, je rattaquerais mon étude de ton code à mon retour.

[Mike118]

On verra donc ça à ton retour =) 

[Donovandu88]

Salut, je continu un peu dans le code.

Hier j'ai reçu un moteur avec un réducteur 13:1 ou 14:1 (https://fr.aliexpres...2311.0.0.gCYmt2)

 

Je suis en train d'imprimer une platine (https://www.thingive.../thing:1232817/) pour le fixer et un pignon de 10 dents avec un trou de 8mm pour la courroie.

 

C'est pour mettre sur mon deuxième bras pour gagner en force.

[Donovandu88]

J'ai des problèmes en utilisant :

AccelStepper steppers[5] = {stepper_Rotation1, stepper_Bras1, stepper_Bras2, stepper_Rotation2, stepper_Bras3};

Quand je fais un :

for (int i = 0; i < 5; i++) {
  steppers[i].moveTo(calcul_step);
}

Les positions ne sont pas assignées aux moteurs. Je suis obligé de le faire manuellement pour chaque moteur.

Une solutions?

[Mike118]

Hum ... Un peu plus de détail sur le code utilisé stp ? 
Tu peux envoyer un .ino complet ?

[Donovandu88]

C'est par rapport au code que tu m'a donné, j'essaye de l'utiliser en le simplifiant avec des boucles pour éviter de tout faire manuellement.

En gros j'ai ça :

#include <AccelStepper.h>


const int enablePin = 8; //activer les moteurs du CNC Shield
AccelStepper stepper_Rotation1(1,2,5); // Driver X CNC Shield
AccelStepper stepper_Bras1(1,9,10); //Limit X Axis et Limite Y Axis
AccelStepper stepper_Bras2(1,3,6); // Driver Y CNC Shield
AccelStepper stepper_Rotation2(1,4,7); // Driver Z CNC Shield
AccelStepper stepper_Bras3(1,12,13); // Driver A CNC Shield 

AccelStepper steppers[5] = {stepper_Rotation1, stepper_Bras1, stepper_Bras2, stepper_Rotation2, stepper_Bras3};

int position_moteur[5];
int vitesse_steppers[5] = {1000, 1000, 1500, 250, 500};

void setup() {
    pinMode(enablePin,OUTPUT);
    digitalWrite(enablePin,LOW); // pour activer les drivers A4988 

    initialisation();

}

void loop() {
  Reste du code

}

void initialisation(){
  for (int i = 0; i < 5; i++) {
   steppers[i].setMaxSpeed(vitesse_steppers[i]);
   steppers[i].setAcceleration(8000.0);
   position_moteur[i] = 0;
   }
}

[Mike118]

Mince j'avais raté ton message. 
 

 

du coup le code

for (int i = 0; i < 5; i++) {
steppers[i].moveTo(calcul_step);
}

doit fonctionner et dire à chaque moteur de se déplacer du même nombre de pas égale à calcul_step ... 
 

Pour moi ce que tu as fait

 

 

C'est par rapport au code que tu m'a donné, j'essaye de l'utiliser en le simplifiant avec des boucles pour éviter de tout faire manuellement.

En gros j'ai ça :

#include <AccelStepper.h>


const int enablePin = 8; //activer les moteurs du CNC Shield
AccelStepper stepper_Rotation1(1,2,5); // Driver X CNC Shield
AccelStepper stepper_Bras1(1,9,10); //Limit X Axis et Limite Y Axis
AccelStepper stepper_Bras2(1,3,6); // Driver Y CNC Shield
AccelStepper stepper_Rotation2(1,4,7); // Driver Z CNC Shield
AccelStepper stepper_Bras3(1,12,13); // Driver A CNC Shield 

AccelStepper steppers[5] = {stepper_Rotation1, stepper_Bras1, stepper_Bras2, stepper_Rotation2, stepper_Bras3};

int position_moteur[5];
int vitesse_steppers[5] = {1000, 1000, 1500, 250, 500};

void setup() {
    pinMode(enablePin,OUTPUT);
    digitalWrite(enablePin,LOW); // pour activer les drivers A4988 

    initialisation();

}

void loop() {
  Reste du code

}

void initialisation(){
  for (int i = 0; i < 5; i++) {
   steppers[i].setMaxSpeed(vitesse_steppers[i]);
   steppers[i].setAcceleration(8000.0);
   position_moteur[i] = 0;
   }
}

 

est très bien =) 

Après je te recommande de faire aussi un tableau du type 

 

 

int16_t nextStep[5]={0}; 
 

 

pour ensuite faire du : 

for (int i = 0; i < 5; i++) {
steppers[i].moveTo(nextStep[i]);
}

Si j'ai répondu à ta question tant mieux ^^ Sinon je pense que c'est par ce que je ne comprends pas ton problème ... 
Donc dans ce cas je veux bien encore un peu plus de détails. 

[R1D1]

Idée à deux balles : est-ce que ça ne serait pas un problème de référence ? En gros, quand tu créés "steppers[5]", tu fais des copies des objets créés au dessus. Mais la classe AccelStepper permet-elle de créer et manipuler des copies des objets initiaux ?
Pour le tester : si tu remplaces ta boucle d'appel à moveTo par un appel explicite à chaque objet (e.g. Stepper_bras.moveTo(...) ) est-ce que ça fonctionne ? Si oui, le problème vient potentiellement de cette copie, si non, il faut chercher ailleurs

[Mike118]

Ce ne sont pas des copies mais les pointeurs des objets qui sont passés en paramètre. 

Je ne pense pas que l'erreur soit à chercher de ce côté =) 
J'utilise cette méthode perso et j'ai jamais vu de problèmes jusqu'à maintenant =) 

[Donovandu88]

Normalement ça fonctionne car le code de Mike qui utilise les objets de cette manière fonctionne. Mais dans le miens, non. Je vais essayer de regarder ce soir.

[Path]

C'est peut-être ça : 

la méthode moveTo donne une nouvelle position absolue. Elle retourne sans délai. Le mouvement est déclenché par l'appel à la méthode run().

Et run doit être appelé en boucle.

https://www.pjrc.com...celStepper.html

[Mike118]

Ah je me disais bien que j'avais pas compris le problème!  

En effet si tu n'utilise pas la fonction run() en boucle pour chacun des moteurs derrière ça ne marche pas =) 
Mais je ne pensais pas que c'était ça ton problème vu que tu semblais maitriser la librairie =) 

[Donovandu88]

Non je n'ai pas de problème avec la fonction run(). C'est juste que le moveTo n'était pas prit en compte en boucle. Je vais refaire des essais ce soir j'espère.