Faire fonctionner 2 moteurs pas à pas

Bonjour,
Je suis un vrai novice.
Je souhaiterais utiliser arduino, pour animer ma vitrine de Noel.
Je suis un peu limité dans mon auto- apprentissage.
Mon idée et de faire monter et descendre un théière.
Je pense accrocher un dessous de théière aux 4 coins. Les 2 coins avant, seraient accrochés sur un moteur par a pas 28byj-48. Les 2 coins arrières seraient branchés sur un autre moteur.
Mon fonctionnement est de faire descendre la théière (ex: sur 50 cm), puis le moteur arrière se lèverait sur 4cm, pour faire comme un effet de versement du thé comme pour servir le thé. Puis revenir a plat et remonter ....
Mon problème et le fonctionnement des 2 moteurs en même temps.
J'ai codé et téléversé, mais un seul moteur fonctionne sur les 2 souhaités en même temps.
Dans mes recherches, je n'ai pas compris la faisabilité de ce double fonctionnement.
SI toutefois, quelqu'un pourrait m'apporter une aide, cela permettrait peut être d'atteindre mon idée de vitrine de noel et continuer mon apprentissage.
Je joint mon code. IL n'est pas parfait évidemment, mais je ne pense pas que cela justifie le non fonctionnement souhaité. Je pense que je n'ai pas les bon code et étant donné qu"il y a du delay, il y a apparemment une incompatibilité à ce niveau.
Merci de votre soutien.

#include <AccelStepper.h>

// Définir les constantes de pas
const int FULLSTEP = 4;
const int MOTEUR1_FULLSTEP = 4;
const int MOTEUR2_FULLSTEP = 8;

// Créer deux instances de la classe AccelStepper
// Les broches sont définies dans l'ordre IN1-IN3-IN4-IN2 pour une séquence de pas appropriée
AccelStepper stepper1(FULLSTEP, 8, 10, 9, 11);
AccelStepper stepper2(FULLSTEP, 4, 6, 5, 7);

// Paramètres
const long distanceEnPas = 6520;  // La distance que vous souhaitez parcourir en pas
const long distanceMonteeEnPas = 520; // La distance pour la montée de 520 pas
const unsigned long delaiArret = 5000;  // Délai en millisecondes pour l'arrêt (5 secondes)

void setup() {
  stepper1.setMaxSpeed(1000);  // Vitesse maximale en pas par seconde pour le moteur 1
  stepper1.setAcceleration(1000);  // Accélération en pas par seconde carrée pour le moteur 1

  stepper2.setMaxSpeed(1000);  // Vitesse maximale en pas par seconde pour le moteur 2
  stepper2.setAcceleration(1000);  // Accélération en pas par seconde carrée pour le moteur 2

// Descendre MOTEUR 1 et 2 de 6520 pas
  stepper1.run();
  stepper2.run();
  stepper1.move(-distanceEnPas);
  stepper2.move(-distanceEnPas);
  stepper1.runToPosition();
  stepper2.runToPosition();

  // Pause pendant 5 secondes
  delay(delaiArret);

  // Arrêter MOTEUR 1 pendant que MOTEUR 2 monte de 52 pas
  stepper1.stop();
  stepper2.move(distanceMonteeEnPas);
  stepper2.runToPosition();
  delay(delaiArret);

  // Descendre MOTEUR 2 de 52 pas
  stepper2.move(-distanceMonteeEnPas);
  stepper2.runToPosition();

  // Monter MOTEUR 1 et MOTEUR 2 de 652 pas
  stepper1.move(distanceEnPas);
  stepper1.runToPosition();
  stepper2.move(distanceEnPas);
  stepper2.runToPosition();
}

void loop() {
  // Mettre à jour les positions des deux moteurs en simultané
  gerermoteur1();
  gerermoteur2();
  stepper1.run();
  stepper2.run();

  // Pause pendant 5 secondes
  delay(delaiArret);

  // Arrêtez MOTEUR 1 pendant que MOTEUR 2 monte de 52 pas
  stepper1.stop();
  stepper2.move(distanceMonteeEnPas);
  stepper2.runToPosition();
 
  // Pause de 5 secondes
  delay(delaiArret);

  // Descendez MOTEUR 2 de 520 pas
  stepper2.move(-distanceMonteeEnPas);
  stepper2.runToPosition();

  // Faites monter MOTEUR 1 et MOTEUR 2 de 6520 pas
  stepper1.move(distanceEnPas);
  stepper1.runToPosition();
  stepper2.move(distanceEnPas);
  stepper2.runToPosition();
}

Bonjour mister_tea

Excellente idée le coups de la théière :wink:

Dans ton programme dans loop()

stepper1.run();
stepper2.run();

C'est OK
Après, pour les mouvements, avec moveTo(), tu devrait lancer le ou les mouvements nécessaire et, ensuite, attendre leur exécution avec un
stepper1.distanceToGo();
et ou
stepper2.distanceToGo();
fonction qui retourne 0 quand le moteur est arrivé.
ensuite prochain(s) mouvement(s)...

Avec distanceToGo() on évite au maximum les temporisations.

A+
Cordialement
jpbbricole

Merci du conseil :wink:
A coté de cela,belle galère de compréhension pour faire fonctionner les moteurs en même temps.

Bonjour mister_tea

Je te fais un exemple.

Cordialement
jpbbricole

d'avance merci.
Je continue mes recherche je suis sur :

ou vous êtes intervenu, intéressant, je persévère

Bonjour mister_tea

Voici un exemple avec .distanceToGo():

#include <AccelStepper.h>

// Définir les constantes de pas
const int FULLSTEP = 4;
const int MOTEUR1_FULLSTEP = 4;
const int MOTEUR2_FULLSTEP = 8;

// Créer deux instances de la classe AccelStepper
// Les broches sont définies dans l'ordre IN1-IN3-IN4-IN2 pour une séquence de pas appropriée
AccelStepper stepper1(FULLSTEP, 8, 10, 9, 11);
AccelStepper stepper2(FULLSTEP, 4, 6, 5, 7);

// Paramètres
const long distanceEnPas = 6520;  // La distance que vous souhaitez parcourir en pas
const long distanceMonteeEnPas = 520; // La distance pour la montée de 520 pas
const unsigned long delaiArret = 5000;  // Délai en millisecondes pour l'arrêt (5 secondes)

void setup() 
{
	Serial.begin(115200);

	stepper1.setMaxSpeed(1000);  // Vitesse maximale en pas par seconde pour le moteur 1
	stepper1.setAcceleration(1000);  // Accélération en pas par seconde carrée pour le moteur 1

	stepper2.setMaxSpeed(1000);  // Vitesse maximale en pas par seconde pour le moteur 2
	stepper2.setAcceleration(1000);  // Accélération en pas par seconde carrée pour le moteur 2
}

void loop() 
{
	//--------------------------------- Descente 2 moteurs
	Serial.println("\nDescente");
	moteursMouvement(-distanceEnPas, -distanceEnPas);
	delay(delaiArret);

	//--------------------------------- Verser
	Serial.println("Verser");
	moteursMouvement(0, distanceMonteeEnPas);
	delay(delaiArret);

	//--------------------------------- Au départ
	Serial.println("Verser fin");
	moteursMouvement(0, -distanceMonteeEnPas);
	delay(delaiArret);

	//--------------------------------- Arret verser
	Serial.println("Retour au debut");
	moteursMouvement(distanceEnPas, distanceEnPas);
	delay(delaiArret * 2);
}

void moteursMouvement(long move1, long move2)
{
	Serial.print(("Move\t") + String(move1) + "\t" + String(move2));

	stepper1.move(move1);     // Démarrage des moteurs
	stepper2.move(move2);

	while (stepper1.distanceToGo() + stepper2.distanceToGo() != 0)     // Tant que un des moteur n'est pas arrivé
	{
		stepper1.run();
		stepper2.run();
	}
	Serial.println("\tArrive(s)");
}

Je te laisse découvrir et poser les bonnes questions :wink:
Je n'ai pas essayé avec des moteurs.

A+
Cordialement
jpbbricole

Je pensais au départ que mon idée était quelque chose de réalisable pour un novice.
Mais passer à 2 moteurs n'a plus rien à voir.
un while et un void moteursmouvement en plus de la base.
Je n'ai qu'un seul moteur qui tourne.
Un lundi découverte approfondie, par rapport au départ?
Journée travail. Je reviendrez dessus demain, car je n'ai pas encores tout bien compris.
comme par exemple l'utilité du Serial begin et string dans le code. Mais je ne desepère pas.
J'ai la journée de demain pour persévérer dans mon apprentissage.
Bonne journée.

Bonjour mister_tea

Oui, c'est réalisable par un novice, tu as déjà fait marcher un moteur et choisi la bonne bibliothèque :wink:
Maintenant, à moi de te guider jusqu'à l'aboutissement.

while = tant que, en l'occurrence:

while (stepper1.distanceToGo() + stepper2.distanceToGo() != 0)

Tant qu'un des 2 moteurs n'est pas arrivé.

Pour void moteursMouvement(long move1, long move2), dans ton programme il y a 4 mouvements:

	//--------------------------------- Descente 2 moteurs
	//--------------------------------- Verser
	//--------------------------------- Au départ
	//--------------------------------- Arret verser

Tout ces mouvements nécessitent la même "mécanique" pour leur exécution, sauf le nombre pas de déplacement de steppeer1 et stepper2. Plutôt que de répéter 5 fois cette "mécanique" on crée une fonction, void moteursMouvement(long move1, long move2) à laquelle un transmet les mouvements des 2 moteurs (long move1, long move2) et on appelle cette fonction par:
moteursMouvement(0, distanceMonteeEnPas);
dans ce cas, stepper1 ne bouge pas et stepper2 bouge de distanceMonteeEnPas (6520)

Je vais faire le montage pour être plus dans le vrai.

Serial begin démarre le port série de l'Arduino, ce port série permet d'afficher des choses dans le moniteur série de l'IDE Arduino à 115200.
image
image
Ce petit "confort" permet d'afficher les diverses phases de fonctionnement de ton programme comme:
Serial.println("Verser");
Une fois le programme au point, ces lignes pourront être supprimées ou mises en remarque.
Le déroulement du programme s'affiche ainsi:

Descente
Move	-6520	-6520	Arrive(s)
Verser
Move	0	520	Arrive(s)
Verser fin
Move	0	-520	Arrive(s)
Retour au debut
Move	6520	6520

Pour ce qui est de string, dans cet exemple:
Serial.print(("Move\t") + String(move1) + "\t" + String(move2));
Serial.print ne permet d'afficher ou du texte ou des chiffres, mais pas un mélange des deux, String permet de convertir une valeur numérique (move1 et move 2) en texte, ainsi Serial.print n'a plus que du texte à afficher.

A+
Cordialement
jpbbricole

Bonjour mister_tea

Ne te gêne surtout pas de poser des questions :wink:

J'ai fait le montage et les 2 moteurs fonctionnent, as tu un problème de câblage?

J'ai légèrement diminué la vitesse, setMaxSpeed, de 1000 à 900, avec 1000 mes moteurs ont tendance à vibrer au lieu de tourner.

Autre amélioration, activer les moteurs seulement quand nécessaire, autrement, les désactiver, cela évite qu'ils soient sous courant quand ils sont arrêtés:

	stepper1.disableOutputs();     // Désactiver les commandes moteur
	stepper2.disableOutputs();
et
	stepper1.enableOutputs();     // Activer les commandes moteur
	stepper2.enableOutputs();

Petite question, ce système nécessite d'avoir une position de départ, comment as tu prévu la chose?

Le programme:

#include <AccelStepper.h>

// Définir les constantes de pas
const int FULLSTEP = 4;
const int MOTEUR1_FULLSTEP = 4;
const int MOTEUR2_FULLSTEP = 8;

// Créer deux instances de la classe AccelStepper
// Les broches sont définies dans l'ordre IN1-IN3-IN4-IN2 pour une séquence de pas appropriée
AccelStepper stepper1(FULLSTEP, 8, 10, 9, 11);
AccelStepper stepper2(FULLSTEP, 4, 6, 5, 7);

// Paramètres
const long distanceEnPas = 6520;  // La distance que vous souhaitez parcourir en pas
const long distanceMonteeEnPas = 520; // La distance pour la montée de 520 pas
const unsigned long delaiArret = 5000;  // Délai en millisecondes pour l'arrêt (5 secondes)

void setup() 
{
	Serial.begin(115200);

	stepper1.setMaxSpeed(900);  // Vitesse maximale en pas par seconde pour le moteur 1
	stepper1.setAcceleration(1000);  // Accélération en pas par seconde carrée pour le moteur 1

	stepper2.setMaxSpeed(900);  // Vitesse maximale en pas par seconde pour le moteur 2
	stepper2.setAcceleration(1000);  // Accélération en pas par seconde carrée pour le moteur 2

	stepper1.disableOutputs();     // Désactiver les commandes moteur
	stepper2.disableOutputs();
}

void loop() 
{
	//--------------------------------- Descente 2 moteurs
	Serial.println("\nDescente");
	moteursMouvement(distanceEnPas, distanceEnPas);
	delay(delaiArret);

	//--------------------------------- Verser
	Serial.println("Verser");
	moteursMouvement(0, -distanceMonteeEnPas);
	delay(delaiArret);

	//--------------------------------- Arret verser
	Serial.println("Verser fin");
	moteursMouvement(0, distanceMonteeEnPas);
	delay(delaiArret);

	//--------------------------------- Au départ
	Serial.println("Retour au debut");
	moteursMouvement(-distanceEnPas, -distanceEnPas);
	delay(delaiArret * 2);
}

void moteursMouvement(long move1, long move2)
{
	Serial.print(("Move\t") + String(move1) + "\t" + String(move2));

	stepper1.enableOutputs();     // Activer les commandes moteur
	stepper2.enableOutputs();

	stepper1.move(move1);     // Démarrage des moteurs
	stepper2.move(move2);

	while ((stepper1.distanceToGo() != 0) || (stepper2.distanceToGo() != 0))     // Tant que un des moteur n'est pas arrivé
	{
		stepper1.run();
		stepper2.run();
	}

	stepper1.disableOutputs();     // Désactiver les commandes moteur
	stepper2.disableOutputs();

	Serial.println("\tArrive(s)");
}

Le montage de test:
image

A+
Cordialement
jpbbricole

Bonjour,

après une longue réflexion sur la question d'un problème de câblage, j'ai effectivement trouvé solution.
// Les broches sont définies dans l'ordre IN1-IN3-IN4-IN2 pour une séquence de pas appropriée
AccelStepper stepper1(FULLSTEP, 8, 10, 9, 12);
IN2 = 12 et non 11.
Vous m'avez grandement aidé et je vous en remercie énormément.
J'ai encore beaucoup à apprendre de tout ce que vous m'avez transmis, mais pour ma première participation sur un forum, je me rends compte de l’énorme aide que je peux trouver.
Ensuite je pense que je devrais changer de moteur, car je ne pense pas que les actuels sont suffisamment puissant pour une théière de 800gr environ.
Il y a encore de quoi découvrir sur ce projet, mais sans vous je n'aurais pas avancé et appris autant.
Je vais donc m'orienter sur la théorie ou le code pour persévérer, pour peut-être continuer à développer l'animation de mes vitrines futurs.
De tout ce que j'ai lu sur le forum, Je sais que si besoin jpbbricole est d'une grande aide à beaucoup de monde.
Encore merci énormément.

Bonsoir mister_tea

Je suis un adepte de l'apprentissage par l'exemple, j'ai beaucoup appris en copiant et je n'ai pas encore fini d'apprendre :wink:, c'est pourquoi je fais volonté des programmes tel que le tiens.
Petite remarque, j'ai peaufiné mon programme et, donc, modifié celui du [post#9] et il y avait un petit bug :woozy_face:(Faire fonctionner 2 moteurs pas à pas - #9 by jpbbricole) fais attention que tu aies la version avrc cette ligne, vers la fin du code:

	while ((stepper1.distanceToGo() != 0) || (stepper2.distanceToGo() != 0))     // Tant que un des moteur n'est pas arrivé

Autre petite remarque, si tu veux inverser un moteur par rapport à l'autre, il suffit de passer cette ligne:

	stepper2.move(move2);
en
	stepper2.move(-move2);

Pour ça, tu peux toujours revenir ici, j'adore ça :wink:

Oui, en effet, ça risque d'être un peu lourd, je peux faire des essais avec des Nema17 avec des A4988 comme drivers,
image

la bibliothèque que tu as choisie, AccelStepper, s'adapte très bien à ce matériel.

A+
Bonne soirée
jpbbricole

Bonjour mister_tea

Pour éviter de devoir mettre des moteurs puissants, n'aurais tu pas la possibilité de "camoufler" des contrepoids;

Cordialement
jpbbricole

Bonjour, de retour après avoir investi dans des nema17 et carte cnc shield, et le temps de gérer les travail. J'ai essayé de m'en sortir dans un premier temps seul, mais je bloqué dès le début.
j'ai effectué mes branchements, réglé la tension, trouvé un simple programme pour tester, et rien de tourne.
Lorsque je connecte le moteur sur les branches de la cnc shield il y a bien à peu près un pas qui s’effectue, mais une fois enfoncé cela ne tourne pas.
je me dis que mon ampérage ou électricité est peu être la cause, mais même si je change cela ne fonctionne pas non plus.
Si un oeil averti pouvait m'éclairer
Merci beaucoup

Bonsoir mister_tea

Quand le programme est lancé, est ce que, en tournant l'axe du moteur à la main, tu sent de la résistance?
Mets ton programme de test en ligne.

A+
jpbbricole

oui il y a bien de la resistance

J ai essaye avec un autre progtramme precedemment et celui ci

saisissez ou#include <AccelStepper.h>
const int enPin=8;
const int stepXPin = 2; //X.STEP
const int dirXPin = 5; // X.DIR
const int stepYPin = 3; //Y.STEP
const int dirYPin = 6; // Y.DIR
const int stepZPin = 4; //Z.STEP
const int dirZPin = 7; // Z.DIR

int stepPin=stepYPin;
int dirPin=dirYPin;

const int stepsPerRev=200;
int pulseWidthMicros = 100; 	// microseconds
int millisBtwnSteps = 1000;

void setup() {
 	Serial.begin(9600);
 	pinMode(enPin, OUTPUT);
 	digitalWrite(enPin, LOW);
 	pinMode(stepPin, OUTPUT);
 	pinMode(dirPin, OUTPUT);
 
 	Serial.println(F("CNC Shield Initialized"));
}

void loop() {
 	Serial.println(F("Running clockwise"));
 	digitalWrite(dirPin, HIGH); // Enables the motor to move in a particular direction
 	// Makes 200 pulses for making one full cycle rotation
 	for (int i = 0; i < stepsPerRev; i++) {
 			digitalWrite(stepPin, HIGH);
 			delayMicroseconds(pulseWidthMicros);
 			digitalWrite(stepPin, LOW);
 			delayMicroseconds(millisBtwnSteps);
 	}
 	delay(1000); // One second delay

 	Serial.println(F("Running counter-clockwise"));
 	digitalWrite(dirPin, LOW); //Changes the rotations direction
 	// Makes 400 pulses for making two full cycle rotation
 	for (int i = 0; i < 2*stepsPerRev; i++) {
 			digitalWrite(stepPin, HIGH);
 			delayMicroseconds(pulseWidthMicros);
 			digitalWrite(stepPin, LOW);
 			delayMicroseconds(millisBtwnSteps);
 	}
 	delay(1000);
} collez du code ici
#include <Stepper.h>

// Déclaration des broches de contrôle du moteur
const int stepPin = 2;
const int dirPin = 3;

// Déclaration de la résolution du moteur
const int stepsPerRevolution = 200;

// Création de l'objet Stepper
Stepper myStepper(stepsPerRevolution, stepPin, dirPin);

void setup() {
  // Déclaration de la vitesse du moteur
  myStepper.setSpeed(100); // Vitesse en tours par minute (TPM)

  // Déclaration de la direction du moteur
  pinMode(dirPin, OUTPUT);
}

void loop() {
  // Lecture de la valeur du potentiomètre
  int potValue = analogRead(A0);

  // Conversion de la valeur du potentiomètre en une valeur de direction (-1 ou 1)
  int dir = map(potValue, 0, 1023, -1, 1);

  // Définition de la direction du moteur
  digitalWrite(dirPin, dir);

  // Faire avancer le moteur d'un pas
  myStepper.step(1);
}

Dans le courant de la soirée, je vais adapter le programme du post#9 à ta nouvelle configuration, ce sera plus simple.

Ton 2ème programme ne fonctionne pas, le signal ENABLE, pin 8 n'est pas géré et ditPin doit être à 5

A+
Cordialement
jpbbricole

Merci du soutien.
Je vais continuer de poursuivre mon apprentissage pendant ce temps.
Bonne soirée.

Bonsoir mister_tea

Voilà le version du programme du post#9 adaprtée à ton shield CNC.
Il y a un bouton start ou un pont à mettre sur les bornes d'Abort (`btnStartPin), image

pour démarrer une séquence.
A toi de me dire comment tu veux démarrer/arrêter ton programme.

Dans la console, à 115200, il y a des indications sur le fonctionnement du programme:

Descente
Move	6520	6520	Arrive(s)
Verser
Move	0	-520	Arrive(s)
Verser fin
Move	0	520	Arrive(s)
Retour au debut
Move	-6520	-6520	Arrive(s)

Tu peux jouer avec les paramètres:

// Paramètres
const long distanceEnPas = 6520;  // La distance que vous souhaitez parcourir en pas
const long distanceMonteeEnPas = 520; // La distance pour la montée de 520 pas
const unsigned long delaiArret = 5000;  // Délai en millisecondes pour l'arrêt (5 secondes)

et les paramètres moteur:

	stepper1.setMaxSpeed(600);  // Vitesse maximale en pas par seconde pour le moteur 1
	stepper1.setAcceleration(1000);  // Accélération en pas par seconde carrée pour le moteur 1
	stepper2.setMaxSpeed(600);  // Vitesse maximale en pas par seconde pour le moteur 2
	stepper2.setAcceleration(1000);  // Accélération en pas par seconde carrée pour le moteur 2

et, surtout, ne pas te gêner de poser des questions :wink:.

Le programme:

/*
    Name:       ARDFR_mister_tea_TheiereMpap.ino
    Created:	01.11.2023
    Author:     jpbbricole/mister_tea
				https://forum.arduino.cc/t/faire-fonctionner-2-moteurs-pas-a-pas/1183801/7

				Fairte descendre, verser et remonter une théière avec 2 mpap
	26.11.2023	Adaption du programme au CNC Shield V3
*/
#include <AccelStepper.h>

const int steppersEnaPin=8;
const int stepper1StepPin = 2;     // Moteur 1 Step
const int stepper1DirPin = 5;     // Moteur 1 Dir
const int stepper2StepPin = 3;
const int stepper2DirPin = 6;


// Créer deux instances de la classe AccelStepper
AccelStepper stepper1(AccelStepper::DRIVER, stepper1StepPin, stepper1DirPin);
AccelStepper stepper2(AccelStepper::DRIVER, stepper2StepPin, stepper2DirPin);

// Paramètres
const long distanceEnPas = 6520;  // La distance que vous souhaitez parcourir en pas
const long distanceMonteeEnPas = 520; // La distance pour la montée de 520 pas
const unsigned long delaiArret = 5000;  // Délai en millisecondes pour l'arrêt (5 secondes)

const int btnStartPin = A0;     // Bouton de démarrage
const int btnEtatOn = LOW;     // Etat lu du bouton quand pressé

void setup()
{
	Serial.begin(115200);

	pinMode(btnStartPin, INPUT_PULLUP);

	stepper1.setEnablePin(steppersEnaPin);     // Pin ENABLE
	stepper1.setPinsInverted(false, false, true);
	stepper1.enableOutputs();     // Activer les signaux du MPAP
	stepper1.setMaxSpeed(600);  // Vitesse maximale en pas par seconde pour le moteur 1
	stepper1.setAcceleration(1000);  // Accélération en pas par seconde carrée pour le moteur 1

	stepper2.setEnablePin(steppersEnaPin);     // Pin ENABLE
	stepper2.setPinsInverted(false, false, true);
	stepper2.enableOutputs();     // Activer les signaux du MPAP
	stepper2.setMaxSpeed(600);  // Vitesse maximale en pas par seconde pour le moteur 2
	stepper2.setAcceleration(1000);  // Accélération en pas par seconde carrée pour le moteur 2
}

void loop()
{
	if (digitalRead(btnStartPin) == btnEtatOn)     // Si bouton start pressé
	{
		programmeStart();
	}
}

void programmeStart()
{
	//--------------------------------- Descente 2 moteurs
	Serial.println("\nDescente");
	moteursMouvement(distanceEnPas, distanceEnPas);
	delay(delaiArret);

	//--------------------------------- Verser
	Serial.println("Verser");
	moteursMouvement(0, -distanceMonteeEnPas);
	delay(delaiArret);

	//--------------------------------- Arret verser
	Serial.println("Verser fin");
	moteursMouvement(0, distanceMonteeEnPas);
	delay(delaiArret);

	//--------------------------------- Au départ
	Serial.println("Retour au debut");
	moteursMouvement(-distanceEnPas, -distanceEnPas);
	delay(delaiArret * 2);
}

void moteursMouvement(long move1, long move2)
{
	Serial.print(("Move\t") + String(move1) + "\t" + String(move2));

	stepper1.enableOutputs();     // Activer les commandes moteur
	stepper2.enableOutputs();

	stepper1.move(move1);     // Démarrage des moteurs
	stepper2.move(move2);

	while ((stepper1.distanceToGo() != 0) || (stepper2.distanceToGo() != 0))     // Tant que un des moteur n'est pas arrivé
	{
		stepper1.run();
		stepper2.run();
	}

	//stepper1.disableOutputs();     // Désactiver les commandes moteur
	//stepper2.disableOutputs();

	Serial.println("\tArrive(s)");
}

A+
Bonne soirée.
jpbbricole