Go Down

Topic: Débutant qui galère avec 2steps, 2servos, et 4 potentiomètre  (Read 1 time) previous topic - next topic

proautobot

Me re-voila ( l'acharné qui ferais mieux de réviser ses maths ).

J'ai réussi plus ou moins à piloter mes moteurs pas à pas avec des boutons poussoir, elle est vraiment bien cette bibliothèque. Je peux les piloter en même temps, cela manque de précision tout de même. En plus les boutton colle aux doigts et se "déclips" de la breadboards.

Voici mon code:
 
Code: [Select]
//Attention aux fil, ils risque d'être arraché car il n'y a pas de fin de course et donc aucune position initial ou autre.

#include <AccelStepper.h> // bibliothèque pour contrôler en même temps plusieurs moteurs pas à pas.
//#include <MultiStepper.h> //vérifier si utile//

AccelStepper mystepper1(8, 10, 12, 11, 13);// A unipolar stepper motor , controlled by 4 transistors.
AccelStepper mystepper2(8, 6, 8, 7, 9);

int bp1, bp2, bp3, bp4; //Variable des boutons poussoirs (bp).
boolean etatBp1, etatBp2, etatBp3, etatBp4; //Variable des états des boutons poussoirs.

void setup() {

  Serial.begin(9600); // établissement d'une communication à 9600 bauds.
  Serial.println("communication établie"); // <- afficher ce message.

  bp1 = 2; // attribution des pins.
  bp2 = 3;
  bp3 = 4;
  bp4 = 5;

  pinMode(bp1, INPUT_PULLUP); //lecture des pins en mode input_pullup avec résistance de 10K ohm intégrées à arduino
  pinMode(bp2, INPUT_PULLUP); // pour les bouttons poussoirs.
  pinMode(bp3, INPUT_PULLUP);
  pinMode(bp4, INPUT_PULLUP);

  mystepper1.setMaxSpeed(1000); //Sets the maximum speed. stepsPerSecond
  mystepper1.setAcceleration(300); // accelération en seconde²
  mystepper1.setSpeed(200); // paramètre de vitesse
  // mystepper1.moveTo(2048); //se déplacer vers 2048 = nombre de pas pour un tour.

  mystepper2.setMaxSpeed(1000); //Sets the maximum speed. stepsPerSecond
  mystepper2.setAcceleration(300); // accelération en seconde²
  mystepper2.setSpeed(200); // paramètre de vitesse
  // mystepper2.moveTo(2048); //se déplacer vers 2048 = nombre de pas pour un tour.


}

void loop() {
 
  etatBp1 = digitalRead(bp1); // étatBp = 0 ou 1, (valeur booléenne).
  etatBp2 = digitalRead(bp2);
  etatBp3 = digitalRead(bp3);
  etatBp4 = digitalRead(bp4);
 
 
                               //déplacement :
  if (etatBp1 == 0)            //bas
  {mystepper1.move(100);}
  mystepper1.run();            // activer les instruction de déplacement
                               
   if (etatBp2 == 0)           //Haut
  {mystepper1.move(-100);}
  mystepper1.run();           // activer les instruction de déplacement
 
   if (etatBp3 == 0)          //gauche
  {mystepper2.move(100);}
  mystepper2.run();          // activer les instruction de déplacement
 
  if (etatBp4 == 0)          //droite
  {mystepper2.move(-100);}   
  mystepper2.run();         // activer les instruction de déplacement
 
}


Cela vous plais ?

Maintenant le but ça va être d'enregistrer une série de mouvements et de les refaire en boucle.

En tout cas merci pour les info mécanique, cependant, avec stepper.h je pouvais faire le lien, mais avec accelstepper c'est plus compliqué.

Premier critère, je suis en demi pas (les fameux 8 ), mais je fait un tour avec 2048 pas quand même. accelstepper compte en pas et non en demi pas malgré le faite que le moteur soit paramétré en demi pas ?

Cette foit la vitesse max n'est pas de 300, avec stepper.h je décrochai au delà. Avec accelstepper.h je suis ici à 1000 et je peux monter encore. Ceci est possible grace à l'accélération progressive ? ou alors ce n'est plus la même unité de vitesse entre les deux bibliothèques ?

Mes moteurs sont bien plus chaud ( pas brûlant ), avec stepper.h je n'arrivais pas à soulever mon bras malgré le faite que j'arrivais à faire tourner le moteur à vide ( juste avant que tout parte en 3#@lle) maintenant je le lève sans problème.

la décélération altère sur la maniabilité, en effet lorsque je lâche le bouton , elle continue à déplacer considérablement le bras. C'est possible de l'arrêter net, sans risque électronique ?

pour finir bonne soirée à vous =).


 

ChPr

... la décélération altère sur la maniabilité, en effet lorsque je lâche le bouton , elle continue à déplacer considérablement le bras. C'est possible de l'arrêter net, sans risque électronique ? ...
Relisez la doc, toutes les unités y sont décrites.

Pour stopper net un mouvement, a priori, il faut redéfinir l'accélération à une valeur très grande et faire un stop();

Cordialement.

Pierre
Pourquoi faire simple alors qu'il est si facile de faire compliqué !

proautobot

Moi et l'anglais ...D'accord je vais relire. Je n'avais pas compris que l'on pouvait modifier l'accélération, le temps d'une action, merci je m'y colle.

Juste pour cerner mon niveau, je programme que depuis septembre dernier donc j'ai du boulot pour me perfectionner, j'ai un fablab non loin de chez moi, je devrais aller y faire un tour. ;)

proautobot

Bonjour, (k'ment k'say d'pui-l temps ? = comment ça va ?)

Je suis de retour, avec peu d'avancement. J'ai fait plain d'essais, j'ai adapté vos conseils à mon programmes et j'ai fais plain de recherche, pour peu de compréhension et donc peu d'information. Bref j'ai pondu ce programme qui resemble beaucoup au premier. La lecture d'une analogue en plus, avec des fonctions, sans doute, évitables pour l'instant.

Code: [Select]

/////////////////////////////Stepper/////////////////////////////
#include <AccelStepper.h> // bibliothèque pour contrôler en même temps plusieurs moteurs pas à pas.
#include <MultiStepper.h>

#define PIN_POTAR_4 A4  //analogue
#define PIN_POTAR_5 A5

AccelStepper mystepper1(8, 10, 12, 11, 13);// A unipolar stepper motor , controlled by 4 transistors.
AccelStepper mystepper2(8, 6, 8, 7, 9);

int valeur_pour_mystepper_1 ;

int valeur_pour_mystepper_2 ;

/////////////////////variable pour le message d'accueil du void loop///////////////////
int loop_activee = 1;

/////////////////////////////Servo///////////////////////////////
#include <Servo.h>

#define PIN_SERVO_1 A0
#define PIN_SERVO_2 A1

#define PIN_POTAR_1 A2
#define PIN_POTAR_2 A3

//Création des objets servo pour controler les servo
Servo servo_1;
Servo servo_2;

int valeur_pour_servo_1 ; //Variable qui stock la position du servo
int valeur_affichage_1;  //varaible utilisée pour la condition d'affichage
int valeur_precedente_servo_1; //variable pour le calcul de la condition d'affiche
int valeur_pour_servo_2 ;
int valeur_affichage_2;
int valeur_precedente_servo_2;


void setup() {
  /////////////////////////////Communication////////////////////////

  Serial.begin(9600); // établissement d'une communication à 9600 bauds.
  Serial.println("communication établie"); // <- afficher ce message.


  /////////////////////////////Stepper/////////////////////////////


  mystepper1.setMaxSpeed(1000); //Sets the maximum speed. stepsPerSecond
  mystepper1.setAcceleration(100); // accelération en seconde²
  mystepper1.setSpeed(300); // paramètre de vitesse
  //  mystepper1.moveTo(500); //se déplacer vers 2048 = nombre de pas pour un tour.


  mystepper2.setMaxSpeed(1000); //Sets the maximum speed. stepsPerSecond
  mystepper2.setAcceleration(100); // accelération en seconde²
  mystepper2.setSpeed(300); // paramètre de vitesse
  // mystepper2.moveTo(2048); //se déplacer vers 2048 = nombre de pas pour un tour


  /////////////////////////////Servo///////////////////////////////

  pinMode (PIN_SERVO_1, OUTPUT);
  pinMode (PIN_SERVO_2, OUTPUT);

  servo_1.attach(PIN_SERVO_1);
  servo_2.attach(PIN_SERVO_2);


}

void loop() {
  /////////////////message d'acueille du void loop/////////////////
  if (loop_activee == 1) {
    Serial.println("loop activée");
    loop_activee = 0;
  }


  /////////////////////////////Stepper//////////////
  mystepper1.setMaxSpeed(1000); //Sets the maximum speed. stepsPerSecond
  mystepper1.setAcceleration(100); // accelération en seconde²
  mystepper1.setSpeed(300); // paramètre de vitesse
  //  mystepper1.moveTo(500); //se déplacer vers 2048 = nombre de pas pour un tour.


  mystepper2.setMaxSpeed(1000); //Sets the maximum speed. stepsPerSecond
  mystepper2.setAcceleration(100); // accelération en seconde²
  mystepper2.setSpeed(300); // paramètre de vitesse
  // mystepper2.moveTo(2048); //se déplacer vers 2048 = nombre de pas pour un tour


  //Lecture de l'Analogue 1 potentiometre 1
  int valPotentio1 = analogRead(A4);
  int valeur1 = map(valPotentio1, 0, 1023, -3, 3);
  Serial.print ("valeur 1:");
  Serial.println(valeur1);

  //Lecture de l'Analogue 1 potentiometre 2
  int valPotentio2 = analogRead(A5);
  int valeur2 = map(valPotentio2, 0, 1023, -3, 3);
  Serial.print ("valeur 2:");
  Serial.println(valeur2);

  //activations des moteurs pas à pas en fonction de la position de l'Analogue 1//

  //mystepper1//

  if (valeur1 == 3)//////////////-3//
  {
    avance_rapide_1();
  }
  mystepper1.run();

  if (valeur1 == 2)///////////////-2//
  {
    avance_moyenne_1();
  }
  mystepper1.run();

  if (valeur1 == 1)///////////////-1//
  {
    avance_lente_1();
  }
  mystepper1.run();

  if (valeur1 == 0)////////////////-1//
  {
    arret_1();
  }
  mystepper1.run();

  if (valeur1 == -1)///// /////////////1//
  {
    avance_lente_inverse_1();
  }
  mystepper1.run();

  if (valeur1 == -2)////////////////////2//
  {
    avance_moyenne_inverse_1();
  }
  mystepper1.run();

  if (valeur1 == -3)///////////////////3//
  {
    avance_rapide_inverse_1();
  }
  mystepper1.run();


  //mystepper2//

  if (valeur2 == 3)///////////////////3//
  {
    avance_rapide_2();
  }
  mystepper2.run();

  if (valeur2 == 2)///////////////////2//
  {
    avance_moyenne_2();
  }
  mystepper2.run();

  if (valeur2 == 1)///////////////////1//
  {
    avance_lente_2();
  }
  mystepper2.run();

  if (valeur2 == 0)//////////////////-1//
 
    arret_2();
  }
  mystepper2.run();

  if (valeur2 == -1)////////////////////////////////-1//
  {
    avance_lente_inverse_2();
  }
  mystepper2.run();

  if (valeur2 == -2)///////////////////-2//
  {
    avance_moyenne_inverse_2();
  }
  mystepper2.run();

  if (valeur2 == -3)////////////////-3//
  {
    avance_rapide_inverse_2();
  }
  mystepper2.run();


  /////////////////////////////Servo/////////////

  //On met à l'échelle la valeur des potentiomètres (0-1023)
  //par rapport à l'échelle du servo (0-179°)
  valeur_pour_servo_1 = map(analogRead(PIN_POTAR_1), 0, 1023, 80, 179);
 /* valeur_affichage_1 = valeur_pour_servo_1 - valeur_precedente_servo_1;
  valeur_precedente_servo_1 = valeur_pour_servo_1;
  if (valeur_afficage_1 != 1)
  {Serial.print("valeur_pout_servo_1")}*/

  //On met à l'échelle la valeur des potentiomètres (0-1023)
  //par rapport à l'échelle du servo (0-179°)
  valeur_pour_servo_2 = map(analogRead(PIN_POTAR_2), 0, 1023, 0, 179);
  /*valeur_affichage_2 = valeur_pour_servo_2 - valeur_precedente_servo_2;
  valeur_precedente_servo_2 = valeur_pour_servo_2;
    if (valeur_afficage_2 != 1)
  {Serial.print("valeur_pout_servo_2")}*/

  servo_1.write(valeur_pour_servo_1);
  servo_2.write(valeur_pour_servo_2);

}

//déclaration des fonctions/////////////
///////////////////mystepper1//////////
void avance_rapide_1() ///////////////
{
  mystepper1.move(500);
  mystepper1.run();
}
void avance_moyenne_1() //
{
  mystepper1.move(200);
  mystepper1.run();
}
void avance_lente_1() //
{
  mystepper1.move(100);
  mystepper1.run();
}
void avance_rapide_inverse_1() //////////
{
  mystepper1.move(-500);
  mystepper1.run();
}
void avance_moyenne_inverse_1() //
{
  mystepper1.move(-200);
  mystepper1.run();
}
void avance_lente_inverse_1() //
{
  mystepper1.move(-100);
  mystepper1.run();
}
void arret_1()
{
  mystepper1.setMaxSpeed(1000); //Sets the maximum speed. stepsPerSecond
  mystepper1.setAcceleration(5000); // accelération en seconde²
  mystepper1.setSpeed(300); // paramètre de vitesse
 
  mystepper1.move(0);
  mystepper1.run();
}

////////////////mystepper2///////////

void avance_rapide_2() ////////////
{
  mystepper2.move(500);
  mystepper2.run();
}
void avance_moyenne_2() //
{
  mystepper2.move(200);
  mystepper2.run();
}
void avance_lente_2() //
{
  mystepper2.move(400);
  mystepper2.run();
}
void avance_rapide_inverse_2() ///////
{
  mystepper2.move(-500);
  mystepper2.run();
}
void avance_moyenne_inverse_2() //
{
  mystepper2.move(-200);
  mystepper2.run();
}
void avance_lente_inverse_2() //
{
  mystepper2.move(-400);
  mystepper2.run();
}
void arret_2()
{
  mystepper2.setMaxSpeed(1000); //Sets the maximum speed. stepsPerSecond
  mystepper2.setAcceleration(5000); // accelération en seconde²
  mystepper2.setSpeed(300); // paramètre de vitesse

  mystepper2.move(0);
  mystepper2.run();

}

Donc, mon but est de contrôler les moteurs pas à pas, avec une analogue celons trois vitesses (comme dans un jeu marche, trottine, cour). Le résultat est pour une énième fois décevant; peut importe ce que je paramètre, le bras avance très lentement, à une seul vitesse(peut importe la position 1,2 ou 3 de l'analogue ) et  ne s'arrête pas immédiatement, même si je suis en position zero. Un peux comme pour le programme précédent.
D'ailleur en parlant de la position zero, tel quel dans le programme que je vous partage, les moteurs tournent dans un sens, sans rien demander. Pour pouvoir utiliser le bras je suis obligé de désactiver cette étape du programme.
Vous me dite que la doc accelstepper est bien détaillée, pouvez vous me donner le liens de ce que vous appelez bien détaillé ?
PS:
Et s'il vous plait, arrêtez avec le "google est ton amis. Surtout si c'est pour tombé sur des conclusions du type "sinon essaye avec une corde et un bout de laine".


dfgh

hello
je n'ai pas détaillé le principe de ton code, je l'ai simplement modifié pour le rendre plus digest

Code: [Select]

/////////////////////////////Stepper/////////////////////////////
#include <AccelStepper.h> // bibliothèque pour contrôler en même temps plusieurs moteurs pas à pas.
#include <MultiStepper.h>

#define PIN_POTAR_4 A4  //analogue
#define PIN_POTAR_5 A5

AccelStepper mystepper1(8, 10, 12, 11, 13);// A unipolar stepper motor , controlled by 4 transistors.
AccelStepper mystepper2(8, 6, 8, 7, 9);

int valeur_pour_mystepper_1 ;

int valeur_pour_mystepper_2 ;

/////////////////////variable pour le message d'accueil du void loop///////////////////
int loop_activee = 1;

/////////////////////////////Servo///////////////////////////////
#include <Servo.h>

#define PIN_SERVO_1 A0
#define PIN_SERVO_2 A1

#define PIN_POTAR_1 A2
#define PIN_POTAR_2 A3

//Création des objets servo pour controler les servo
Servo servo_1;
Servo servo_2;

int valeur_pour_servo_1 ; //Variable qui stock la position du servo
int valeur_affichage_1;  //varaible utilisée pour la condition d'affichage
int valeur_precedente_servo_1; //variable pour le calcul de la condition d'affiche
int valeur_pour_servo_2 ;
int valeur_affichage_2;
int valeur_precedente_servo_2;


void setup() {
  /////////////////////////////Communication////////////////////////
  Serial.begin(115200); // établissement d'une communication à 9600 bauds.
  Serial.println("communication établie"); // <- afficher ce message.
  /////////////////////////////Stepper/////////////////////////////
  mystepper1.setMaxSpeed(1000); //Sets the maximum speed. stepsPerSecond
  mystepper1.setAcceleration(100); // accelération en seconde²
  mystepper1.setSpeed(300); // paramètre de vitesse
  //  mystepper1.moveTo(500); //se déplacer vers 2048 = nombre de pas pour un tour.
  mystepper2.setMaxSpeed(1000); //Sets the maximum speed. stepsPerSecond
  mystepper2.setAcceleration(100); // accelération en seconde²
  mystepper2.setSpeed(300); // paramètre de vitesse
  // mystepper2.moveTo(2048); //se déplacer vers 2048 = nombre de pas pour un tour
  /////////////////////////////Servo///////////////////////////////
  pinMode (PIN_SERVO_1, OUTPUT);
  pinMode (PIN_SERVO_2, OUTPUT);
  servo_1.attach(PIN_SERVO_1);
  servo_2.attach(PIN_SERVO_2);
}

void loop()
{
  /////////////////message d'acueille du void loop/////////////////
  if (loop_activee == 1){Serial.println("loop activée");loop_activee = 0;}

  /////////////////////////////Stepper//////////////
  mystepper1.setMaxSpeed(1000); //Sets the maximum speed. stepsPerSecond
  mystepper1.setAcceleration(100); // accelération en seconde²
  mystepper1.setSpeed(300); // paramètre de vitesse
  //  mystepper1.moveTo(500); //se déplacer vers 2048 = nombre de pas pour un tour.

  mystepper2.setMaxSpeed(1000); //Sets the maximum speed. stepsPerSecond
  mystepper2.setAcceleration(100); // accelération en seconde²
  mystepper2.setSpeed(300); // paramètre de vitesse
  // mystepper2.moveTo(2048); //se déplacer vers 2048 = nombre de pas pour un tour

  /////////////////////////////Commandes moteurs/////////////
  int valPotentio1 = analogRead(A4);
  int valeur1 = map(valPotentio1, 0, 1023, -3, 3);
  Serial.print ("valeur 1:"); Serial.println(valeur1);

  int valPotentio2 = analogRead(A5);
  int valeur2 = map(valPotentio2, 0, 1023, -3, 3);
  Serial.print ("valeur 2:"); Serial.println(valeur2);

  switch (valeur1)
  {
    case  3 : {avance(1, 500);mystepper1.run();} break;
    case  2 : {avance(1, 200);mystepper1.run();} break;
    case  1 : {avance(1, 100);mystepper1.run();} break;
    case  0 : {arret (1, 1000, 5000, 300);mystepper1.run();} break; //n mot, 1000,5000,300
    case -1 : {avance(1,-100);mystepper1.run();} break;
    case -2 : {avance(1,-200);mystepper1.run();} break;
    case -3 : {avance(1,-500);mystepper1.run();} break;
    default : break;
  }

  switch (valeur2)
  {
    case  3 : {avance(2,  500);mystepper2.run();} break;
    case  2 : {avance(2,  200);mystepper2.run();} break;
    case  1 : {avance(2,  100);mystepper2.run();} break;
    case  0 : {arret (2,  1000, 5000, 300);mystepper2.run();} break; //n mot, 1000,5000,300
    case -1 : {avance(2, -100);mystepper2.run();} break;
    case -2 : {avance(2, -200);mystepper2.run();} break;
    case -3 : {avance(2, -500);mystepper2.run();} break;
    default : break;
  }

  /////////////////////////////commmandes Servos /////////////
  valeur_pour_servo_1 = map(analogRead(PIN_POTAR_1), 0, 1023, 80, 179);
  valeur_pour_servo_2 = map(analogRead(PIN_POTAR_2), 0, 1023, 0, 179);
  /////////////////////////////Fonctions Servos /////////////
  servo_1.write(valeur_pour_servo_1);
  servo_2.write(valeur_pour_servo_2);
}

  /////////////////////////////Fonctions moteurs/////////////

  void avance(int moteur, int vitesse)            //500, 200, 100 -100, -200, -500
  {
    switch (moteur)
    {
      case 1: {
          mystepper1.move(vitesse);Serial.print("avance ou recul moteur 1 avec vitesse de: ");Serial.println(vitesse);
          mystepper1.run();
        }
        break;
      case 2: {
          mystepper2.move(vitesse);Serial.print("avance ou recul moteur 2 avec vitesse de: ");Serial.println(vitesse);
          mystepper2.run();
        }
        break;
    }
  }

  void arret(int moteur, int vitesse_max, int accel, int vitesse) //n mot, 1000,5000,300
  {
    switch (moteur)
    {
      case 1: {Serial.print("arret moteur 1 avec vitesse max de: ");Serial.println(vitesse_max);
          mystepper1.setMaxSpeed(vitesse_max); //Sets the maximum speed. stepsPerSecond
          mystepper1.setAcceleration(accel); // accelération en seconde²
          mystepper1.setSpeed(vitesse); // paramètre de vitesse
          mystepper1.move(0);
          mystepper1.run();
        }
        break;
      case 2: {Serial.print("arret moteur 2 avec vitesse max de: ");Serial.println(vitesse_max);
          mystepper2.setMaxSpeed(vitesse_max); //Sets the maximum speed. stepsPerSecond
          mystepper2.setAcceleration(accel); // accelération en seconde²
          mystepper2.setSpeed(vitesse); // paramètre de vitesse
          mystepper2.move(0);
          mystepper2.run();
        }
        break;
    }
  }







proautobot

=) ok merci beaucoup, c'est vrais que je n'ai pas encore une bonne syntaxe, je n'ai pas encore  étudié le switch, et je ne savais pas que l'on pouvais écrire deux ligne de code sur la même ligne.
C'est cool.

Sur ce, personne n'a d'indice pour accelStepper ?

J-M-L

je ne savais pas que l'on pouvais écrire deux ligne de code sur la même ligne.
C'est cool.
c'est cool mais c'est pas une super pratique dans la majorité des cas car ça nuit à la lisibilité (dans quelques cas c'est OK si c'est simple à lire)

pour votre soucis je pense que vous devriez commencer tout simple avec 1 seul moteur et apprendre les fonctions de la librairie
Please do not PM me for help,  others will benefit as well if you post your question publicly on the forums
Pas de messages privés SVP

dfgh

j'ai voulu regarder un peu ton code, et je tombe sur tes déclarations de moteurs


pourquoi donnes tu 5 pinoches par declaration de moteur?
Quote
AccelStepper mystepper1(8, 10, 12, 11, 13);// A unipolar stepper motor , controlled by 4 transistors.
AccelStepper mystepper2(8, 6, 8, 7, 9);
et si je me fie à ton "schéma fritzing" du depart,
tu as un moteur sur 5,6,7,8
et l'autre sur 9,10,11,12

proautobot

Oui je pense que je vais tout démonter pour faire des essaies à vide (j'ai fais un robot style "mearm"avec des touillettes à café ^^).

En faite je ne déclare pas 5 pinoches mais 4, le premier chiffre "8"c'est pour être en demi pas, j'ai trouvé çà sur le net :

AccelStepper mystepper(4, pinA1, pinA2, pinB1, pinB2);
A unipolar stepper motor, controlled by 4 transistors.

et celle-ci sont croisée, si non je suis obligé de croisé les fils, en effet je pense que mon interface uln est câblée "en croisée". Au début ça ne fonctionnais pas, je me demandais pourquoi.

donc Actuellement je suis câblé ainsi :
mystepper1: 6 7 8 9  et programmer en 6 8 7 9
mystepper2: 10 11 12 13  ; 10 12 11 13
Les alimentations 5v sont secondaires avec le ground en commun.

dfgh

tu es sur du 8 pour les demis pas ?

je ne suis pas une bête en anglais, mais je crois comprendre que le 1 er paramètre doit être un 2 ou un 4 selon que tu câbles un moteur 2 ou 4 fils.

Quote
AccelStepper(uint8_t pins = 4, uint8_t pin1 = 2, uint8_t pin2 = 3, uint8_t pin3 = 4, uint8_t pin4 = 5);


/// \param[in] pins Number of pins to interface to 1.
2 or 4 are supported. 1 means a stepper driver (with Step and Direction pins)
2 means a 2 wire stepper. 4 means a 4 wire stepper.  Defaults to 4 pins.
    /// \param[in] pin1 Arduino digital pin number for motor pin 1. Defaults to pin 2.

 For a driver (pins==1), this is the Step input to the driver. Low to high transition means to step)

    /// \param[in] pin2 Arduino digital pin number for motor pin 2. Defaultsto pin 3.
 
For a driver (pins==1), this is the Direction input the driver. High means forward.

    /// \param[in] pin3 Arduino digital pin number for motor pin 3. Defaults to pin 4.

    /// \param[in] pin4 Arduino digital pin number for motor pin 4. Defaults to pin 5.


proautobot

Bonjour,

Je suis d'accord, j'ai essayé avec 4, je gagne en vitesse, mais je doit perdre en précision,(c'est pas important). Je vais rester en 4, mais en 8 ça fonctionne aussi. Je pense que c'est en demi pas si j'utilise 8. Maintenant j'ai toujours se problème, j'ai qu'une vitesse, et je n'ai toujours pas de ''stop'' net quand je positionne l'analogue à 0, d'ailleurs cette latence, ressenti dans le pilotage du robot, est amplifiée si je met 4 aux lieux de 8 (Puisque la vitesse est doublée la décélération est plus longue).

Et j'ai toujours ce satané problème du robot qui pète les plombs. En effet, je branche que les moteurs pas à pas tout va bien, je branche que les servos tout va bien, je met tout en même temps et les servo finissent par bugger et ne réponde plus, soit je coupe et je r'allume soit je débranche les moteurs pas à pas et les servo se debuggent. J'ai aussi un servo qui semble malade tout seul ils fait n'importe quoi et répond qu'à moitié. Dans le meilleur des cas tout fonctionnent.

Mon alimentation est sensée fournir 700mA, un moteur pas à pas consomme 25mA ...Attendez !!!

un Servo 9G c'est :

Running current with 5V supply (no mechanical load)   220 ±50mA
Stall current with 5V supply (horn locked)   650 ±80mA

Autrement dit il consomme 3 fois plus au repos et j'en est deux...donc J'ai déjà un problème d'alimentation, Je suppose aussi que malgré l'accélération progressive des moteurs pas à pas, il y avais une pointe d'intensité aux démarrages. Je dépasse largement les 1.5 A.

Sacre bleu, en plus j'avais déjà une piste de réflexion à suivre au début du poste.
Je vais acheter une alimentation 110W  5.5vcc,  j'ai de quoi m'amuser avec 20 Ampères (P=U.I), Si je peux me permettre, pour 30 euros c'est raisonnable ?

Go Up