AccelStepper

[likiki]

Quelqu'un aurait-il des informations sur la librairie AccelStepper ?

Tout ce que je trouve est en anglais et moi, je ne baragouine pas deux mots a la suite en anglais.

[herwat]

Oui ! C'est comme moi, si j'ai bien compris, qui parle anglais comme une vache espagnole !
alors voici ceci en anglais
et Cela traduit en français . ça devrait t'aider . Mais attention, tout est traduit, même les fonctions ! ça peut créer des surprises . . . . et même une certaine incompréhension .

Bon courage .

Voilà une partie de mon programme de transbordeur où j'utilise quelques-unes des fonctions :

Code : Tout sélectionner

//                     * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//                     * * * * *    Commande NEMA 17 avec AccelStepper     * * * * *
//                     * * * * *     Moteur piloté par driver DRV8825      * * * * *
//                     * * * * *              et micro steps               * * * * *
//                     * * * * *        Pour transbodeur vertical          * * * * *
//                     * * * * *                                           * * * * *
//                     * * * * *           Programme opérationnel          * * * * *
//                     * * * * *   Avec commutateur mOm de sélection et    * * * * *
//                     * * * * *       affichage LCD  et suivi Leds        * * * * *
//                     * * * * *                sur Méga                   * * * * *
//                     * * * * *       Commande de deux moteurs PaP        * * * * *
//                     * * * * * avec deux drivers branchés en parallèle   * * * * *
//                     * * * * *    sur les même sorties de l'arduino      * * * * *
//                     * * * * *                                           * * * * *
//                     * * * * *   avec commande servo de verrouillage     * * * * *
//                     * * * * *          et témoin de position            * * * * *
//                     * * * * *                                           * * * * *
//                     * * * * *    Mise en mémoire des niveaux de voie    * * * * *
//                     * * * * *    et de la dernière sélection de voie    * * * * *
//                     * * * * *                                           * * * * *      
//                     * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

#include <EEPROM.h>
#include <AccelStepper.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>  

LiquidCrystal_I2C lcd(0x27,16,2);    // Description de l'écran
    
  const byte PinBPplus  = 16;        // Pin d'entrée des boutons de commande
  const byte PinBPmoins = 15;
  const byte PinBPConf  = 14;
  const byte PinBPajustmem = 2;

  int Voie  = 0;
  int VoieInt = 0;
  int VoieSel = 0;
  int VoieAnc = 0;
  boolean act  = false;
  boolean Confirm = false ;
  boolean mem = false ;
  
      /* Affectation des sorties pour les LEDs témoins  */
  int pinLed [11] = {40,42,44,46,48,39,41,43,45,47,49};
  const byte pinAlimLed = 38 ;

  unsigned long TempsZero = 0 ;
  boolean Veille = true ;

// Définit comment sera piloté le moteur et les broches qu'il utilise .
   AccelStepper Moteur1(1, 11, 10); // 1=Driver, Pin 11 = pas, Pin 10 = direction
    
//  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *   
// 
//                   Définition des hauteur de voies en pas moteur
//                    microstep = 1/2  soit 400 pas pour 1.25 mm
//                    Hauteur entre voie de 80 mm soit 25600 pas

 unsigned long NiveauVoie [11] = {0,25600,51200,76800,102400,128000,153600,179200,204800,230400,256000};
 unsigned long Niveaumod ;
//  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
     
    const byte pinZero = 5 ;         // pin d'entrée du détecteur de fin de course niveau zéro
    const byte pinZeroApp = 4 ;      // pin d'entrée du détecteur d'approche de fin de course
    const byte pinAlim = 23 ;        // pin de sortie commendant le relai d'alimentation 12v des moteurs
    const byte pinDCC = 3 ;          // pin de sortie commendant le relai d'alimentation DCC de la rampe
    const byte pinServo = 25 ;       // pin de commande du servo de verrouillage "Pont-voie"
    const byte pinVerrou = 27 ;      // pin témoin de verroillage - déverrouilage du servo
    const byte pinDriverHT = 13;     // vrai = driver désactivé
    const byte pinM0 = 8 ;           //  Gestion des micro Steps
    const byte pinM1 = 7 ;           //  Gestion des micro Steps
    const byte pinM2 = 6 ;           //  Gestion des micro Steps
    boolean Approch = false ;
    long Ralenti = 0 ;
    boolean ini = true ;        //  Initialisation pour définir le zéro de référence (et autre)
    boolean Mvt ;                //  vrai si le moteur tourne
    boolean Alim12v = false ;    //  Définit l'alimentation en 12v des moteurs PaP
    boolean AlimLED = false ;    //  Commande l'alimentation des Leds
    boolean Verrouille = false;  //  Témoin de verrouillage
    boolean Attente = false ;
    unsigned long Clignot = 0 ;
    byte y ;                      //  variables d'incrémentation
    
    
void setup()
   {  
      lcd.init();
      lcd.backlight();
      lcd.setCursor(0,0);
      
      for (y=0 ; y <= 10 ; y++){ pinMode(pinLed [y], OUTPUT); }
      for (y=0 ; y <= 10 ; y++){ digitalWrite(pinLed [y], LOW); }
      pinMode(pinAlimLed,OUTPUT);
      pinMode(PinBPplus,INPUT);
      pinMode(PinBPmoins,INPUT);
      pinMode(PinBPConf,INPUT);
      pinMode(PinBPajustmem,INPUT);
    
      pinMode (pinZero, INPUT) ;
      pinMode (pinZeroApp, INPUT) ;
      pinMode(pinDriverHT, OUTPUT);
      pinMode(pinM0, OUTPUT) ;
      pinMode(pinM1, OUTPUT) ;
      pinMode(pinM2, OUTPUT) ;
      pinMode(pinAlim, OUTPUT) ;
      pinMode(pinDCC, OUTPUT) ;
      pinMode(pinServo, OUTPUT) ;
      pinMode (pinVerrou, INPUT) ;
    
// * * * * Réglage microsteps  * * * *         M0     M1     M2   
                                      //       LOW    LOW    LOW      Full step 
      digitalWrite(pinM0,HIGH);       //       HIGH   LOW    LOW      1/2  pas
      digitalWrite(pinM1,LOW);        //       LOW    HIGH   LOW      1/4  pas
      digitalWrite(pinM2,LOW);        //       HIGH   HIGH   LOW      1/8  pas
                                      //       LOW    LOW    HIGH     1/16 pas
// * * * * * * * * * * * * * * * * * *         LOW    HIGH   HIGH     1/32 pas

      digitalWrite(pinDriverHT,HIGH);
      digitalWrite(pinDCC,HIGH);
      digitalWrite(pinServo,LOW);
      digitalWrite( pinAlim,LOW );
      delay (3000) ;                   // Attend que l'initialisation du Nano Servo soit faite
      
      premierefois () ;
      lectureEP () ;
      Initialisation() ;
    }  

void loop()
    {
     affichage(5) ;
     if (!Mvt){ SelecVoie() ; }
     if (Mvt){ Deplacement () ; }
    }

void Deplacement ()

      {
        affichage(2) ;
        digitalWrite(pinDCC,HIGH);
        Verrouillage( false ) ;
        Moteur1.moveTo(NiveauVoie [VoieSel]);
        digitalWrite(pinDriverHT,LOW);
        ini = true ; 
        while (ini) {
                   Moteur1.run();
                   if ( !Moteur1.run() ){ ini = false ; }
                   Alim_Led () ;
                   if(digitalRead(PinBPConf)){ ArretUrg (); }     // Arret d'urgence
                    }
 
        digitalWrite(pinDriverHT,HIGH);
        affichage(4) ;
        Verrouillage( true ) ;
        EEPROM.put(50, VoieSel);
        digitalWrite(pinDCC,LOW);
        Mvt = false ;  Alim_Led () ;
      }

void Initialisation()
    {
      Moteur1.setMaxSpeed(3600);
      Moteur1.setAcceleration(1600);

      affichage(9) ;
      Attente = true ;
      Confirm = false ;
      TempsZero = millis() ;
      while (Attente) {
                       if ( digitalRead(PinBPConf)){ Confirm = true ; }
                       if ( millis() - TempsZero > 4000 ){ Attente = false ; }
                      }
      if(Confirm) { Misaniveau() ; }
      else { Misazero() ; }
      
    }  

           
void Misazero()
     {
      affichage(1) ;
      Verrouillage( false ) ;
      VoieSel = 0 ;
      digitalWrite(pinDriverHT,LOW);
      Mvt = true ;
      digitalWrite(pinLed [VoieSel], HIGH);

      if ( digitalRead(pinZero) == 0 )
          {  Moteur1.moveTo(10000);
             while (ini) {
                          Moteur1.run();
                          if ( !Moteur1.run() ){ ini = false ; }
                          Alim_Led () ;
                          if(digitalRead(PinBPConf)){ ArretUrg (); }
                         }
             ini = true ; 
          }
          
      Moteur1.moveTo(-300000);
      while (ini) {
                   if (Approch == false && digitalRead(pinZeroApp) == 0)
                               {
                                digitalWrite(pinM0,LOW);
                                digitalWrite(pinM1,HIGH);
                                Ralenti = -Moteur1.currentPosition() ;
                                Approch = true ;
                                }
                                
                   if (Approch == true && -Moteur1.currentPosition() > Ralenti + 6000 )
                                { digitalWrite(pinM0,HIGH);
                                  digitalWrite(pinM1,HIGH); }
                                 
                   if ( digitalRead(pinZero) == 0)
                               {
                                Moteur1.setMaxSpeed(0);
                                Moteur1.setCurrentPosition(0);
                                Moteur1.setMaxSpeed(3600);
                                digitalWrite(pinM0,HIGH);
                                digitalWrite(pinM1,LOW);
                                ini = false ;
                                }
                   Moteur1.run();
                   if(digitalRead(PinBPConf)){ ArretUrg (); }
                   Alim_Led () ;
                  }
      ini = true ;
      Moteur1.moveTo(NiveauVoie [0]);
      while (ini) {
                   Moteur1.run();
                   if ( !Moteur1.run() ){ ini = false ; }
                   Alim_Led () ;
                  }         

      digitalWrite(pinDriverHT,HIGH);
      Verrouillage( true ) ;
      digitalWrite(pinDCC,LOW);
      Mvt = false ;  Alim_Led () ;
      
    }

void Misaniveau()
    {
      Moteur1.setCurrentPosition(NiveauVoie [VoieSel]);
      Verrouillage( true ) ;
      digitalWrite(pinLed [VoieSel], HIGH);
      digitalWrite(pinDCC,LOW);
      Mvt = false ;  Alim_Led () ;
    }



   

Si ça peut t'aider . . .

à cette ligne : AccelStepper Moteur1(1, 11, 10); // 1=Driver, Pin 11 = pas, Pin 10 = direction
Pour toi, je pense qu'il faut mettre 4 pour le premier paramètre .

Si tu veux, je peux t'envoyer par mail la totalité du programme .

[likiki]

Merci pour la traduction, une aubaine pour moi qui parle anglais comme un taureau basque.

Je vais lire cela a tête reposée ce soir.

[likiki]

Bien, voici mes premier pas avec cette librairie.

[herwat]

[likiki]

Le même programme, mais moteur monté sur le simulateur.


.

[bunny94]

Bien les 2 vidéos

[Papy2568]

Ça se concrétise

[herwat]

ça vient bon .

[likiki]

Doucement, il y a encore pas mal de boulot.

[likiki]

C'est bien de mettre des vidéos, mais il faut expliquer le pourquoi du comment.


Alors voici.

Code : Tout sélectionner

#include <AccelStepper.h>                    // Appel de la bibliotheque Accelstepper

#define FCR 5                                // Attachement de l'objet Fin de Course Ralantissement a la broche n° 5

AccelStepper Moteur1(1, 2, 3);               // 1=Driver, Pin 2 = step, Pin 3 = dir


boolean mouv = true ;                         // Variable mouvement
int Position0 = 0;                            // Variable de position niveau 0 de référence

void setup() {
 

Serial.begin(9600);                          // Initialisation du port série


Moteur1.setMaxSpeed(4000);                   // vitesse max moteur en micro pas 4000

Moteur1.setAcceleration(1200);               // Nombre micro pas d'accélération / décélération

Moteur1.setCurrentPosition (Position0);      // Position moteur a l'initialisation

Mise en place des entrés / sorties

Code : Tout sélectionner

pinMode(2, OUTPUT);

pinMode(3, OUTPUT);

pinMode(4, OUTPUT);

pinMode(5, INPUT);

}

En boucle principal :

Code : Tout sélectionner

void loop() {

                                          
descente();                             // Vers le module descente

delay (3000);

monte();                               // Vers le module monté

delay (3000);

Les modules montée et descente (seul le descente est détaillé, mais c'est kif kif sauf sur l'instruction "moteur1.move").

Code : Tout sélectionner

void descente()
{
Moteur1.move(50000);                        // Ont veut que le moteur bouge dans le sens horaire de 50000 MICRO pas

digitalWrite(4,LOW);                        // Alimente le moteur via driver

mouv = true; 

while(mouv){                                // Tant que mouv est a TRUE la boucle while continue
  
Moteur1.run();                              // On avance d'1 micro pas

if ( !Moteur1.run() ){ mouv = false ; }     // Si il n'y a plus de micro pas a faire, ont sort de la boucle while

capteur();                                  // Vers le module capteur
}

digitalWrite(4, HIGH);                      // coupe l'alimentation du moteur via driver

}

Code : Tout sélectionner

void monte()
{
Moteur1.move(-50000);                             // Ont veut que le moteur bouge dans le sens anti-horaire de 50000 MICRO pas

digitalWrite(4,LOW);                              // Alimente le moteur via driver

mouv = true ;

while(mouv){

Moteur1.run() ;

if ( !Moteur1.run() ){ mouv = false ; }

capteur();                                        // Vers le module capteur
}

  digitalWrite(4, HIGH);

}

La partie (peut-être) la plus intéressante du programme, le module capteur ...

Code : Tout sélectionner

void capteur()
{

if (digitalRead(FCR) == LOW){    // teste la pin FCR (la n°5) si actionnée


Moteur1.stop();                  // Si pin actionnée, ordre de commencer le ralentissement du moteur et de le stopper 



}
  
}

[likiki]

Ajout d'un module fin de course total.

Arrête le moteur, coupe l'alimentation moteur et bloque le programme. Ce module est testé a chaque micro pas, juste avant le module capteur.

Code : Tout sélectionner

void FCHaut()
{

if (digitalRead(FCT) == LOW){               // teste la pin FCT (la n°6) si actionnée

mouv = false ;

digitalWrite(4, HIGH);                      // coupe l'alimentation du moteur via driver

while (mouv == false){                      // Boucle infini seul une RAZ de la carte permet d'en sortir

  delay (100);
}

}
  
}

Voilà, avec tout ça, nous avons de quoi faire pour beaucoup d'application nécessitant un ou des moteurs pas à pas.

Il existe encore pas mal de fonctions liées a cette bibliothèque, je les développerais au besoin, mais si certain d'entre vous les connaissent, allez y, détaillez les ici.

[Lherve54]

et voila cela avance !!

Notre chef , va finir par adapter tout ca a son boulot !!

[likiki]

Ce serait plutôt le contraire Hervé.

[herwat]

Une vraie machine à écrire, notre chef ! ça frise l'emballement ! ! !

Bon, j'analyserai ça plus tard, à tête reposée (très reposée )

[likiki]

Voici le programme dans sa totalité ...

Code : Tout sélectionner

/*
***************************************************
****** Ascenseur avec un moteur pas à pas   *******
******                                      *******
****** Programme d'essais ACCELSTEPPER      *******
****** Du 28/01/2022                        *******
****** Par C.ARFEL                          *******
******                                      *******
****** Carte MEGA 2560                      *******
******                                      *******
****** Version 1.0                          *******
                                      
******      Liste des bornes utilisées      *******                                      
******                                      *******                                      
****** D0 RX UNO                            *******                                      
****** D1 TX UNO                            *******                                      
****** D2 Step du TMC2209                   *******                                      
****** D3 Dir du TMC2209                    *******                                     
****** D4 Enable du TMC2209                 ******* 
****** D5 capteur Top ralentissement        ******* 
****** D6 capteur extreme                   ******* 
****** D7                                   *******                                      
****** D8                                   *******                                     
****** D9                                   *******                                     
****** D10                                  *******                                    
****** D11                                  *******                                      
****** D12                                  *******                                      
****** D13                                  *******                                      
******                                      *******                                      
******                                      *******                                                             
***************************************************
*/

#include <AccelStepper.h>                    // Appel de la bibliotheque Accelstepper

#define FCR 5                                // Attachement de l'objet Fin de Course Ralantissement a la broche n° 5

#define FCT 6                                // Attachement de l'objet Fin de Course Total a la broche n° 6

AccelStepper Moteur1(1, 2, 3);               // 1=Driver, Pin 2 = step, Pin 3 = dir


boolean mouv = true ;                         // Variable mouvement
int Position0 = 0;                            // Variable de position niveau 0 de référence

void setup() {
 

Serial.begin(9600);                          // Initialisation du port série


Moteur1.setMaxSpeed(4000);                   // vitesse max moteur en micro pas 4000

Moteur1.setAcceleration(1200);               // Nombre micro pas d'accélération / décélération 1200

Moteur1.setCurrentPosition (Position0);      // Position moteur a l'initialisation




/*
***************************************
* Mise en place des entrées / sorties *
***************************************
*/


pinMode(2, OUTPUT);

pinMode(3, OUTPUT);

pinMode(4, OUTPUT);

pinMode(5, INPUT);

pinMode(6, INPUT);

}
/*
************************
* Fin de la zone SETUP *
************************
*/

/*
*************************
* Début de la zone VOID *
*************************
*/

void capteur()
{

if (digitalRead(FCR) == LOW){    // teste la pin FCR (la n°5) si actionnée


Moteur1.stop();                  // Si pin actionnée, ordre de commencer le ralentissement du moteur et de le stopper 



}
  
}


void descente()
{
Moteur1.move(50000);                        // Ont veut que le moteur bouge dans le sens horaire de 50000 MICRO pas

digitalWrite(4,LOW);                        // Alimente le moteur via driver



while(mouv){                                // Tant que mouv est a TRUE la boucle while continue
  
Moteur1.run();                              // On avance d'1 micro pas

if ( !Moteur1.run() ){ mouv = false ; }     // Si il n'y a plus de micro pas a faire, ont sort de la boucle while

FCHaut();                                   // Vers le module FCHaut

capteur();                                  // Vers le module capteur
}

digitalWrite(4, HIGH);                      // coupe l'alimentation du moteur via driver

}


void monte()
{
Moteur1.move(-50000);                             // Ont veut que le moteur bouge dans le sens anti-horaire de 50000 MICRO pas

digitalWrite(4,LOW);                              // Alimente le moteur via driver



while(mouv){

Moteur1.run() ;

if ( !Moteur1.run() ){ mouv = false ; }

FCHaut();                                         // Vers le module FCHaut

capteur();                                        // Vers le module capteur
}

  digitalWrite(4, HIGH);

}

void FCHaut()
{

if (digitalRead(FCT) == LOW){               // teste la pin FCT (la n°6) si actionnée

mouv = false ;

digitalWrite(4, HIGH);                      // coupe l'alimentation du moteur via driver

while (mouv == false){                      // Boucle infini seul une RAZ de la carte permet d'en sortir

  delay (100);
}

}
  
}

                                   
/*
***********************
* Fin de la zone VOID *
***********************
*/

/*
*****************************************************************************
* boucle principale  ********************************************************
*****************************************************************************
*/


void loop() {

mouv = true;  
                                      
descente();                             // Vers le module descente

delay (3000);


mouv = true;

monte();                               // Vers le module monté

delay (3000);


}

[herwat]

Je vois que tu n'as pas utilisé les même fonctions que moi .

La fonction Moteur1.stop(); est sympa car elle permet d’arrêter à tout moment le moteur après sa phase de ralentissement ! et comme ce ralentissement est calculé par le programme, on est sûr qu'il s’arrêtera toujours au même endroit , au step près . Intéressant, intéressant . . .

De même la fonction Moteur1.move(Nb); Oblige le moteur a effectuer Nb steps quelque soit sa position .
Tandis que moi, j'utilise Moteur1.moveTo(pos); qui oblige le moteur à aller à la position "pos" exprimée en steps à partir de la position 0 .

Intéressant tout ça !

On va finir par la maitriser cette bibliothèque !
Elle est riche et vaut vraiment le coup !

[likiki]

Je rencontre juste un "petit" inconvegnant lors de la lecture d'une entrée changeante.

Le moteur s'arrête. Une a deux millisecondes, certe, mais cela se sent et engendre une vibration, donc un bruit.

Je l'aurais, je ne sais pas encore comment, mais je l'aurais.

[likiki]

Je l'ai eu, non mais, c'est pas une machine qui vas faire sa loi, Terminator ce n'est pas pour cette année.

Code : Tout sélectionner

void capteur()
{

Capteur = digitalRead(CR);            // lecture la pin CR (la n°5) si actionnée par capteur optique



if (Capteur != 0 & Pcapteur == 0){    // si capteur optique obstrué et si ne l'était pas avant ...
  
Pcapteur = 1;                                 // Capteur obstrué


if (Sens == 0){Top --;} else {Top ++;}


if (Top == Destination){

Moteur1.stop();                              // Si pin actionnée, ordre de commencer le ralentissement du moteur et de le stopper 

}

}
if (Capteur == 0) { Pcapteur = 0;}    // Si capteur n'est plus obtrué la variable est mise a 0
}

La petite vidéo qui vas bien.

Démarrage du moteur, comptage de 4 capteurs, ralentissement et arrêt avant de repartir dans l'autre sens.
.

.


Autre point 'noir' rencontré. Ne pas utiliser le moniteur série, cela ralenti de façon phénoménal la rotation moteur.

[herwat]

Mais c'est-y pas qu'il deviendrait bon , le chef

Pas bête du tout, ton idée .

Par contre, effectivement, le moniteur série , dans ce genre de programme, c'est une catastrophe . . .

Mais j'ai vu que tu utilise une vitesse égale à 4000 . Attention, c'est proche de la vitesse maximum admissible pour un arduino MEGA .

[likiki]

Hervé, bizarre j'ai les chevilles qui enflent.

Alors, j'ai testé plusieurs valeurs, a 3600 j'ai un grognement vibratoire sur le moteur, a 4000 rien, a 4200 re-belote. C'est la raison de ce choix.

En sachant que le programme vas s'étoffer et donc ralentir dans sont exécution moteur.