Guide linéaire motorisé

Bonjour , il n'y a aucune différence à utilisé runToPosition ou runToNewPosition(5000) , mis a part que avec que avec run to position il faut utiliser en plus moveTo ( 5000 ) pour avoir le nombre de pas que l'on cherche .

 

Ci dessous l'explication de AccelStepper 

runToNewPosition

Déplace le moteur (avec accélération / décélération) vers la nouvelle position cible et bloque jusqu'à ce qu'il soit en position. Ne l'utilisez pas dans les boucles d'événements, car il se bloque.

runToPosition

Déplace le moteur (avec accélération / décélération) vers la  position cible et bloque jusqu'à ce qu'il soit en position. Ne l'utilisez pas dans les boucles d'événements, car il se bloque.

 

D'aprés mes essais c'est vrai .

N'est ce pas bizarre de créer deux fonctions qui font la même chose ?

 

En fait c'est pour des questions d'usage, Je suppose qu'à l'origine il y avait le fonction " moveTo " et la fonction " runToPosition " . 
Puis ils ont du se dire que ça serait pratique de faire une fonction qui encapsule les deux. 

Il est possible que la fonction ressemble simplement à un truc comme ça :
 

runToNewPosition ( uint32_t position ) {

 static uint32_t currentTargetPosition = 0; 
 if( position != currentTargetPosition) {
  moveTo(position); 
  currentTargetPosition = position;

 }
 runToPosition();

}

Faire deux fonctions avec un nom différent qui seraient identiques serait en effet étrange et pourrait prêter à confusion. Mais même ça, ça existe (typiquement quand tu as une grosse librairie qui décide de changer de nom pour certaines fonctions : pendant quelques versions, ils gardent la fonction avec l'ancien nom en plus du nouveau nom, de manière à ce que les vieux programmes continuent à fonctionner (souvent ils ajoutent un avertissement que l'ancienne fonction n'existera plus dans les nouvelles fonctions)).

Une seconde possibilité, est que deux fonctions donnent le même résultat, mais en y aboutissant de manière différente, avec une méthode plus efficace que l'autre selon les cas (par exemple, il existe des dizaines d'algorithmes différents de tri, avec chacun leurs avantages et inconvéniants : l'un sera très rapide en moyenne mais lent dans quelques cas particuliers, un autre sera un peu plus lent en moyenne, mais plus rapide si on compare les pires des cas, un troisième utilisera moins de mémoire, un quatrième sera très efficace si les données sont déjà presque triées, un cinquième sera efficace si on connait à l'avance les valeurs possibles et qu'il y en a peu, ...)

Le dernier cas que je vois, qui est le tien, c'est que plusieurs fonctions différentes permettent d'aboutir à un même résultat, mais qu'il est possible d'utiliser l'une (ou les deux) fonctions également d'une manière différente.

runToNewPosition est en soit "inutile", vu qu'on peut la remplacer par moveTo suivit de runToPosition. Sauf que c'est plus rapide/clair/concis d'utiliser une seule fonction plutôt que les deux succéssivement : on a donc créé une fonction en guise de "raccourci".

Avoir les fonctions moveTo et runToPosition séparés, peut être utile dans certains cas :

- on peut utiliser moveTo suivit de runSpeedToPosition au lieu de runToPosition

- on peut utiliser moveTo, puis faire autre chose, puis exécuter runToPosition plus tard (par exemple tu pourrais fixer la destination depuis une fonction, puis lancer le déplacement quand tu appuis sur un bouton)

- on peut utiliser moveTo suivit de run (dans une boucle). On peut aussi imaginer une combinaison : on utilise moveTo, puis run dans une boucle avec une certaine condition, puis on finit le déplacement avec runToPosition. Par exemple si ton servomoteur sert à faire tourner le treuil qui catapulte un planeur d'aéromodélisme : au début, dans ta boucle, tu vérifie qu'on n'appuie pas sur un bouton "stop", puis quand le planeur à commencer à découler, tu vas jusqu'au bout peu importe le bouton (si le planeur vient de décoller mais n'est pas encore assez haut, il est impossible de lui faire faire un demi-tour pour ré-atérir, du coup il est sur de s'écraser)

- tu peux utiliser moveTo, puis la fonction distanceToGo pour savoir la distance à parcourir, et seulement ensuite décider si tu veux bouger ou pas

- ...

Bref, il y a plein de cas où avoir les deux fonctions séparées peut être utile, même si dans ton cas (et dans celui d'un bon nombre de personnes), avoir une fonction qui fait les deux en même temps est plus pratique.

ça marche et en plus le code est pas mal , propre, avec des fonctions, sans variable globales autre que les const des pins =). 

Juste quelques remarques afin d'améliorer encore si tu le souhaites : 
Au delà de la précédente proposition qui est pour le moment reportée,

perso je ferais une fonction qui map la distance en mm en step plutôt que de taper la formule à chaque fois à chaque endroit où tu auras envie de l'utiliser. ( D'ailleur j'utiliserais cette formule avec 30.0 en paramètre au lieu de mettre la valeur magique -117162 )

Tu peux aussi retirer les " valeurs magiques " dans ton code et les mettre comme constante en dessous de tes const pour les pins utilisés  
En effet tu vas certainement avoir besoin de changer ces constantes à plusieurs endroits ... Et si tu as besoin de les modifier, le faire juste à un endroit en haut de ton code ça sera plus facile exemple const float distanceMin = 30.0 ;   et remplacer partout 30.0 par distanceMin =)

Pour des besoins de propreté du code tu peux éventuellement choisir d'inverser deux fils de tes moteurs pas à pas pour inverser le sens de rotation. ( En gros aller en vitesse négative pour s'initialiser et utiliser une consigne " positive " pour se positionner sur le rail au lieu de mettre un - dans ta formule =) )

tu as une jolie fonction attendrems mais tu utilise encore la fonction delay...

Je te recommande toujours de "clean au maximum ton code " qui marche avant de passer à la suite =) . 
Car plus ça va aller plus tu vas entasser du code et plus il sera dur de le nettoyer ... 

Bientôt on va pouvoir arriver à un point où je te proposerais de faire plusieurs fichiers Tu me diras quand tu trouveras que ce code est trop long pour tenir dans un seul fichier =)

Bonjour , avant d'amélioré le code j'ai une question sur le moteur de mon guide linéaire .

(Il m'en faut un , et peut être il y a beaucoup de délai  ) 

  Le guide est un peu différent que sur la présentation (photo jointe) . L'original était trop encombrant ." 3.20 mètres"  de long !!  

J'ai du le coupé en quatre , ce qui m’emmène à une question plutôt mécanique .

On m'avait prêté un moteur nema 17 avec un réducteur d'environ 27/1 . 

Très bien d’ailleurs . Je pourrai reprendre le même , mais vu le choix partout et la curiosité , c'est le couple qui me fait réfléchir .

La notice du moteur me dit :

• Ce moteur pas à pas Nema 17 avec un corps de 48mm et un courant nominal de 1.68A, a intégré un réducteur planétaire de 26.85: 1 Rapport d'engrenage. C'est une bonne solution pour les applications avec un espace limité mais nécessitant une faible vitesse et / ou un couple élevé.

  Spécification électrique
  • Numéro de pièce du fabricant: 17HS19-1684S-PG27
  • Type de moteur: bipolaire
  • Angle de pas: 0.067 deg
  • Couple de serrage sans boîte de vitesses: 52Ncm(73.6oz.in)
  • Courant/phase: 1.68A
  • Résistance/phase: 1.65ohms
  • Tension: 2.8V
  • Inductance: 2.8mH ± 20%(1KHz)
  Spécifications de la boîte de vitesses
  • Type de boîte à engrenages: Planetary
  • Rapport d'engrenage: 26.85: 1
  • Efficacité: 81%
  • Contrecoup No-load: <=1 deg
  • Couple maximal autorisé: 3Nm(425oz.in)
  • Moment admissible Couple: 5Nm(708oz.in)
  • Charge axiale maximale de l'arbre: 50N
  • Charge radiale maximale de l'arbre: 100N
•  
•  
  • La question est simple : il est de combien le couple en sortie ? Il y a un rapport entre le couple moteur et la boite de vitesse ? Je pourrai dire que le couple en sortie est 27 fois plus important parce que la boite de vitesse 27 fois plus lente ?

à première vue, je dirais que tu as raison.

donc 52Ncm, soit 0.52Nm * 26.85 *0.81 = 11.3Nm

par contre si le couple maximal autorisé de 3Nm est en sortie, ça voudrait dire que le moteur serait capable de casser le réducteur

Et le moment maxi de 5Nm c'est dans le sens de rotation ou pas ? t'as pas un petit graphique avec la doc ?

(et t'aurais pas la doc quelque part sur le net ?)

 17HS19-1684S-PG27_Torque_Curve.pdf   166,24 Ko   152 téléchargement(s)

Bonjour Forthman ,

La doc m'aide pas vraiment sur le fonctionnement du couple moteur avec un réducteur . .

Je sais pas ou est le rapport entre le moteur et le reducteur . 

Je doit comprendre qu' au moment ou le moteur donne 52Ncm en sortie moteur , le couple maxi serai de 3 Nm en sortie réducteur ?

Est-ce que tu aurais par hasard un lien vers la page où tu as toutes ces infos (en particulier, si le site permet d'afficher la description directement en anglais, ça m'aiderait bien, car là ça sent le google traduction).

Pour le couple, en théorie, pour un réducteur idéal, si la vitesse est réduite d'un facteur 27, le couple est augmenté d'un facteur 27. Pour de vrai, il y a des pertes dans le réducteur (le tient à un rendement de 81%), donc la vitesse sera divisée par 27 mais le couple sera seulement augmenté de 0.81*27=22.

Pour les 3Nm évoqués, il est bien possible que le réducteur ne soit pas assez solide pour supporter plus (en tout cas pas sans usure accélérée).

ça y ressemble en effet, donc à toi de faire en sorte de ne pas dépasser ce 3N.m avec un limiteur de couple par exemple

Bon , je pense qu'avec vos explications, c'est clair pour le moment . Je vais rester avec ces quelques notions et choisir le moteur dans de bien meilleure condition  . Merci à tous les deux .

Toutefois ,  Il me trotte bien l'idée de faire tourner mon guide linéaire plutôt que moi en faire le tour ou le tourner à la main pour lui enroulé ma pelote de fil .

C'est plutôt lourd , je vous reposerai la question voir si c'est réalisable . 

Je vais reprendre le code dans l’immédiat et continuer de le nettoyer .  

Bonjour, 

J'ai voulu nettoyer un peu le code selon les consignes du post 144 . J'aime bien l' idée  mais j'y suis pas arrivé .    .J'ai les boules !  Pour les moins ( devant les pas ) c'est compliqué . J'y reviendrai plus tard . Je suis tombé sur plus bizarre .

J'ai voulu rajouter une fonction qui me passerai la distance en cm directement en pas . Ma fonction s’appelle : float ConversionDistanceCmEnPas (float DistanceEnPas).

A force d’essais , parce que je voulais pas passer ma fonction par le loop , pas moyen de solutionner mon problème .

Donc j'ai gardé le même principe déjà appliqué à mon code , c'est à dire , passer par le loop pour modifier ma distance en pas pour la renvoyer dans ma fonction configuration plateau . 

Eh bien, ça marche pas . Mes boutons réglage dans ma fonction RéglageAffichageDistance ne marche plus . Il reste sur 30 quand j'appuis . J'aimerai bien savoir pourquoi . Je pensais comprendre , eh ben non  !! 

#include <AccelStepper.h>
AccelStepper stepper (1, 9, 8);
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

const int PinBoutonInit = A0; //Bouton qui déplacera le chariot vers la buté à 30 cm
const int PinContactBute = A1;// Contact qui stope le chariot à 30 cm
const int PinBoutonReglageDistanceCm = A2;//Bouton de reglage distance en Cm
const int PinBoutonReglageDistanceMm = A3;//Bouton de reglage distance en Mm
const int PinBoutonReglageDistancePlus5Mm = A4;//Bouton de reglage distance + 5 Mm
const int PinBoutonReglageDistanceMoins5Mm = A5;//Bouton de reglage distance - 5 Mm
const int PinBoutonConfigurationPlateau = 6;//Bouton configuration Plateau à la distance écrite sur écran LCD
const int LED = 10;
const float distanceMin = 30.0 ; // reglage mécanique minimum de mon guide
const float distanceMax = 290.0 ; // reglage mécanique maximum de mon guide


float  ReglageAffichageDistance   (float NouvelleDistance)  {

  while (digitalRead(PinBoutonReglageDistancePlus5Mm) == 0) {// Bouton + 5 mm
    NouvelleDistance = NouvelleDistance + 0.5 ;
    if (NouvelleDistance > distanceMax) {
      NouvelleDistance = distanceMin ;
    }
    attendreMs(300);
    Serial.println(NouvelleDistance);
    AfficherLaDistance(NouvelleDistance);
    AfficherLaDistancePouce(NouvelleDistance);
  }

  while (digitalRead(PinBoutonReglageDistanceMoins5Mm) == 0)  { // Bouton - 5 mm
    NouvelleDistance = NouvelleDistance - 0.5 ;
    if (NouvelleDistance < distanceMin ) {
      NouvelleDistance = distanceMax;
    }
    attendreMs(300);
    Serial.println(NouvelleDistance);
    AfficherLaDistance(NouvelleDistance);
    AfficherLaDistancePouce(NouvelleDistance);
  }


  while (digitalRead(PinBoutonReglageDistanceMm) == 0) { // Bouton réglage des millimetres
    NouvelleDistance = NouvelleDistance + 0.01 ;
    if (NouvelleDistance > distanceMax) {
      NouvelleDistance = distanceMin ;
    }
    attendreMs(100);
    Serial.println(NouvelleDistance);
    AfficherLaDistance(NouvelleDistance);
    AfficherLaDistancePouce(NouvelleDistance);
  }

  while (digitalRead(PinBoutonReglageDistanceCm ) == 0) { // Bouton réglage des cm

    NouvelleDistance = NouvelleDistance + 1 ;   // Le compteur s'incrémente de 1 cm
    if (NouvelleDistance > distanceMax) {
      NouvelleDistance = distanceMin ;
    }
    attendreMs(200);  // on attend 500 ms sans utiliser la fonction delay()
    Serial.println("AB"); 
    Serial.println(NouvelleDistance);
    AfficherLaDistance(NouvelleDistance);
    AfficherLaDistancePouce(NouvelleDistance);
  }
  return NouvelleDistance;       // quand on a fini d'incrémenter on retourne la valeur au reste du programme
}


float  ConversionDistanceCmEnPas  (float DistanceEnPas) {{
  DistanceEnPas = DistanceEnPas * 3905.4  ;// 1tour = 11cm = 42960 pas soit 390.54 pas pour 1 mm
   Serial.println("C"); 
   Serial.println(DistanceEnPas);

}
return DistanceEnPas ;       // aprés la conversion, on retourne la valeur au reste du programme
}



void  ConfigurationPlateau (float Distance) {

  if (digitalRead(PinBoutonConfigurationPlateau) == 0)  {
    // stepper.setPinsInverted (true, false, false); // inverse le sens de rotation
    stepper. moveTo ( - Distance) ;
     Serial.println("B"); 
     Serial.println(Distance); 
    stepper. runToPosition () ;
    attendreMs(100); 
   

  }
  else {
    stepper.stop();
  }
}


void attendreMs (unsigned int attente) {
  unsigned long InstantouJappuis = millis();           // Variable qui enregistre le déroulement du temps qui passe depuis l'appuis
  while (millis() - InstantouJappuis <  attente ) { // décompte de 500ms en cours
  }
}



void  AfficherLaDistance  (float Distance) {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print (  " BUTEE " );
  lcd.setCursor(7, 0);
  lcd.print (  Distance  );
  lcd.setCursor(13, 0);
  lcd.print (  " cm "   );
}

void  AfficherLaDistancePouce  (float Distance) {

  lcd.setCursor(1, 1);
  lcd.print (  Distance / 2.54  );
  lcd.setCursor(11, 1);
  lcd.print (  " inch "   );
}



void  AfficherInitTermine () {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print (" Initialisation  "  );
  lcd.setCursor(0, 1 );
  lcd.print (" terminée "  );
  Serial.println ("Initialisation terminée " );
}

void  AfficherInitEnCours () {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print (" Initialisation  "  );
  lcd.setCursor(0, 1 );
  lcd.print (" en cours "  );
  Serial.println (" Initialisation en cours "  );

}
float initMoteur (float InitDistance ) {


  if (digitalRead(PinBoutonInit) == 0) {
    AfficherInitEnCours ();
    stepper.setSpeed(3900);

    while (digitalRead(PinContactBute) == 1) {
      stepper.runSpeed();
      digitalWrite(10, LOW); // initialisation non réalisé
      // on attends la buté
    }
    stepper.stop(); // On remet à 0 les consignes de vitesse ...
    digitalWrite(10, HIGH);  // initialisation  réalisé

    InitDistance  = distanceMin ;
    stepper. setCurrentPosition ( -117162 ) ;// Permet de mettre le moteur à sa position cible de 30 cm à la butée
    Serial.println("A"); 
    Serial.println (InitDistance);

    AfficherInitTermine ();
    attendreMs(1000); 
    AfficherLaDistance(InitDistance) ;
  }
  return InitDistance;   // quand on a fini d'initialisé on retourne la valeur au reste du programme
}

void setup() {

  Serial.begin(9600);
  pinMode(A0, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A1, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A2, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A3, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A4, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A5, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode( 6, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(10, OUTPUT);
  stepper.setMaxSpeed(4000);
  stepper. setAcceleration ( 500 ) ;
  lcd.begin(16, 2);
  lcd.print("START PRESS INIT");
}

void loop() {

  static float maDistance = 29;// Variable qui va stocker la distance de consigne
  maDistance = initMoteur (maDistance);  // Permet d'initialisé ma distance sur 30 cm
  maDistance = ReglageAffichageDistance (maDistance); // réglage de la distance de 30 à 290 cm
  maDistance = ConversionDistanceCmEnPas (maDistance) ;// Passage de la distance en Cm en pas 
  ConfigurationPlateau (maDistance) ;
}

Si on regarde juste le loop : 


 

  static float maDistance = 29;// Variable qui va stocker la distance de consigne
  maDistance = initMoteur (maDistance);  // Permet d'initialisé ma distance sur 30 cm
  maDistance = ReglageAffichageDistance (maDistance); // réglage de la distance de 30 à 290 cm
  maDistance = ConversionDistanceCmEnPas (maDistance) ;// Passage de la distance en Cm en pas 
  ConfigurationPlateau (maDistance) ;

je vois un problème.. 

Tu écrases ta valeur de distance ( qui est en cm comprise entre 30 et 290 ) par une valeur en pas qui sort du cadre des 30 290 ... 

cette fonction de conversion ne doit utiliser que dans tes sous fonctions à l'endroit où tu en as besoin =) 

Je te propose de revenir un tout petit peu en arrière, avec un code qui fonctionne tout en gardant les débuts d'évolutions que tu as fais et qui vont bien =) Et ensuite on avance à partir de ce qui marche

Si on regarde juste le loop : 


 

  static float maDistance = 29;// Variable qui va stocker la distance de consigne
  maDistance = initMoteur (maDistance);  // Permet d'initialisé ma distance sur 30 cm
  maDistance = ReglageAffichageDistance (maDistance); // réglage de la distance de 30 à 290 cm
  maDistance = ConversionDistanceCmEnPas (maDistance) ;// Passage de la distance en Cm en pas 
  ConfigurationPlateau (maDistance) ;

je vois un problème.. 

Tu écrases ta valeur de distance ( qui est en cm comprise entre 30 et 290 ) par une valeur en pas qui sort du cadre des 30 290 ... 

cette fonction de conversion ne doit utiliser que dans tes sous fonctions à l'endroit où tu en as besoin =) 

Je te propose de revenir un tout petit peu en arrière, avec un code qui fonctionne tout en gardant les débuts d'évolutions que tu as fais et qui vont bien =) Et ensuite on avance à partir de ce qui marche

J'ai remis à jour le code qui fonctionne bien avec les 2 améliorations ( suppressions des délais et et des distance min et max ) .

J'aimerai bien rajouter cette fonction : 

float ConversionDistanceCmEnPas (float DistanceEnPas) {

 DistanceEnPas = DistanceEnPas * 3905.4 ; // 1tour = 11cm = 42960 pas soit 390.54 pas pour 1 mm}

pour ne plus faire la conversion des Cm en pas dans ma fonction void ConfigurationPlateau (float Distance) .

Un ptit peu comme la fonction attendre . Mais je sais pas comment faire .

#include <AccelStepper.h>
AccelStepper stepper (1, 9, 8);
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

const int PinBoutonInit = A0; //Bouton qui déplacera le chariot vers la buté à 30 cm
const int PinContactBute = A1;// Contact qui stope le chariot à 30 cm
const int PinBoutonReglageDistanceCm = A2;//Bouton de reglage distance en Cm
const int PinBoutonReglageDistanceMm = A3;//Bouton de reglage distance en Mm
const int PinBoutonReglageDistancePlus5Mm = A4;//Bouton de reglage distance + 5 Mm
const int PinBoutonReglageDistanceMoins5Mm = A5;//Bouton de reglage distance - 5 Mm
const int PinBoutonConfigurationPlateau = 6;//Bouton configuration Plateau à la distance écrite sur écran LCD
const int LED = 10;
const float distanceMin = 30.0 ; // reglage mécanique minimum de mon guide
const float distanceMax = 290.0 ; // reglage mécanique maximum de mon guide


float  ReglageAffichageDistance   (float NouvelleDistance)  {

  while (digitalRead(PinBoutonReglageDistancePlus5Mm) == 0) {// Bouton + 5 mm
    NouvelleDistance = NouvelleDistance + 0.5 ;
    if (NouvelleDistance > distanceMax ) {
      NouvelleDistance = distanceMin ;
    }
    attendreMs(300);
    Serial.println(NouvelleDistance);
    AfficherLaDistance(NouvelleDistance);
    AfficherLaDistancePouce(NouvelleDistance);
  }

  while (digitalRead(PinBoutonReglageDistanceMoins5Mm) == 0)  { // Bouton - 5 mm
    NouvelleDistance = NouvelleDistance - 0.5 ;
    if (NouvelleDistance < distanceMin ) {
      NouvelleDistance = distanceMax ;
    }
    attendreMs(300);
    Serial.println(NouvelleDistance);
    AfficherLaDistance(NouvelleDistance);
    AfficherLaDistancePouce(NouvelleDistance);
  }


  while (digitalRead(PinBoutonReglageDistanceMm) == 0) { // Bouton réglage des millimetres
    NouvelleDistance = NouvelleDistance + 0.01 ;
    if (NouvelleDistance > distanceMax ) {
      NouvelleDistance = distanceMin ;
    }
    attendreMs(100);
    Serial.println(NouvelleDistance);
    AfficherLaDistance(NouvelleDistance);
    AfficherLaDistancePouce(NouvelleDistance);
  }

  while (digitalRead(PinBoutonReglageDistanceCm ) == 0) { // Bouton réglage des cm

    NouvelleDistance = NouvelleDistance + 1 ;   // Le compteur s'incrémente de 1 cm
    if (NouvelleDistance > distanceMax) {
      NouvelleDistance = distanceMin ;
    }
    attendreMs(200);                            // on attend 500 ms sans utiliser la fonction delay()
    Serial.println(NouvelleDistance);
    AfficherLaDistance(NouvelleDistance);
    AfficherLaDistancePouce(NouvelleDistance);
  }
  return NouvelleDistance;       // quand on a fini d'incrémenter on retourne la valeur au reste du programme
}



void  ConfigurationPlateau (float Distance) {

  if (digitalRead(PinBoutonConfigurationPlateau) == 0)  {

    stepper. moveTo (- Distance * 3905.4 ) ;// 1tour = 11cm = 42960 pas soit 390.54 pas pour 1 mm .
    stepper. runToPosition () ;
    Serial.println(Distance * 3905.4); 
     attendreMs(100);

  }
  else {
     stepper.stop();
  }
}


void attendreMs (unsigned int attente) {
  unsigned long InstantouJappuis = millis();           // Variable qui enregistre le déroulement du temps qui passe depuis l'appuis
  while (millis() - InstantouJappuis <  attente ) { // décompte de 500ms en cours
  }
}



void  AfficherLaDistance  (float Distance) {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print (  " BUTEE " );
  lcd.setCursor(7, 0);
  lcd.print (  Distance  );
  lcd.setCursor(13, 0);
  lcd.print (  " cm "   );
}

void  AfficherLaDistancePouce  (float Distance) {

  lcd.setCursor(1, 1);
  lcd.print (  Distance / 2.54  );
  lcd.setCursor(11, 1);
  lcd.print (  " inch "   );
}



void  AfficherInitTermine () {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print (" Initialisation  "  );
  lcd.setCursor(0, 1 );
  lcd.print (" terminée "  );
  Serial.println ("Initialisation terminée " );
}

void  AfficherInitEnCours () {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print (" Initialisation  "  );
  lcd.setCursor(0, 1 );
  lcd.print (" en cours "  );
  Serial.println (" Initialisation en cours "  );

}
float initMoteur (float InitDistance ) {


  if (digitalRead(PinBoutonInit) == 0) {
    AfficherInitEnCours ();
    stepper.setSpeed(3900);

    while (digitalRead(PinContactBute) == 1) {
      stepper.runSpeed();
       digitalWrite(10, LOW); // initialisation non réalisé
      // on attends la buté
    }
    stepper.stop(); // On remet à 0 les consignes de vitesse ...
   digitalWrite(10, HIGH);  // initialisation  réalisé

    InitDistance  = distanceMin ;
    stepper. setCurrentPosition ( -117162 ) ;// Permet de mettre le moteur à sa position cible de 30 cm à la butée

    Serial.println (InitDistance);

    AfficherInitTermine ();
     attendreMs(1000);
    AfficherLaDistance(InitDistance) ;
  }
  return InitDistance;   // quand on a fini d'initialisé on retourne la valeur au reste du programme
}

void setup() {

  Serial.begin(9600);
  pinMode(A0, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A1, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A2, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A3, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A4, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A5, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode( 6, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(10, OUTPUT);
  stepper.setMaxSpeed(4000);
  stepper. setAcceleration ( 500 ) ;
  lcd.begin(16, 2);
  lcd.print("START PRESS INIT");
}

void loop() {

  static float maDistance = 29; // Variable qui va stocker la distance de consigne
  maDistance = initMoteur (maDistance);  // Permet d'initialisé ma distance sur 30 cm
  maDistance = ReglageAffichageDistance (maDistance); // réglage de la distance de 30 à 290 cm
  Serial.println (maDistance );
  ConfigurationPlateau (maDistance) ;

}

#include <AccelStepper.h>
AccelStepper stepper (1, 9, 8);
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

const int PinBoutonInit = A0; //Bouton qui déplacera le chariot vers la buté à 30 cm
const int PinContactBute = A1;// Contact qui stope le chariot à 30 cm
const int PinBoutonReglageDistanceCm = A2;//Bouton de reglage distance en Cm
const int PinBoutonReglageDistanceMm = A3;//Bouton de reglage distance en Mm
const int PinBoutonReglageDistancePlus5Mm = A4;//Bouton de reglage distance + 5 Mm
const int PinBoutonReglageDistanceMoins5Mm = A5;//Bouton de reglage distance - 5 Mm
const int PinBoutonConfigurationPlateau = 6;//Bouton configuration Plateau à la distance écrite sur écran LCD
const int LED = 10;
const float distanceMin = 30.0 ; // reglage mécanique minimum de mon guide
const float distanceMax = 290.0 ; // reglage mécanique maximum de mon guide


float  ReglageAffichageDistance   (float NouvelleDistance)  {

  while (digitalRead(PinBoutonReglageDistancePlus5Mm) == 0) {// Bouton + 5 mm
    NouvelleDistance = NouvelleDistance + 0.5 ;
    if (NouvelleDistance > distanceMax ) {
      NouvelleDistance = distanceMin ;
    }
    attendreMs(300);
    Serial.println(NouvelleDistance);
    AfficherLaDistance(NouvelleDistance);
    AfficherLaDistancePouce(NouvelleDistance);
  }

  while (digitalRead(PinBoutonReglageDistanceMoins5Mm) == 0)  { // Bouton - 5 mm
    NouvelleDistance = NouvelleDistance - 0.5 ;
    if (NouvelleDistance < distanceMin ) {
      NouvelleDistance = distanceMax ;
    }
    attendreMs(300);
    Serial.println(NouvelleDistance);
    AfficherLaDistance(NouvelleDistance);
    AfficherLaDistancePouce(NouvelleDistance);
  }


  while (digitalRead(PinBoutonReglageDistanceMm) == 0) { // Bouton réglage des millimetres
    NouvelleDistance = NouvelleDistance + 0.01 ;
    if (NouvelleDistance > distanceMax ) {
      NouvelleDistance = distanceMin ;
    }
    attendreMs(100);
    Serial.println(NouvelleDistance);
    AfficherLaDistance(NouvelleDistance);
    AfficherLaDistancePouce(NouvelleDistance);
  }

  while (digitalRead(PinBoutonReglageDistanceCm ) == 0) { // Bouton réglage des cm

    NouvelleDistance = NouvelleDistance + 1 ;   // Le compteur s'incrémente de 1 cm
    if (NouvelleDistance > distanceMax) {
      NouvelleDistance = distanceMin ;
    }
    attendreMs(200);                            // on attend 500 ms sans utiliser la fonction delay()
    Serial.println(NouvelleDistance);
    AfficherLaDistance(NouvelleDistance);
    AfficherLaDistancePouce(NouvelleDistance);
  }
  return NouvelleDistance;       // quand on a fini d'incrémenter on retourne la valeur au reste du programme
}

int32_t ConversionDistanceCmEnPas (float DistanceEnCm) {   // On met un type d'entier car le nombre de pas c'est un entier
 int32_t DistanceEnPas = - DistanceEnCm * 3905.4 ;// 1tour = 11cm = 42960 pas soit 390.54 pas pour 1 mm avec le signe - car inversion
 Serial.println("C");   // print utile que pour du débug à commenter ou supprimer plus tard ... 
 Serial.println(DistanceEnPas); // idem
 return DistanceEnPas ; // aprés la conversion, on retourne la valeur au reste du programme
}

void  ConfigurationPlateau (float Distance) {

  if (digitalRead(PinBoutonConfigurationPlateau) == 0)  {

    stepper.moveTo(ConversionDistanceCmEnPas(Distance));// move to prend en paramètre une distance en pas.
    stepper.runToPosition () ;
    attendreMs(100);

  }
  else {
     stepper.stop();
  }
}


void attendreMs (unsigned int attente) {
  unsigned long InstantouJappuis = millis();           // Variable qui enregistre le déroulement du temps qui passe depuis l'appuis
  while (millis() - InstantouJappuis <  attente ) { // décompte de 500ms en cours
  }
}



void  AfficherLaDistance  (float Distance) {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print (  " BUTEE " );
  lcd.setCursor(7, 0);
  lcd.print (  Distance  );
  lcd.setCursor(13, 0);
  lcd.print (  " cm "   );
}

void  AfficherLaDistancePouce  (float Distance) {

  lcd.setCursor(1, 1);
  lcd.print (  Distance / 2.54  );
  lcd.setCursor(11, 1);
  lcd.print (  " inch "   );
}



void  AfficherInitTermine () {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print (" Initialisation  "  );
  lcd.setCursor(0, 1 );
  lcd.print (" terminée "  );
  Serial.println ("Initialisation terminée " );
}

void  AfficherInitEnCours () {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print (" Initialisation  "  );
  lcd.setCursor(0, 1 );
  lcd.print (" en cours "  );
  Serial.println (" Initialisation en cours "  );

}

float initMoteur (float InitDistance ) {


  if (digitalRead(PinBoutonInit) == 0) {
    AfficherInitEnCours ();
    stepper.setSpeed(3900);

    while (digitalRead(PinContactBute) == 1) {
      stepper.runSpeed();
       digitalWrite(10, LOW); // initialisation non réalisé
      // on attends la buté
    }
    stepper.stop(); // On remet à 0 les consignes de vitesse ...
   digitalWrite(10, HIGH);  // initialisation  réalisé

    InitDistance  = distanceMin ;
    stepper. setCurrentPosition ( -117162 ) ;// Permet de mettre le moteur à sa position cible de 30 cm à la butée

    Serial.println (InitDistance);

    AfficherInitTermine ();
     attendreMs(1000);
    AfficherLaDistance(InitDistance) ;
  }
  return InitDistance;   // quand on a fini d'initialisé on retourne la valeur au reste du programme
}

void setup() {

  Serial.begin(9600);
  pinMode(A0, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A1, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A2, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A3, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A4, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A5, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode( 6, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(10, OUTPUT);
  stepper.setMaxSpeed(4000);
  stepper. setAcceleration ( 500 ) ;
  lcd.begin(16, 2);
  lcd.print("START PRESS INIT");
}

void loop() {

  static float maDistance = 29; // Variable qui va stocker la distance de consigne
  maDistance = initMoteur (maDistance);  // Permet d'initialisé ma distance sur 30 cm
  maDistance = ReglageAffichageDistance (maDistance); // réglage de la distance de 30 à 290 cm
  Serial.println (maDistance );
  ConfigurationPlateau (maDistance) ;

}

Bon j'ai corrigé un petit peu ta fonction 

+> Changement du type de fonction ( car un nombre de pas c'est censé être un entier ) 
+> Ajout du signe " - " à l'intérieur de ta fonction, car visiblement tu le mettais partout, 

et j'ai utilisé ta fonction nouvelle fonction modifié dans la fonction " configuration du plateau " . 

Regarde ce qui a été fait, confirme que ça marche bien pose des questions si besoin =) 

Ensuite tu peux modifier d'autres endroits ou tu mets des valeurs magique en pas en les remplaçant par 

 " ConversionDistanceCmEnPas ( MaConstanteEquivalenteEnCm )  "  =) 

 

Bonjour, 

Ça y est ! J'ai  simplifier le code au niveau des pas dans la fonction float initMoteur (float InitDistance ) { .

Et j'ai surtout retiré le moins dans la fonction qui converti les Cm en pas .  J'ai essayé en vain 

avec stepper.setPinsInverted(true, false, false); , sans résultat et sans comprendre ; Mais alors pas du tout  .

Puis en fait il suffisait de mettre une vitesse négative !

Bon je suis ravi que sa marche et que c'est plus clair .

Je ne me souvient plus sur ce site ou l'on parle de (int32_t) . Ou je la retrouve l''explication ?

//Code avec la fonction des pas complete 



#include <AccelStepper.h>
AccelStepper stepper (1, 9, 8);
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

const int PinBoutonInit = A0; //Bouton qui déplacera le chariot vers la buté à 30 cm
const int PinContactBute = A1;// Contact qui stope le chariot à 30 cm
const int PinBoutonReglageDistanceCm = A2;//Bouton de reglage distance en Cm
const int PinBoutonReglageDistanceMm = A3;//Bouton de reglage distance en Mm
const int PinBoutonReglageDistancePlus5Mm = A4;//Bouton de reglage distance + 5 Mm
const int PinBoutonReglageDistanceMoins5Mm = A5;//Bouton de reglage distance - 5 Mm
const int PinBoutonConfigurationPlateau = 6;//Bouton configuration Plateau à la distance écrite sur écran LCD
const int LED = 10;
const float distanceMin = 30.0 ; // reglage mécanique minimum de mon guide
const float distanceMax = 290.0 ; // reglage mécanique maximum de mon guide
//stepper.setPinsInverted(true, false, false);

float  ReglageAffichageDistance   (float NouvelleDistance)  {

  while (digitalRead(PinBoutonReglageDistancePlus5Mm) == 0) {// Bouton + 5 mm
    NouvelleDistance = NouvelleDistance + 0.5 ;
    if (NouvelleDistance > distanceMax ) {
      NouvelleDistance = distanceMin ;
    }
    attendreMs(300);
    Serial.println(NouvelleDistance);
    AfficherLaDistance(NouvelleDistance);
    AfficherLaDistancePouce(NouvelleDistance);
  }

  while (digitalRead(PinBoutonReglageDistanceMoins5Mm) == 0)  { // Bouton - 5 mm
    NouvelleDistance = NouvelleDistance - 0.5 ;
    if (NouvelleDistance < distanceMin ) {
      NouvelleDistance = distanceMax ;
    }
    attendreMs(300);
    Serial.println(NouvelleDistance);
    AfficherLaDistance(NouvelleDistance);
    AfficherLaDistancePouce(NouvelleDistance);
  }


  while (digitalRead(PinBoutonReglageDistanceMm) == 0) { // Bouton réglage des millimetres
    NouvelleDistance = NouvelleDistance + 0.01 ;
    if (NouvelleDistance > distanceMax ) {
      NouvelleDistance = distanceMin ;
    }
    attendreMs(100);
    Serial.println(NouvelleDistance);
    AfficherLaDistance(NouvelleDistance);
    AfficherLaDistancePouce(NouvelleDistance);
  }

  while (digitalRead(PinBoutonReglageDistanceCm ) == 0) { // Bouton réglage des cm

    NouvelleDistance = NouvelleDistance + 1 ;   // Le compteur s'incrémente de 1 cm
    if (NouvelleDistance > distanceMax) {
      NouvelleDistance = distanceMin ;
    }
    attendreMs(200);                            // on attend 500 ms sans utiliser la fonction delay()
    Serial.println(NouvelleDistance);
    AfficherLaDistance(NouvelleDistance);
    AfficherLaDistancePouce(NouvelleDistance);
  }
  return NouvelleDistance;       // quand on a fini d'incrémenter on retourne la valeur au reste du programme
}

int32_t ConversionDistanceCmEnPas (float DistanceEnCm) {   // On met un type d'entier car le nombre de pas c'est un entier
 int32_t DistanceEnPas = DistanceEnCm * 3905.4 ;// 1tour = 11cm = 42960 pas soit 390.54 pas pour 1 mm avec le signe - car inversion
 
 Serial.println("C");   // print utile que pour du débug à commenter ou supprimer plus tard ... 
 Serial.println(DistanceEnPas); // idem
 return DistanceEnPas ; // aprés la conversion, on retourne la valeur au reste du programme
}

void  ConfigurationPlateau (float Distance) {

  if (digitalRead(PinBoutonConfigurationPlateau) == 0)  {

    stepper.moveTo(ConversionDistanceCmEnPas(Distance));// move to prend en paramètre une distance en pas.
    stepper.runToPosition () ;
    attendreMs(100);

  }
  else {
     stepper.stop();
  }
}


void attendreMs (unsigned int attente) {
  unsigned long InstantouJappuis = millis();           // Variable qui enregistre le déroulement du temps qui passe depuis l'appuis
  while (millis() - InstantouJappuis <  attente ) { // décompte de 500ms en cours
  }
}



void  AfficherLaDistance  (float Distance) {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print (  " BUTEE " );
  lcd.setCursor(7, 0);
  lcd.print (  Distance  );
  lcd.setCursor(13, 0);
  lcd.print (  " cm "   );
}

void  AfficherLaDistancePouce  (float Distance) {

  lcd.setCursor(1, 1);
  lcd.print (  Distance / 2.54  );
  lcd.setCursor(11, 1);
  lcd.print (  " inch "   );
}



void  AfficherInitTermine () {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print (" Initialisation  "  );
  lcd.setCursor(0, 1 );
  lcd.print (" terminée "  );
  Serial.println ("Initialisation terminée " );
}

void  AfficherInitEnCours () {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print (" Initialisation  "  );
  lcd.setCursor(0, 1 );
  lcd.print (" en cours "  );
  Serial.println (" Initialisation en cours "  );

}

float initMoteur (float InitDistance ) {


  if (digitalRead(PinBoutonInit) == 0) {
    AfficherInitEnCours ();
    stepper.setSpeed(-3900);
    
    while (digitalRead(PinContactBute) == 1) {
      
      stepper.runSpeed();
       digitalWrite(10, LOW); // initialisation non réalisé
      // on attends la buté
    }
    stepper.stop(); // On remet à 0 les consignes de vitesse ...
   digitalWrite(10, HIGH);  // initialisation  réalisé

    InitDistance  = distanceMin ;
    stepper. setCurrentPosition (ConversionDistanceCmEnPas(distanceMin)) ;// Permet de mettre le moteur à sa position cible de 30 cm à la butée

  

    Serial.println (InitDistance);

    AfficherInitTermine ();
     attendreMs(1000);
    AfficherLaDistance(InitDistance) ;
  }
  return InitDistance;   // quand on a fini d'initialisé on retourne la valeur au reste du programme
}

void setup() {

  Serial.begin(9600);
  pinMode(A0, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A1, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A2, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A3, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A4, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A5, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode( 6, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(10, OUTPUT);
  stepper.setMaxSpeed(4000);
  stepper. setAcceleration ( 500 ) ;
  lcd.begin(16, 2);
  lcd.print("START PRESS INIT");
}

void loop() {

  static float maDistance = 29; // Variable qui va stocker la distance de consigne
  maDistance = initMoteur (maDistance);  // Permet d'initialisé ma distance sur 30 cm
  maDistance = ReglageAffichageDistance (maDistance); // réglage de la distance de 30 à 290 cm
  Serial.println (maDistance );
  ConfigurationPlateau (maDistance) ;

}

Alors , 

=> Int32 etc ... => Tuto pour adapter la taille des variables en C : https://www.robot-ma...variables-en-c/

Par contre je suis curieux concernant ta remarque sur 

 

Et j'ai surtout retiré le moins dans la fonction qui converti les Cm en pas .  J'ai essayé en vain 

avec stepper.setPinsInverted(true, false, false); , sans résultat et sans comprendre ; Mais alors pas du tout  .

 

Je te propose de faire quelque tests pour explorer ce qui se passe ... et bien comprendre avant de passer à la suite ça te va ? 

Car il y a plusieurs façon pour corriger ce problème et il est intéressant de toutes les connaitre ( et de savoir celles qui éventuellement ne marche pas comme on le voudrait ! ) 

Bonjour à tous ,

Je vais essayé de reformuler ma question de mon post ci dessus  .

Je voudrais faire tourner mon futur guide linéaire ( photo ci dessus )  . Il sera monté sur un axe central et entrainé par courroie .

Je cherche à calculer le couple moteur ( type NEMA  pas à pas ) qui me permettrai de faire tourner l'ensemble .

Comment je dois m'y prendre ? Existe t'il une formule qui me guiderai dans mon choix de moteur  ?

a bientôt

Salut,

L'ensemble carré va tourner sur lui-même ? c'est juste un mobile ?

Si tu n'as que les frottements de l'air, que l'ensemble est monté sur roulements à billes, que la vitesse n'est pas très élevée, et que les rampes d'accélération/freinage sont longues,

un moteur minuscule pourrait faire l'affaire. Mais si tu dois entraîner autre chose, il faut le calculer.