PB demi-tour 3 moteurs PAP en simultané

Bonjour à toutes et à tous,

après deux soirées passées à chercher sans trouver je vous expose mon problème qui pourtant ne me semblait pas si compliqué que cela, mais cela doit être dû à mon niveau de grand débutant :wink:
Je suis en train de réaliser une "sculpture musicale" on pourrait dire, où des moteurs pas à pas frottent des cordes à l'aide de médiators. J'ai trouvé un code que j'ai un peu modifié pour mes besoins et cela fonctionne, je peux actionner simultanément 3 moteurs PAP mais je ne parviens pas à modifier les cycles. Je voudrais dans un premier temps simplement faire en sorte que les moteurs ne fasse pas une révolution complète mais un 180° (afin d'aller plus vite). Voici le code (je pense que cela se situe au niveau du void loop) d'avance merci pour vos lumières et votre aide ! (et surtout je vais essayer de comprendre pour aménager d'autres configurations par la suite)

`

Texte préformaté`//declare variables for the motor pins
int motorPin1 = 10; // Blue
int motorPin2 = 11; // Pink
int motorPin3 = 12; // Yellow
int motorPin4 = 13; // Orange
// Red (VCC)

int motorPin5 = 9; // Blue
int motorPin6 = 8; // Pink
int motorPin7 = 7; // Yellow
int motorPin8 = 6; // Orange
// Red (VCC)


int motorPin9 = 5; // Blue
int motorPin10 = 4; // Pink
int motorPin11 = 3; // Yellow
int motorPin12 = 2; // Orange
// Red (VCC)

int motorSpeed = 300; // stepper speed
int count = 0; // count steps
int countsperrev = 4096; // steps per revolution
int lookup[8] = {B01000, B01100, B00100, B00110, B00010, B00011, B00001, B01001};

unsigned long currentMillis = millis();


void setup() {
Serial.begin(9600);
//declare the motor pins as outputs
pinMode(motorPin1, OUTPUT);
pinMode(motorPin2, OUTPUT);
pinMode(motorPin3, OUTPUT);
pinMode(motorPin4, OUTPUT);

pinMode(motorPin5, OUTPUT);
pinMode(motorPin6, OUTPUT);
pinMode(motorPin7, OUTPUT);
pinMode(motorPin8, OUTPUT);
Serial.begin(9600);

pinMode(motorPin9, OUTPUT);
pinMode(motorPin10, OUTPUT);
pinMode(motorPin11, OUTPUT);
pinMode(motorPin12, OUTPUT);
Serial.begin(9600);
}

void loop(){
countsperrev = 10;
if(count < countsperrev )
clockwise();
else if (count == countsperrev * 1)
count = 10;
else
anticlockwise();
count++;
}

///// functions //////

void anticlockwise()
{
for(int i = 0; i < 9; i++)
{
setOutput(i);
delayMicroseconds(motorSpeed);
Serial.print("A "); Serial.print(i); Serial.println(count);
}
}

void clockwise()
{
for(int i = 9; i >= 10; i--)
{
setOutput(i);
delayMicroseconds(motorSpeed);
Serial.print("B "); Serial.print(i); Serial.println(count);
}
}

void setOutput(int out)
{
digitalWrite(motorPin1, bitRead(lookup[out], 0) );
digitalWrite(motorPin2, bitRead(lookup[out], 1) );
digitalWrite(motorPin3, bitRead(lookup[out], 2) );
digitalWrite(motorPin4, bitRead(lookup[out], 3) );

digitalWrite(motorPin5, bitRead(lookup[out], 0) );
digitalWrite(motorPin6, bitRead(lookup[out], 1) );
digitalWrite(motorPin7, bitRead(lookup[out], 2) );
digitalWrite(motorPin8, bitRead(lookup[out], 3) );

digitalWrite(motorPin9, bitRead(lookup[out], 0) );
digitalWrite(motorPin10, bitRead(lookup[out], 1) );
digitalWrite(motorPin11, bitRead(lookup[out], 2) );
digitalWrite(motorPin12, bitRead(lookup[out], 3) );
}saisissez ou collez du code ici

Merci encore !

vous comprenez le code. Par exemple ça fait quoi ça ?

Bonsoir, merci pour votre retour. Je dirais que si le nombre de pas allant dans une direction horaire est équivalent au nombre de pas allant dans le sens contraire alors il y aura 10 pas allant dans le sens initial, soit pas de changements possibles

non pas vraiment... je suppose que ça fait partie du code que vous avez bidouillé ?

countsperrev était à l'origine le nombre de pas pour faire un tour, ici 4096

mais vous avez du modifier cela parce que dans le code de la loop il passe à 10

donc

else if (count == countsperrev * 1)
count = 10;

dit si mon count vaut 10 (10 * 1 = 10) alors mettre count à ... 10.... super utile vous en conviendrez ...

autre truc que vous avez essayé de bidouiller sans doute

for(int i = 9; i >= 10; i--)

ça dit on commence avec i qui vaut 0 et tant qu'il est plus grand que 10 alors on le décrémente... comme 9 n'est pas plus grand que 10....

bref, le code fait n'importe quoi.. revenez au code d'origine ou encore mieux écrivez votre code avec la bibliothèque Stepper ➜ regardez l'exemple sweep pour vous inspirer

Merci pour votre retour. Pour la première modification il s’agit de la solution trouver pour palier à une difficulté : le moteur arrivant devant la corde qu’il devait pincer repartait dans l’autre sens ( la résistance étant trop forte). J’en convient c’est peu élégant mais je n’ai pas trouvé mieux.
Pour le second code, il s’agit bien du code original. Enfin pour la bibliothèque Stepper, je n’ai pas trouvé à part ce code, une façon de faire fonctionner simultanément les 3 PAP, et mon niveau de débutant ( total débutant) ne me permet pas de recréer un code complet. Ainsi est il possible de demander aux PAP de réaliser un demi tour au lieu d’un tour complet ? D’avance merci.

Avec la bibliothèque stepper vous faites une boucle qui demande de faire un pas à chaque moteur - les instructions seront envoyées séquentiellement mais la perception sera sans doute qu’ils avancent en même temps.

La boucle for doit faire le nombre de pas qu’il faut pour un demi tour

Une fois terminé vous faites la même boucle for mais en demandant de faire -1 pas pour aller dans l’autre sens

Merci pour votre retour. j'avais tenté de faire une manipulation de ce genre à partir de codes trouvés via la librairie Stepper mais les moteurs étaient très (trop) lent probablement dû à la séquentialité du montage d'où mon souhait de travailler en simultané. Par ailleurs, j'entends bien vos conseils que je comprends mais ma difficulté réside dans la traduction en langage informatique, ce que je ne maîtrise pas. Cela me serait plus simple de partir du code fourni afin de voir quels paramètres devaient être modifiés, par avance merci.

pour vous donner une idée ça aurait pu ressembler à cela avec la bibliothèque stepper
(tapé ici, non testé)

#include <Stepper.h>

// les pins des moteurs
// ATTENTION: NE PAS ALIMENTER LES MOTEURS DEPUIS L'ARDUINO. JOINDRE LES GND
const byte motor1Pin1 = 10; // Blue
const byte motor1Pin2 = 11; // Pink
const byte motor1Pin3 = 12; // Yellow
const byte motor1Pin4 = 13; // Orange

const byte motor2Pin1 = 9; // Blue
const byte motor2Pin2 = 8; // Pink
const byte motor2Pin3 = 7; // Yellow
const byte motor2Pin4 = 6; // Orange

const byte motor3Pin1 = 5; // Blue
const byte motor3Pin2 = 4; // Pink
const byte motor3Pin3 = 3; // Yellow
const byte motor3Pin4 = 2; // Orange

// à changer en fonction du nombre de pas par tour
const int stepsPerRevolution = 200;

// déclarer les moteurs, s'assurer que les pins sont dans le bon ordre
Stepper pap1(stepsPerRevolution, motor1Pin1, motor1Pin2, motor1Pin3, motor1Pin4);
Stepper pap2(stepsPerRevolution, motor2Pin1, motor2Pin2, motor2Pin3, motor2Pin4);
Stepper pap3(stepsPerRevolution, motor3Pin1, motor3Pin2, motor3Pin3, motor3Pin4);

void setup() {}

void loop() {
  // on fait 1/2 tour dans un sens
  for (int i = 0; i <= stepsPerRevolution / 2; i++) {
    pap1.step(1);
    pap2.step(1);
    pap3.step(1);
  }

  // petite pause avant de changer de sens (nécessaire ?)
  delay(5);

  // on fait 1/2 tour dans l'autre sens
  for (int i = stepsPerRevolution / 2; i >= 0; i--) {
    pap1.step(-1);
    pap2.step(-1);
    pap3.step(-1);
  }
}

si c'est trop lent (parce qu'on fait juste 1 pas après un pas, on n'utilise pas le stepper au mieux) il faut passer en mode asynchrone et utiliser par exemple la bibliothèque accelStepper

Je suppose qu'il n'y a pas besoin de couple et que vous voulez au final que ça "gratte" rapidement, pourquoi ne pas prendre des servo moteurs plutôt qu'un pas à pas ?

Merci beaucoup pour le retour. Le code en tant que tel ne marche pas mais j'imagine que je peux aménager et remplacer votre void loop par le précédent (je vais essayer ça entre midi et 2 ). Pour le couple, il faudra que les cordes concernées soient simplement "pincées" comme le ferait un guitariste (la sculpture sera amplifiée donc pas besoin de puissance) et pourquoi des moteurs PAP : la première des réponse est ... parceque j'en avais à disposition :slight_smile: mais par la suite j'ai aussi intégré des servomoteurs mais... qui font beaucoup plus de bruit que les PAP, donc j'ai gardé 2 servomoteurs puis 6 moteurs PAP (3 X 2). Enfin, je comprends qu'on pouvait diviser en 2 la révolution cela devrait m'aider grandement ! Merci encore, à tout à l'heure pour le diagnostic :wink:

c'est sans doute que les pins ne sont pas définies dans le bon ordre dans

Stepper pap1(stepsPerRevolution, motor1Pin1, motor1Pin2, motor1Pin3, motor1Pin4);
Stepper pap2(stepsPerRevolution, motor2Pin1, motor2Pin2, motor2Pin3, motor2Pin4);
Stepper pap3(stepsPerRevolution, motor3Pin1, motor3Pin2, motor3Pin3, motor3Pin4);

j'ai juste utilisé l'ordre dans lequel vous aviez fait les déclarations, c'est sans doute faux.

si vous parlez des 2 boucles for, oui pourquoi pas.

vous pouvez décrire votre circuit ? vous avez un contrôleur pour vos moteurs pas à pas ?


c'est souvent une bonne raison quand on bricole :slight_smile:

Super ! Merci encore. Alors oui, les PAP ont tous des drivers j'utilise pour 3 moteurs une arduino uno, pour 3 autres une mega et deux nano pour chacun des servomoteurs (mon idée à terme, pas pour le moment, est de pouvoir incrémenter des codes variables pour changer les mélodies et harmonie de l'instrument). Ci-joint une photo de l'oeuvre en cours :

En vue globale :

OK on dirait des 28BYJ-48 avec le module UNL2003 comme driver ?

vous pouvez lire cet article vous verrez un pilotage soit par les pins directement comme fait votre code, soit par la bibliothèque Stepper

pas-a-pas-28byj-48

Me revoilà :slight_smile: J'ai passé un peu de temps à comprendre, beaucoup de temps à croire comprendre puis à réussir un peu quelque chose... Malgré tous mes échecs il m'a semblé toutefois comprendre ceci

#define in1 2
#define in2 3
#define in3 4
#define in4 5
#define in5 6
#define in6 7
#define in7 8
#define in8 9
#define in9 10
#define in10 11
#define in11 12
#define in12 13



int dl = 10; // temps entre les pas, minimum 10 ms

void setup() {
    pinMode(in1, OUTPUT);
    pinMode(in2, OUTPUT);
    pinMode(in3, OUTPUT);
    pinMode(in4, OUTPUT);
    pinMode(in5, OUTPUT);
    pinMode(in6, OUTPUT);
    pinMode(in7, OUTPUT);
    pinMode(in8, OUTPUT);
    pinMode(in9, OUTPUT);
    pinMode(in10, OUTPUT);
    pinMode(in11, OUTPUT);
    pinMode(in12, OUTPUT);
}

void loop() {
    digitalWrite(in1, HIGH); 
    digitalWrite(in2, LOW); 
    digitalWrite(in3, LOW); 
    digitalWrite(in4, HIGH);
    delay(dl);

    digitalWrite(in1, HIGH); 
    digitalWrite(in2, HIGH); 
    digitalWrite(in3, LOW); 
    digitalWrite(in4, LOW);
    delay(dl);

    digitalWrite(in1, LOW); 
    digitalWrite(in2, HIGH); 
    digitalWrite(in3, HIGH); 
    digitalWrite(in4, LOW);
    delay(dl);

    digitalWrite(in1, LOW); 
    digitalWrite(in2, LOW); 
    digitalWrite(in3, HIGH); 
    digitalWrite(in4, HIGH);
    delay(dl);

    digitalWrite(in5, HIGH); 
    digitalWrite(in6, LOW); 
    digitalWrite(in7, LOW); 
    digitalWrite(in8, HIGH);
    delay(dl);

    digitalWrite(in5, HIGH); 
    digitalWrite(in6, HIGH); 
    digitalWrite(in7, LOW); 
    digitalWrite(in8, LOW);
    delay(dl);

    digitalWrite(in5, LOW); 
    digitalWrite(in6, HIGH); 
    digitalWrite(in7, HIGH); 
    digitalWrite(in8, LOW);
    delay(dl);

    digitalWrite(in5, LOW); 
    digitalWrite(in6, LOW); 
    digitalWrite(in7, HIGH); 
    digitalWrite(in8, HIGH);
    delay(dl);    
    
    digitalWrite(in9, HIGH); 
    digitalWrite(in10, LOW); 
    digitalWrite(in11, LOW); 
    digitalWrite(in12, HIGH);
    delay(dl);

    digitalWrite(in9, HIGH); 
    digitalWrite(in10, HIGH); 
    digitalWrite(in11, LOW); 
    digitalWrite(in12, LOW);
    delay(dl);

    digitalWrite(in9, LOW); 
    digitalWrite(in10, HIGH); 
    digitalWrite(in11, HIGH); 
    digitalWrite(in12, LOW);
    delay(dl);

    digitalWrite(in9, LOW); 
    digitalWrite(in10, LOW); 
    digitalWrite(in11, HIGH); 
    digitalWrite(in12, HIGH);
    delay(dl);
    
   
}

Ainsi, on est en séquentielle (cela provoque plus de bruit) avec un avantage : les moteurs sont plus puissants et cela me convient bien, mais... impossible de leur faire faire un demi tour, je n'y arrive pas, est-il possible de le faire sans passer par une bibliothèque (j'ai aussi essayer accelstepper mais je n'ai pas saisi la différence) ? (le code est issu du lien fourni sur le moteur pap)

D'avance merci !

Avec le programme du post#1, tu était en mode demi-pas, et on perd effectivement 30% sur le couple maximum. maintenant les moteurs décrochaient-il ou pas? Si la réponse est non, on n'a pas besoin d'augmenter le couple maxi et le moteur chauffera moins.

Dans les autres programmes on est en mode pas entiers (2 phases à la fois. On est dans tous les cas en séquentiel.

Une bibliothèque ce n'est ni plus ni moins du code qui peut d'ailleurs être visible. L'intérêt est qu'avec son utilisation, on a moins de code à écrire (et surtout moins de bugs). L'inconvéniant est qu'une bibliothèque va proposer des tas de chose pour satisfaire tout le monde et sera moins performante que si on écrit le code directement.
Un avantage d'une bibliothèque est que l'on a pas à comprendre dans le détail le fonctionnement du composant. La commande d'un pas à pas est simple, ce n'est pas comme gérer une carte SD, des chronogrammes précis pour led programmables la multitude de registres pour un écran tft...
Mais on peut parfaitement se passer de bibliothèque surtout si tu n'a pas besoin des accélérations.

Les pas à pas utilisés (et aussi tous ceux que j'ai vu) on 4 commandes différentes de pas pour avancer en pas entiers:

    digitalWrite(in1, HIGH); 
    digitalWrite(in2, LOW); 
    digitalWrite(in3, LOW); 
    digitalWrite(in4, HIGH);

sera ce que je vais appeler le "pas 1 du moteur 1",

   digitalWrite(in1, HIGH); 
    digitalWrite(in2, HIGH); 
    digitalWrite(in3, LOW); 
    digitalWrite(in4, LOW);

sera le "pas 2 du moteur 1", et ainsi de suite.

En mettant de côté la petite temporisation entre chaque pas (qu'il faut mettre!), ton dernier programme faisait:
On boucle
  pas 1 du moteur 1
  pas 2 du moteur 1
  pas 3 du moteur 1
  pas 4 du moteur 1

  pas 1 du moteur 2
  pas 2 du moteur 2
  pas 3 du moteur 2
  pas 4 du moteur 2

  pas 1 du moteur 3
  pas 2 du moteur 3
  pas 3 du moteur 3
  pas 4 du moteur 3
fin de la boucle

Pour faire avancer un moteur, il faut par exemple donner les ordres: pas1, pas2, pas3, pas4, pas1,pas2...
Pour le faire avancer dans l'autre sens: pas1, pas4; pas3, pas2, pas1, pas4...
Pour lui faire faire un demi tour (les BYJ28-48 on souvent 2048 pas par tour. Pour faire un demi tour, il faut donc faire 2048/2 pas. Si on les fait par paquet de 4, il faut faire 2048/8 paquets de 4 pas.

Pour faire un demi tour pour le premier moteur, puis retour, aller, retour.... cela va donner en gros (non testé) pour loop() (le reste ne change pas):

void loop() {

  for (paquet=0; paquet< 2048/8; paquet++) { // 2048/8 fois 4 pas donnent un demi tour

      digitalWrite(in1, HIGH); // pas 1 du moteur 1
      digitalWrite(in2, LOW); 
      digitalWrite(in3, LOW); 
      digitalWrite(in4, HIGH);
      delay(dl);

      digitalWrite(in1, HIGH);  // pas 2 du moteur 1
      digitalWrite(in2, HIGH); 
      digitalWrite(in3, LOW); 
      digitalWrite(in4, LOW);
      delay(dl);

      digitalWrite(in1, LOW);  // pas 3 du moteur 1
     digitalWrite(in2, HIGH); 
      digitalWrite(in3, HIGH); 
      digitalWrite(in4, LOW);
      delay(dl);

      digitalWrite(in1, LOW);  // pas 4 du moteur 1
      digitalWrite(in2, LOW); 
      digitalWrite(in3, HIGH); 
      digitalWrite(in4, HIGH);
      delay(dl);
  }

  delay(1000); // si on veut 1 seconde d'attente pour bien distinguer l'aller et le retour

  for (paquet=0; paquet< 2048/8; paquet++) { // va dans l'autre sens

      digitalWrite(in1, HIGH); // pas 1 du moteur 1
      digitalWrite(in2, LOW); 
      digitalWrite(in3, LOW); 
      digitalWrite(in4, HIGH);
      delay(dl);

      digitalWrite(in1, LOW);  // pas 4 du moteur 1
      digitalWrite(in2, LOW); 
      digitalWrite(in3, HIGH); 
      digitalWrite(in4, HIGH);
      delay(dl);

      digitalWrite(in1, LOW);  // pas 3 du moteur 1
     digitalWrite(in2, HIGH); 
      digitalWrite(in3, HIGH); 
      digitalWrite(in4, LOW);
      delay(dl);
 
      digitalWrite(in1, HIGH);  // pas 2 du moteur 1
      digitalWrite(in2, HIGH); 
      digitalWrite(in3, LOW); 
      digitalWrite(in4, LOW);
      delay(dl);
 }

  delay(2000); // si on veut 2 secondes d'attente entre les grattages

}

Si on veut que les trois moteurs tournent ensemble en permanence, il faut faire
On boucle
  pas 1 du moteur 1
  pas 1 du moteur 2
  pas 1 du moteur 3

  pas 2 du moteur 1
  pas 2 du moteur 2
  pas 2 du moteur 3

  pas 3 du moteur 1
  pas 3 du moteur 2
  pas 3 du moteur 3

  pas 4 du moteur 1
  pas 4 du moteur 2
  pas 4 du moteur 3
fin de la boucle

Super ! Merci encore ! Pour la puissance des moteurs ça semble bon et effectivement je dois faire attention à la surchauffe. Pour la boucle je vais tester ça demain matin, je n’ai pas besoin de déclarer la variable ? Je vais me « faire les dents » en essayant la manipulation et reviens vers vous avec le résultat, encore merci pour tout ces échanges !

Pour les essais, non, mais bientôt il faudra compacter un peu le programme, ne faire des demi-tours que si nécessaire....
D'ailleurs si! il faut déclarer paquet soit avant loop, soit en utilisant:
for (word paquet=0; paquet< 2048/8; paquet++)...
J'ai mis word car le nombre est positif, mais un int convient aussi. Mais je trouve plus propre d'utiliser des entiers non signés quand les valeurs sont positives uniquement.

au fait, avez vous vraiment besoin de faire un 180° ? si vous voulez juste gratter une corde, une oscillation de 10° ou 15° (voire moins) autour de cette corde devrait suffire non? ça vous permettra de 'gratter' plus vite aussi

Bonjour à tout le monde ! Je viens de tester un nouveau code qui fonctionne avec les moteurs fonctionnant les uns après les autres (c'est un bon début mais l'objectif étant le simultané). J'ai compilé les divers propositions (je pense même commencer à saisir la logique :slight_smile: )mais lorsque j'ai essayé de modifier l'ordre des pas des moteurs afin de vouloir les mettre en séquentiel : plus rien. Les led des drivers fonctionnent, le code pour vérification est bon (ne donne aucune erreur) mais... pas d'avancée, avez-vous une idée ? Merci beaucoup !

#define in1 2
#define in2 3
#define in3 4
#define in4 5
#define in5 6
#define in6 7
#define in7 8
#define in8 9
#define in9 10
#define in10 11
#define in11 12
#define in12 13

int dl = 10; // temps entre les pas, minimum 10 ms
int paquet=0;

void setup() {
    pinMode(in1, OUTPUT);
    pinMode(in2, OUTPUT);
    pinMode(in3, OUTPUT);
    pinMode(in4, OUTPUT);
    pinMode(in5, OUTPUT);
    pinMode(in6, OUTPUT);
    pinMode(in7, OUTPUT);
    pinMode(in8, OUTPUT);
    pinMode(in9, OUTPUT);
    pinMode(in10, OUTPUT);
    pinMode(in11, OUTPUT);
    pinMode(in12, OUTPUT);
}

void loop() {

  for (paquet=0; paquet< 2048/8; paquet++) { // 2048/8 fois 4 pas donnent un demi tour

      digitalWrite(in1, HIGH); // pas 1 du moteur 1
      digitalWrite(in2, LOW); 
      digitalWrite(in3, LOW); 
      digitalWrite(in4, HIGH);
      delay(dl);

      digitalWrite(in5, HIGH); // pas 1 du moteur 2
      digitalWrite(in6, LOW); 
      digitalWrite(in7, LOW); 
      digitalWrite(in8, HIGH);
      delay(dl);

      digitalWrite(in9, HIGH); // pas 1 du moteur 3
      digitalWrite(in10, LOW); 
      digitalWrite(in11, LOW); 
      digitalWrite(in12, HIGH);
      delay(dl);
}

  for (paquet=0; paquet< 2048/8; paquet++) { // 2048/8 fois 4 pas donnent un demi tour

      digitalWrite(in1, HIGH);  // pas 2 du moteur 1
      digitalWrite(in2, HIGH); 
      digitalWrite(in3, LOW); 
      digitalWrite(in4, LOW);
      delay(dl);
      
      digitalWrite(in5, HIGH);  // pas 2 du moteur 2
      digitalWrite(in6, HIGH); 
      digitalWrite(in7, LOW); 
      digitalWrite(in8, LOW);
      delay(dl);

      digitalWrite(in9, HIGH);  // pas 2 du moteur 3
      digitalWrite(in10, HIGH); 
      digitalWrite(in11, LOW); 
      digitalWrite(in12, LOW);
      delay(dl);
}

  for (paquet=0; paquet< 2048/8; paquet++) { // 2048/8 fois 4 pas donnent un demi tour
      
      digitalWrite(in1, LOW);  // pas 3 du moteur 1
      digitalWrite(in2, HIGH); 
      digitalWrite(in3, HIGH); 
      digitalWrite(in4, LOW);
      delay(dl);

      digitalWrite(in1, LOW);  // pas 3 du moteur 2
      digitalWrite(in2, HIGH); 
      digitalWrite(in3, HIGH); 
      digitalWrite(in4, LOW);
      delay(dl);

      digitalWrite(in9, LOW);  // pas 3 du moteur 3
       digitalWrite(in10, HIGH); 
      digitalWrite(in11, HIGH); 
      digitalWrite(in12, LOW);
      delay(dl);
           
}

  for (paquet=0; paquet< 2048/8; paquet++) { // 2048/8 fois 4 pas donnent un demi tour

      digitalWrite(in1, LOW);  // pas 4 du moteur 1
      digitalWrite(in2, LOW); 
      digitalWrite(in3, HIGH); 
      digitalWrite(in4, HIGH);
      delay(dl);

      digitalWrite(in5, LOW);  // pas 4 du moteur 2
      digitalWrite(in6, LOW); 
      digitalWrite(in7, HIGH); 
      digitalWrite(in8, HIGH);
      delay(dl);

      digitalWrite(in9, LOW);  // pas 4 du moteur 3
      digitalWrite(in10, LOW); 
      digitalWrite(in11, HIGH); 
      digitalWrite(in12, HIGH);
      delay(dl);
  }
      
  delay(1000); // si on veut 1 seconde d'attente pour bien distinguer l'aller et le retour

  for (paquet=0; paquet< 2048/8; paquet++) { // va dans l'autre sens

      digitalWrite(in1, HIGH); // pas 1 du moteur 1
      digitalWrite(in2, LOW); 
      digitalWrite(in3, LOW); 
      digitalWrite(in4, HIGH);
      delay(dl);

      digitalWrite(in5, HIGH); // pas 1 du moteur 2
      digitalWrite(in6, LOW); 
      digitalWrite(in7, LOW); 
      digitalWrite(in8, HIGH);
      delay(dl);

      digitalWrite(in9, HIGH); // pas 1 du moteur 3
      digitalWrite(in10, LOW); 
      digitalWrite(in11, LOW); 
      digitalWrite(in12, HIGH);
      delay(dl);

  }

  for (paquet=0; paquet< 2048/8; paquet++) { // va dans l'autre sens

       
      digitalWrite(in1, HIGH);  // pas 2 du moteur 1
      digitalWrite(in2, HIGH); 
      digitalWrite(in3, LOW); 
      digitalWrite(in4, LOW);
      delay(dl);
  
      digitalWrite(in5, HIGH);  // pas 2 du moteur 2
      digitalWrite(in6, HIGH); 
      digitalWrite(in7, LOW); 
      digitalWrite(in8, LOW);
      delay(dl);

      digitalWrite(in9, HIGH);  // pas 2 du moteur 3
      digitalWrite(in10, HIGH); 
      digitalWrite(in11, LOW); 
      digitalWrite(in12, LOW);
      delay(dl);

}
      for (paquet=0; paquet< 2048/8; paquet++) { // va dans l'autre sens
        
      digitalWrite(in1, LOW);  // pas 3 du moteur 1
      digitalWrite(in2, HIGH); 
      digitalWrite(in3, HIGH); 
      digitalWrite(in4, LOW);
      delay(dl);

      digitalWrite(in5, LOW);  // pas 3 du moteur 2
      digitalWrite(in6, HIGH); 
      digitalWrite(in7, HIGH); 
      digitalWrite(in8, LOW);
      delay(dl);

      digitalWrite(in9, LOW);  // pas 3 du moteur 3
      digitalWrite(in10, HIGH); 
      digitalWrite(in11, HIGH); 
      digitalWrite(in12, LOW);
      delay(dl);
      
}
      for (paquet=0; paquet< 2048/8; paquet++) { // va dans l'autre sens

      digitalWrite(in1, LOW);  // pas 4 du moteur 1
      digitalWrite(in2, LOW); 
      digitalWrite(in3, HIGH); 
      digitalWrite(in4, HIGH);
      delay(dl);
      
      digitalWrite(in5, LOW);  // pas 4 du moteur 2
      digitalWrite(in6, LOW); 
      digitalWrite(in7, HIGH); 
      digitalWrite(in8, HIGH);
      delay(dl);
      
      digitalWrite(in9, LOW);  // pas 4 du moteur 3
      digitalWrite(in10, LOW); 
      digitalWrite(in11, HIGH); 
      digitalWrite(in12, HIGH);
      delay(dl);
      }         
}



      

  

Re-bonjour,

c'est pas impossible, il faudra voir ce que cela donne en demi-tour, sachant qu'il y aura 6 PAP et 2 servo il ne faudra pas trop du succession de notes sinon cela deviendra vite cacophonique :slight_smile: Je vous dirais ça ! Merci !