Problème de sens de rotation de MPAP

enash · November 22, 2022, 5:38am

Bonjour
Je dispose de 3 programmes sur arduino mega obtenu à l'aide de sujets précédents qui permettent de piloter des moteurs pas à pas différemment à travers une application sur MAI (MIT App Inventor) et pour le même montage. Dans le montage les pattes dir des drivers sont toutes reliées à la broche 4.
Le premier programme permet de faire tourner un moteur pas à pas quand on appuie sur le bouton virtuel qui lui est dédié:

#define btSerial Serial1     // Port du bluetooth
#include "AccelStepper.h"

String Incoming_value = "";

const byte enable[] = {40, 43, 45, 46, 42, 44, 47, 49, 51, 12, 11, 10};
const byte enableNombre = sizeof(enable) / sizeof(byte);

const char mpapDirReverse = 4; //Seul Dir (ligne ajoutée)

boolean MPAPRunning[11];

const bool boutonPinEtatOn = LOW;

enum mpapIndex {mpapIndex1, mpapIndex2, mpapIndex3, mpapIndex4, mpapIndex5, mpapIndex6, mpapIndex7, 
                mpapIndexRouge, mpapIndexBleu, mpapIndexJaune, mpapIndexViolet, mpapIndexGris};

const byte mpapStepPin[] = {37, 39, 41, 6, 3, 38, 36, 8, 35, 9, 7, 5};
const byte stepNombre = sizeof(mpapStepPin) / sizeof(byte);
const byte stepperDriverType = AccelStepper::DRIVER;
const byte mpapDirReversePin = 4;

//------------------------------------- Tableau de moteurs pas à pas
AccelStepper MPAP[] =
{
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex1],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex2],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex3],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex4],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex5],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex6],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex7],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexRouge],  mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexBleu],   mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexJaune],  mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexViolet], mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexGris],   mpapDirReversePin},
};
const byte nombreMPAP = sizeof MPAP / sizeof * MPAP;

long mpapNombreDeToursAtourner = 2;
long mpapNombreDePasAtourner = 200;


void setup()
{
  // put your setup code here, to run once:
  Serial.begin(115200);
  btSerial.begin(9600);

  for (int e = 0; e < enableNombre; e ++)
  {
    pinMode(enable[e], OUTPUT);
  }
  for (int m = 0; m < stepNombre; m ++)
  {
    MPAP[m].setMaxSpeed(400);
    MPAP[m].setAcceleration(500);
    MPAP[m].setEnablePin(enable[m]); //ligne ajoutée
    MPAP[m].setPinsInverted(mpapDirReversePin, false, true); //ligne modifiée
  }
}

void loop()
{
  if (btSerial.available())
  {
    Incoming_value = btSerial.readStringUntil('\n');
    Incoming_value.trim();     // Nettoyage de Incoming_value 
    Serial.println("Recu : " + Incoming_value);

    //----------------------------- MPAP1
    if (Incoming_value == "MPAP1")
    {
      MPAP[mpapIndex1].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndex1] = true;
    }
    if (Incoming_value == "nonMPAP1")
    {
      MPAP[mpapIndex1].stop();
      MPAP[mpapIndex1].setCurrentPosition(0);
      MPAP[mpapIndex1].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndex1] = false;
    }

    //----------------------------- MPAP2
    if (Incoming_value == "MPAP2")
    {
      MPAP[mpapIndex2].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndex2] = true;
    }

    if (Incoming_value == "nonMPAP2")
    {
      MPAP[mpapIndex2].stop();
      MPAP[mpapIndex2].setCurrentPosition(0);
      MPAP[mpapIndex2].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndex2] = false;
    }

    //----------------------------- MPAP3
    if (Incoming_value == "MPAP3")
    {
      MPAP[mpapIndex3].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndex3] = true;
    }

    if (Incoming_value == "nonMPAP3")
    {
      MPAP[mpapIndex3].stop();
      MPAP[mpapIndex3].setCurrentPosition(0);
      MPAP[mpapIndex3].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndex3] = false;
    }
    //----------------------------- MPAP4
    if (Incoming_value == "MPAP4")
    {
      MPAP[mpapIndex4].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndex4] = true;
    }

    if (Incoming_value == "nonMPAP4")
    {
      MPAP[mpapIndex4].stop();
      MPAP[mpapIndex4].setCurrentPosition(0);
      MPAP[mpapIndex4].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndex4] = false;
    }
    //----------------------------- MPAP5
    if (Incoming_value == "MPAP5")
    {
      MPAP[mpapIndex5].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndex5] = true;
    }

    if (Incoming_value == "nonMPAP5")
    {
      MPAP[mpapIndex5].stop();
      MPAP[mpapIndex5].setCurrentPosition(0);
      MPAP[mpapIndex5].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndex5] = false;
    }
    //----------------------------- MPAP6
    if (Incoming_value == "MPAP6")
    {
      MPAP[mpapIndex6].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndex6] = true;
    }

    if (Incoming_value == "nonMPAP6")
    {
      MPAP[mpapIndex6].stop();
      MPAP[mpapIndex6].setCurrentPosition(0);
      MPAP[mpapIndex6].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndex6] = false;
    }
    //----------------------------- MPAP7
    if (Incoming_value == "MPAP7")
    {
      MPAP[mpapIndex7].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndex7] = true;
    }

    if (Incoming_value == "nonMPAP7")
    {
      MPAP[mpapIndex7].stop();
      MPAP[mpapIndex7].setCurrentPosition(0);
      MPAP[mpapIndex7].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndex7] = false;
    }
    //----------------------------- MPAProuge
    if (Incoming_value == "MPAProuge")
    {
      MPAP[mpapIndexRouge].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndexRouge] = true;
    }

    if (Incoming_value == "nonMPAProuge")
    {
      MPAP[mpapIndexRouge].stop();
      MPAP[mpapIndexRouge].setCurrentPosition(0);
      MPAP[mpapIndexRouge].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndexRouge] = false;
    }
    //----------------------------- MPAPbleu
    if (Incoming_value == "MPAPbleu")
    {
      MPAP[mpapIndexBleu].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndexBleu] = true;
    }

    if (Incoming_value == "nonMPAPbleu")
    {
      MPAP[mpapIndexBleu].stop();
      MPAP[mpapIndexBleu].setCurrentPosition(0);
      MPAP[mpapIndexBleu].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndexBleu] = false;
    }
    //----------------------------- MPAPjaune
    if (Incoming_value == "MPAPjaune")
    {
      MPAP[mpapIndexJaune].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndexJaune] = true;
    }

    if (Incoming_value == "nonMPAPjaune")
    {
      MPAP[mpapIndexJaune].stop();
      MPAP[mpapIndexJaune].setCurrentPosition(0);
      MPAP[mpapIndexJaune].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndexJaune] = false;
    }
    //----------------------------- MPAPviolet
    if (Incoming_value == "MPAPviolet")
    {
      MPAP[mpapIndexViolet].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndexViolet] = true;
    }

    if (Incoming_value == "nonMPAPviolet")
    {
      MPAP[mpapIndexViolet].stop();
      MPAP[mpapIndexViolet].setCurrentPosition(0);
      MPAP[mpapIndexViolet].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndexViolet] = false;
    }
    //----------------------------- MPAPgris
    if (Incoming_value == "MPAPgris")
    {
      MPAP[mpapIndexGris].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndexGris] = true;
    }

    if (Incoming_value == "nonMPAPgris")
    {
      MPAP[mpapIndexGris].stop();
      MPAP[mpapIndexGris].setCurrentPosition(0);
      MPAP[mpapIndexGris].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndexGris] = false;
    }
  }

  if (MPAPRunning[mpapIndex1])
  {
    MPAP[mpapIndex1].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP 1");
    MPAP[mpapIndex1].run();
  }

  if (MPAPRunning[mpapIndex2])
  {
    MPAP[mpapIndex2].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP 2");
    MPAP[mpapIndex2].run();
  }

  if (MPAPRunning[mpapIndex3])
  {
    MPAP[mpapIndex3].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP 3");
    MPAP[mpapIndex3].run();
  }
  
  if (MPAPRunning[mpapIndex4])
  {
    MPAP[mpapIndex4].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP 4");
    MPAP[mpapIndex4].run();
  }
  
  if (MPAPRunning[mpapIndex5])
  {
    MPAP[mpapIndex5].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP 5");
    MPAP[mpapIndex5].run();
  }
  
  if (MPAPRunning[mpapIndex6])
  {
    MPAP[mpapIndex6].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP 6");
    MPAP[mpapIndex6].run();
  }
  
  if (MPAPRunning[mpapIndex7])
  {
    MPAP[mpapIndex7].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP 7");
    MPAP[mpapIndex7].run();
  }
  
  if (MPAPRunning[mpapIndexRouge])
  {
    MPAP[mpapIndexRouge].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP rouge");
    MPAP[mpapIndexRouge].run();
  }
  if (MPAPRunning[mpapIndexBleu])
  {
    MPAP[mpapIndexBleu].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP bleu");
    MPAP[mpapIndexBleu].run();
  }  
  if (MPAPRunning[mpapIndexJaune])
  {
    MPAP[mpapIndexJaune].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP jaune");
    MPAP[mpapIndexJaune].run();
  }
  if (MPAPRunning[mpapIndexViolet])
  {
    MPAP[mpapIndexViolet].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP violet");
    MPAP[mpapIndexViolet].run();
  }
  if (MPAPRunning[mpapIndexGris])
  {
    MPAP[mpapIndexGris].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP gris");
    MPAP[mpapIndexGris].run();
  }
}

avec l'application MAI suivante:
Plusieurs_moteur_mpap_a_l_appuie (2).zip (3,9 Ko)

Le deuxième permet d'allumer ou d'éteindre des relais et de mettre en marche ou d'arrêter un moteur à courant continue:

const int relaisPin[] = {22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34};     // Liste des pin des relais
const int relaisNombre = sizeof(relaisPin) / sizeof(int);     // Calcul du nombre de relais
const int relaisEtatOn = HIGH;     // Etat pour faire tirer le relais

String Incoming_value;     // Chaîne reçue de App Inventor via Bluetooth

void setup()
{
  //--------------------------------- Serial 1 Rx = 19 Tx = 18
  Serial1.begin(9600);
  Serial1.setTimeout(50);     // Pour fin des commandes depuis Bluetooth

  for (int r = 0; r < relaisNombre; r ++)     // Initialisation des pin des relais
  {
    pinMode(relaisPin[r], OUTPUT);
    digitalWrite(relaisPin[r], !relaisEtatOn);     // Relais à OFF
  }
}

void loop()
{
  if(Serial1.available() > 0)
  {
    Incoming_value = Serial1.readString();
    Serial.print(Incoming_value);
    Serial.print("\n");
    //moteur à courant continu
    if(Incoming_value == "mcc")  
    digitalWrite(relaisPin[12], relaisEtatOn);
    else if(Incoming_value == "nonMcc")
    digitalWrite(relaisPin[12], !relaisEtatOn);
    //rouge
    if(Incoming_value == "rouge")               // ON 1
    digitalWrite(relaisPin[11], relaisEtatOn);
    else if(Incoming_value == "nonRouge")
    digitalWrite(relaisPin[11], !relaisEtatOn);
    //jaune
    else if(Incoming_value == "jaune")               // ON 2
    digitalWrite(relaisPin[10], relaisEtatOn);
    else if(Incoming_value == "nonJaune")
    digitalWrite(relaisPin[10], !relaisEtatOn);
    //bleu
    else if(Incoming_value == "bleu")               // ON 3
    digitalWrite(relaisPin[9], relaisEtatOn);
    else if(Incoming_value == "nonBleu")
    digitalWrite(relaisPin[9], !relaisEtatOn);
    //gris
    else if(Incoming_value == "gris")               // ON 4
    digitalWrite(relaisPin[8], relaisEtatOn);
    else if(Incoming_value == "nonGris")
    digitalWrite(relaisPin[8], !relaisEtatOn);
    //violet
    else if(Incoming_value == "violet")               // ON 5
    digitalWrite(relaisPin[7], relaisEtatOn);
    else if(Incoming_value == "nonViolet")
    digitalWrite(relaisPin[7], !relaisEtatOn);
    //ing1
    else if(Incoming_value == "ing1")               // ON 6
    digitalWrite(relaisPin[6], relaisEtatOn);
    else if(Incoming_value == "nonIng1")
    digitalWrite(relaisPin[6], !relaisEtatOn);
    //ing2
    else if(Incoming_value == "ing2")               // ON 7
    digitalWrite(relaisPin[5], relaisEtatOn);
    else if(Incoming_value == "nonIng2")
    digitalWrite(relaisPin[5], !relaisEtatOn);
    //ing3
    else if(Incoming_value == "ing3")               // ON 8
    digitalWrite(relaisPin[4], relaisEtatOn);
    else if(Incoming_value == "nonIng3")
    digitalWrite(relaisPin[4], !relaisEtatOn);
    //ing4
    else if(Incoming_value == "ing4")               // ON 9
    digitalWrite(relaisPin[3], relaisEtatOn);
    else if(Incoming_value == "nonIng4")
    digitalWrite(relaisPin[3], !relaisEtatOn);
    //ing5
    else if(Incoming_value == "ing5")               // ON 10
    digitalWrite(relaisPin[2], relaisEtatOn);
    else if(Incoming_value == "nonIng5")
    digitalWrite(relaisPin[2], !relaisEtatOn);
    //ing6
    else if(Incoming_value == "ing6")               // ON 11
    digitalWrite(relaisPin[1], relaisEtatOn);
    else if(Incoming_value == "nonIng6")
    digitalWrite(relaisPin[1], !relaisEtatOn);
    //ing7
    else if(Incoming_value == "ing7")               // ON 12
    digitalWrite(relaisPin[0], relaisEtatOn);
    else if(Incoming_value == "nonIng7")
    digitalWrite(relaisPin[0], !relaisEtatOn);
  }
}

à l'aide de l'application suivante:
Relais_B_avec_MCC.zip (4,2 Ko)

Et enfin le troisième permet de faire tourner en même temps un groupe de moteurs pas à pas dans un sens ou dans l'autre ou bien de les arrêter:

#define btSerial Serial1    
#define CONTINUE 0x7FFF
#include "AccelStepper.h"

String Incoming_value = "";

const byte enable[] = {40, 43, 45, 46, 42, 44, 47, 49, 51, 12, 11, 10};
const byte enableNombre = sizeof(enable) / sizeof(byte);

//int CONTINUE = 32767;

enum mpapIndex {mpapIndex1, mpapIndex2, mpapIndex3, mpapIndex4, mpapIndex5, mpapIndex6, mpapIndex7, 
                mpapIndexRouge, mpapIndexBleu, mpapIndexJaune, mpapIndexViolet, mpapIndexGris};

const byte mpapStepPin[] = {37, 39, 41, 6, 3, 38, 36, 8, 35, 9, 7, 5};
const byte stepNombre = sizeof(mpapStepPin) / sizeof(byte);
const byte stepperDriverType = AccelStepper::DRIVER;
const byte mpapDirReversePin = 4;

//------------------------------------- Tableau de moteurs pas à pas
AccelStepper MPAP[] =
{
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex1],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex2],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex3],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex4],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex5],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex6],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex7],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexRouge],  mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexBleu],   mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexJaune],  mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexViolet], mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexGris],   mpapDirReversePin},
};
const byte nombreMPAP = sizeof MPAP / sizeof * MPAP;


void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  btSerial.begin(9600);

  for (int e = 0; e < enableNombre; e ++)
  {
    pinMode(enable[e], OUTPUT);
  }
  for (int m = 0; m < stepNombre; m ++)
  {
    MPAP[m].setMaxSpeed(400);
    MPAP[m].setAcceleration(500);
    MPAP[m].setEnablePin(enable[m]); //ligne ajoutée
    MPAP[m].setPinsInverted(mpapDirReversePin, false, true); //ligne modifiée
  }
}

void loop() {
  // put your main code here, to run repeatedly:
  if (btSerial.available())
  {
    Incoming_value = btSerial.readStringUntil('\n');
    Incoming_value.trim();     // Nettoyage de Incoming_value 
    Serial.println("Recu : " + Incoming_value);
    if (Incoming_value == "marcheAv")
    {
      for (int y = 0; y < nombreMPAP; y ++)
      {
        MPAP[y].enableOutputs();
        MPAP[y].move(CONTINUE);
      }
    }
    if (Incoming_value == "marcheAr")
    {
      for (int y = 0; y < nombreMPAP; y ++)
      {
        MPAP[y].enableOutputs();
        MPAP[y].move(-CONTINUE);
      }
    }
    if (Incoming_value == "stopMoteurs")
    {
      for (int y = 0; y < nombreMPAP; y ++)
      {
        MPAP[y].stop();
        MPAP[y].disableOutputs(); 
      } 
    }
  }
  for (int y = 0; y < nombreMPAP; y ++)
  {
    MPAP[y].run(); 
  } 
}

à l'aide de l'application suivante:
Marche_AvAr_fini.zip (2,1 Ko)

J'aimerai les associés afin d'avoir un seul programme qui fonctionne avec les trois applications mais un problème est survenu lorsque je les ai combinés de la manière suivante:

#define btSerial Serial1
#define CONTINUE 0x7FFF    
#include "AccelStepper.h"

const int relaisPin[] = {22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34};     // Liste des pin des relais
const int relaisNombre = sizeof(relaisPin) / sizeof(int);     // Calcul du nombre de relais
const int relaisEtatOn = HIGH;     // Etat pour faire tirer le relais

String Incoming_value = "";

const byte enable[] = {40, 43, 45, 46, 42, 44, 47, 49, 51, 12, 11, 10};
const byte enableNombre = sizeof(enable) / sizeof(byte);

//int CONTINUE = 32767;

enum mpapIndex {mpapIndex1, mpapIndex2, mpapIndex3, mpapIndex4, mpapIndex5, mpapIndex6, mpapIndex7, 
                mpapIndexRouge, mpapIndexBleu, mpapIndexJaune, mpapIndexViolet, mpapIndexGris};

const byte mpapStepPin[] = {37, 39, 41, 6, 3, 38, 36, 8, 35, 9, 7, 5};
const byte stepNombre = sizeof(mpapStepPin) / sizeof(byte);
const byte stepperDriverType = AccelStepper::DRIVER;
const byte mpapDirReversePin = 4;
boolean MPAPRunning[11];

//------------------------------------- Tableau de moteurs pas à pas
AccelStepper MPAP[] =
{
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex1],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex2],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex3],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex4],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex5],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex6],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex7],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexRouge],  mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexBleu],   mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexJaune],  mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexViolet], mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexGris],   mpapDirReversePin},
};
const byte nombreMPAP = sizeof MPAP / sizeof * MPAP;

long mpapNombreDeToursAtourner = 2;
long mpapNombreDePasAtourner = 200;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  Serial1.setTimeout(50);     // Pour fin des commandes depuis Bluetooth
  btSerial.begin(9600);
  for (int r = 0; r < relaisNombre; r ++)     // Initialisation des pin des relais
  {
    pinMode(relaisPin[r], OUTPUT);
    digitalWrite(relaisPin[r], !relaisEtatOn);     // Relais à OFF
  }
  for (int e = 0; e < enableNombre; e ++)
  {
    pinMode(enable[e], OUTPUT);
  }
  for (int m = 0; m < stepNombre; m ++)
  {
    MPAP[m].setMaxSpeed(400);
    MPAP[m].setAcceleration(500);
    MPAP[m].setEnablePin(enable[m]); //ligne ajoutée
    MPAP[m].setPinsInverted(mpapDirReversePin, false, true); //ligne modifiée
  }
}

void loop() {
  // put your main code here, to run repeatedly:
  if (btSerial.available())
  {
    Incoming_value = btSerial.readStringUntil('\n');
    Incoming_value.trim();     // Nettoyage de Incoming_value 
    Serial.println("Recu : " + Incoming_value);
    //----------------------------- MPAP1
    if (Incoming_value == "MPAP1")
    {
      MPAP[mpapIndex1].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndex1] = true;
    }
    else if (Incoming_value == "nonMPAP1")
    {
      MPAP[mpapIndex1].stop();
      MPAP[mpapIndex1].setCurrentPosition(0);
      MPAP[mpapIndex1].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndex1] = false;
    }

    //----------------------------- MPAP2
    else if (Incoming_value == "MPAP2")
    {
      MPAP[mpapIndex2].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndex2] = true;
    }

    else if (Incoming_value == "nonMPAP2")
    {
      MPAP[mpapIndex2].stop();
      MPAP[mpapIndex2].setCurrentPosition(0);
      MPAP[mpapIndex2].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndex2] = false;
    }

    //----------------------------- MPAP3
    else if (Incoming_value == "MPAP3")
    {
      MPAP[mpapIndex3].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndex3] = true;
    }

    else if (Incoming_value == "nonMPAP3")
    {
      MPAP[mpapIndex3].stop();
      MPAP[mpapIndex3].setCurrentPosition(0);
      MPAP[mpapIndex3].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndex3] = false;
    }
    //----------------------------- MPAP4
    else if (Incoming_value == "MPAP4")
    {
      MPAP[mpapIndex4].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndex4] = true;
    }

    else if (Incoming_value == "nonMPAP4")
    {
      MPAP[mpapIndex4].stop();
      MPAP[mpapIndex4].setCurrentPosition(0);
      MPAP[mpapIndex4].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndex4] = false;
    }
    //----------------------------- MPAP5
    else if (Incoming_value == "MPAP5")
    {
      MPAP[mpapIndex5].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndex5] = true;
    }

    else if (Incoming_value == "nonMPAP5")
    {
      MPAP[mpapIndex5].stop();
      MPAP[mpapIndex5].setCurrentPosition(0);
      MPAP[mpapIndex5].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndex5] = false;
    }
    //----------------------------- MPAP6
    else if (Incoming_value == "MPAP6")
    {
      MPAP[mpapIndex6].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndex6] = true;
    }

    else if (Incoming_value == "nonMPAP6")
    {
      MPAP[mpapIndex6].stop();
      MPAP[mpapIndex6].setCurrentPosition(0);
      MPAP[mpapIndex6].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndex6] = false;
    }
    //----------------------------- MPAP7
    else if (Incoming_value == "MPAP7")
    {
      MPAP[mpapIndex7].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndex7] = true;
    }

    else if (Incoming_value == "nonMPAP7")
    {
      MPAP[mpapIndex7].stop();
      MPAP[mpapIndex7].setCurrentPosition(0);
      MPAP[mpapIndex7].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndex7] = false;
    }
    //----------------------------- MPAProuge
    else if (Incoming_value == "MPAProuge")
    {
      MPAP[mpapIndexRouge].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndexRouge] = true;
    }

    else if (Incoming_value == "nonMPAProuge")
    {
      MPAP[mpapIndexRouge].stop();
      MPAP[mpapIndexRouge].setCurrentPosition(0);
      MPAP[mpapIndexRouge].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndexRouge] = false;
    }
    //----------------------------- MPAPbleu
    else if (Incoming_value == "MPAPbleu")
    {
      MPAP[mpapIndexBleu].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndexBleu] = true;
    }

    else if (Incoming_value == "nonMPAPbleu")
    {
      MPAP[mpapIndexBleu].stop();
      MPAP[mpapIndexBleu].setCurrentPosition(0);
      MPAP[mpapIndexBleu].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndexBleu] = false;
    }
    //----------------------------- MPAPjaune
    else if (Incoming_value == "MPAPjaune")
    {
      MPAP[mpapIndexJaune].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndexJaune] = true;
    }

    else if (Incoming_value == "nonMPAPjaune")
    {
      MPAP[mpapIndexJaune].stop();
      MPAP[mpapIndexJaune].setCurrentPosition(0);
      MPAP[mpapIndexJaune].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndexJaune] = false;
    }
    //----------------------------- MPAPviolet
    else if (Incoming_value == "MPAPviolet")
    {
      MPAP[mpapIndexViolet].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndexViolet] = true;
    }

    else if (Incoming_value == "nonMPAPviolet")
    {
      MPAP[mpapIndexViolet].stop();
      MPAP[mpapIndexViolet].setCurrentPosition(0);
      MPAP[mpapIndexViolet].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndexViolet] = false;
    }
    //----------------------------- MPAPgris
    else if (Incoming_value == "MPAPgris")
    {
      MPAP[mpapIndexGris].enableOutputs();     // Activer les signaux du MPAP
      MPAPRunning[mpapIndexGris] = true;
    }

    else if (Incoming_value == "nonMPAPgris")
    {
      MPAP[mpapIndexGris].stop();
      MPAP[mpapIndexGris].setCurrentPosition(0);
      MPAP[mpapIndexGris].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      MPAPRunning[mpapIndexGris] = false;
    }
    //moteur à courant continu
    else if(Incoming_value == "mcc")  
    digitalWrite(relaisPin[12], relaisEtatOn);
    else if(Incoming_value == "nonMcc")
    digitalWrite(relaisPin[12], !relaisEtatOn);
    //rouge
    else if(Incoming_value == "rouge")               // ON 1
    digitalWrite(relaisPin[11], relaisEtatOn);
    else if(Incoming_value == "nonRouge")
    digitalWrite(relaisPin[11], !relaisEtatOn);
    //jaune
    else if(Incoming_value == "jaune")               // ON 2
    digitalWrite(relaisPin[10], relaisEtatOn);
    else if(Incoming_value == "nonJaune")
    digitalWrite(relaisPin[10], !relaisEtatOn);
    //bleu
    else if(Incoming_value == "bleu")               // ON 3
    digitalWrite(relaisPin[9], relaisEtatOn);
    else if(Incoming_value == "nonBleu")
    digitalWrite(relaisPin[9], !relaisEtatOn);
    //gris
    else if(Incoming_value == "gris")               // ON 4
    digitalWrite(relaisPin[8], relaisEtatOn);
    else if(Incoming_value == "nonGris")
    digitalWrite(relaisPin[8], !relaisEtatOn);
    //violet
    else if(Incoming_value == "violet")               // ON 5
    digitalWrite(relaisPin[7], relaisEtatOn);
    else if(Incoming_value == "nonViolet")
    digitalWrite(relaisPin[7], !relaisEtatOn);
    //ing1
    else if(Incoming_value == "ing1")               // ON 6
    digitalWrite(relaisPin[6], relaisEtatOn);
    else if(Incoming_value == "nonIng1")
    digitalWrite(relaisPin[6], !relaisEtatOn);
    //ing2
    else if(Incoming_value == "ing2")               // ON 7
    digitalWrite(relaisPin[5], relaisEtatOn);
    else if(Incoming_value == "nonIng2")
    digitalWrite(relaisPin[5], !relaisEtatOn);
    //ing3
    else if(Incoming_value == "ing3")               // ON 8
    digitalWrite(relaisPin[4], relaisEtatOn);
    else if(Incoming_value == "nonIng3")
    digitalWrite(relaisPin[4], !relaisEtatOn);
    //ing4
    else if(Incoming_value == "ing4")               // ON 9
    digitalWrite(relaisPin[3], relaisEtatOn);
    else if(Incoming_value == "nonIng4")
    digitalWrite(relaisPin[3], !relaisEtatOn);
    //ing5
    else if(Incoming_value == "ing5")               // ON 10
    digitalWrite(relaisPin[2], relaisEtatOn);
    else if(Incoming_value == "nonIng5")
    digitalWrite(relaisPin[2], !relaisEtatOn);
    //ing6
    else if(Incoming_value == "ing6")               // ON 11
    digitalWrite(relaisPin[1], relaisEtatOn);
    else if(Incoming_value == "nonIng6")
    digitalWrite(relaisPin[1], !relaisEtatOn);
    //ing7
    else if(Incoming_value == "ing7")               // ON 12
    digitalWrite(relaisPin[0], relaisEtatOn);
    else if(Incoming_value == "nonIng7")
    digitalWrite(relaisPin[0], !relaisEtatOn);
    else if (Incoming_value == "marcheAv")
    {
      for (int y = 0; y < nombreMPAP; y ++)
      {
        MPAP[y].enableOutputs();
        MPAP[y].move(CONTINUE);
      }
    }
    else if (Incoming_value == "marcheAr")
    {
      for (int y = 0; y < nombreMPAP; y ++)
      {
        MPAP[y].enableOutputs();
        MPAP[y].move(-CONTINUE);
      }
    }
    else if (Incoming_value == "stopMoteurs")
    {
      for (int y = 0; y < nombreMPAP; y ++)
      {
        MPAP[y].stop();
        MPAP[y].disableOutputs(); 
      } 
    }
  }
  if (MPAPRunning[mpapIndex1])
  {
    MPAP[mpapIndex1].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP 1");
    MPAP[mpapIndex1].run();
  }

  if (MPAPRunning[mpapIndex2])
  {
    MPAP[mpapIndex2].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP 2");
    MPAP[mpapIndex2].run();
  }

  if (MPAPRunning[mpapIndex3])
  {
    MPAP[mpapIndex3].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP 3");
    MPAP[mpapIndex3].run();
  }
  
  if (MPAPRunning[mpapIndex4])
  {
    MPAP[mpapIndex4].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP 4");
    MPAP[mpapIndex4].run();
  }
  
  if (MPAPRunning[mpapIndex5])
  {
    MPAP[mpapIndex5].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP 5");
    MPAP[mpapIndex5].run();
  }
  
  if (MPAPRunning[mpapIndex6])
  {
    MPAP[mpapIndex6].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP 6");
    MPAP[mpapIndex6].run();
  }
  
  if (MPAPRunning[mpapIndex7])
  {
    MPAP[mpapIndex7].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP 7");
    MPAP[mpapIndex7].run();
  }
  
  if (MPAPRunning[mpapIndexRouge])
  {
    MPAP[mpapIndexRouge].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP rouge");
    MPAP[mpapIndexRouge].run();
  }
  if (MPAPRunning[mpapIndexBleu])
  {
    MPAP[mpapIndexBleu].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP bleu");
    MPAP[mpapIndexBleu].run();
  }  
  if (MPAPRunning[mpapIndexJaune])
  {
    MPAP[mpapIndexJaune].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP jaune");
    MPAP[mpapIndexJaune].run();
  }
  if (MPAPRunning[mpapIndexViolet])
  {
    MPAP[mpapIndexViolet].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP violet");
    MPAP[mpapIndexViolet].run();
  }
  if (MPAPRunning[mpapIndexGris])
  {
    MPAP[mpapIndexGris].move(mpapNombreDePasAtourner);
    //Serial.println("MPAP gris");
    MPAP[mpapIndexGris].run();
  }
  for (int y = 0; y < nombreMPAP; y ++)
  {
    MPAP[y].run(); 
  } 
}

quand je veux faire tourner les moteurs en même temps en marche arrière avec l'application prévu à cet effet j'ai des moteurs qui continuent de tourner en marche avant alors qu'avec le programme séparé les moteurs tournent bien comme voulu. Quelqu'un aurait-il une idée de la raison de ce disfonctionnement ?

Cordialement

J-M-L · November 22, 2022, 7:38am

quand vous recevez la commande marcheAr vous donnez comme ordre à tous les moteurs d'aller à la position -CONTINUE avec cette boucle.

      for (int y = 0; y < nombreMPAP; y ++)
      {
        MPAP[y].enableOutputs();
        MPAP[y].move(-CONTINUE);
      }

mais une fois sorti du

  if (btSerial.available())
  {

vous testez pour tous les moteurs s'ils tournent

  if (MPAPRunning[xxx])
  {
    MPAP[xxx].move(mpapNombreDePasAtourner);
    //Serial.println("xxx");
    MPAP[xxx].run();
  }

donc vous leur donnez une nouvelle destination mpapNombreDePasAtourner

➜ si vous avez utilisé la fonction qui commande les moteurs et qui met à jour les booléens MPAPRunning[xxx] alors ils repartiront de l'avant

il faudrait repenser le code et les commandes pour que ce soit homogène. sans doute vous débarrasser des booléens (et en profiter aussi pour utiliser des tableaux car il y a énormément de code répété)

enash · November 23, 2022, 1:40am

Bonjour
J'ai enlevé les booléens et certaines fonctions, déplacer leurs instructions plus haut pour essayer le programme suivant:

#define btSerial Serial1
#define CONTINUE 0x7FFF    
#include "AccelStepper.h"

const int relaisPin[] = {22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34};     // Liste des pin des relais
const int relaisNombre = sizeof(relaisPin) / sizeof(int);     // Calcul du nombre de relais
const int relaisEtatOn = HIGH;     // Etat pour faire tirer le relais

String Incoming_value = "";

const byte enable[] = {40, 43, 45, 46, 42, 44, 47, 49, 51, 12, 11, 10};
const byte enableNombre = sizeof(enable) / sizeof(byte);

//int CONTINUE = 32767;

enum mpapIndex {mpapIndex1, mpapIndex2, mpapIndex3, mpapIndex4, mpapIndex5, mpapIndex6, mpapIndex7, 
                mpapIndexRouge, mpapIndexBleu, mpapIndexJaune, mpapIndexViolet, mpapIndexGris};

const byte mpapStepPin[] = {37, 39, 41, 6, 3, 38, 36, 8, 35, 9, 7, 5};
const byte stepNombre = sizeof(mpapStepPin) / sizeof(byte);
const byte stepperDriverType = AccelStepper::DRIVER;
const byte mpapDirReversePin = 4;
//boolean MPAPRunning[11];

//------------------------------------- Tableau de moteurs pas à pas
AccelStepper MPAP[] =
{
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex1],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex2],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex3],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex4],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex5],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex6],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndex7],      mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexRouge],  mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexBleu],   mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexJaune],  mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexViolet], mpapDirReversePin},
  AccelStepper {stepperDriverType, mpapStepPin[mpapIndexGris],   mpapDirReversePin},
};
const byte nombreMPAP = sizeof MPAP / sizeof * MPAP;

long mpapNombreDeToursAtourner = 2;
long mpapNombreDePasAtourner = 200;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  Serial1.setTimeout(50);     // Pour fin des commandes depuis Bluetooth
  btSerial.begin(9600);
  for (int r = 0; r < relaisNombre; r ++)     // Initialisation des pin des relais
  {
    pinMode(relaisPin[r], OUTPUT);
    digitalWrite(relaisPin[r], !relaisEtatOn);     // Relais à OFF
  }
  for (int e = 0; e < enableNombre; e ++)
  {
    pinMode(enable[e], OUTPUT);
  }
  for (int m = 0; m < stepNombre; m ++)
  {
    MPAP[m].setMaxSpeed(400);
    MPAP[m].setAcceleration(500);
    MPAP[m].setEnablePin(enable[m]); //ligne ajoutée
    MPAP[m].setPinsInverted(mpapDirReversePin, false, true); //ligne modifiée
  }
}

void loop() {
  // put your main code here, to run repeatedly:
  if (btSerial.available())
  {
    Incoming_value = btSerial.readStringUntil('\n');
    Incoming_value.trim();     // Nettoyage de Incoming_value 
    Serial.println("Recu : " + Incoming_value);
    //----------------------------- MPAP1
    if (Incoming_value == "MPAP1")
    {
      MPAP[mpapIndex1].enableOutputs();     // Activer les signaux du MPAP
      MPAP[mpapIndex1].move(mpapNombreDePasAtourner);
      MPAP[mpapIndex1].run();
      //MPAPRunning[mpapIndex1] = true;
    }
    else if (Incoming_value == "nonMPAP1")
    {
      MPAP[mpapIndex1].stop();
      MPAP[mpapIndex1].setCurrentPosition(0);
      MPAP[mpapIndex1].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      //MPAPRunning[mpapIndex1] = false;
    }

    //----------------------------- MPAP2
    else if (Incoming_value == "MPAP2")
    {
      MPAP[mpapIndex2].enableOutputs();     // Activer les signaux du MPAP
      MPAP[mpapIndex2].move(mpapNombreDePasAtourner);
      MPAP[mpapIndex2].run();
      //MPAPRunning[mpapIndex2] = true;
    }

    else if (Incoming_value == "nonMPAP2")
    {
      MPAP[mpapIndex2].stop();
      MPAP[mpapIndex2].setCurrentPosition(0);
      MPAP[mpapIndex2].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      //MPAPRunning[mpapIndex2] = false;
    }

    //----------------------------- MPAP3
    else if (Incoming_value == "MPAP3")
    {
      MPAP[mpapIndex3].enableOutputs();     // Activer les signaux du MPAP
      MPAP[mpapIndex3].move(mpapNombreDePasAtourner);
      MPAP[mpapIndex3].run();
      //MPAPRunning[mpapIndex3] = true;
    }

    else if (Incoming_value == "nonMPAP3")
    {
      MPAP[mpapIndex3].stop();
      MPAP[mpapIndex3].setCurrentPosition(0);
      MPAP[mpapIndex3].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      //MPAPRunning[mpapIndex3] = false;
    }
    //----------------------------- MPAP4
    else if (Incoming_value == "MPAP4")
    {
      MPAP[mpapIndex4].enableOutputs();     // Activer les signaux du MPAP
      MPAP[mpapIndex4].move(mpapNombreDePasAtourner);
      MPAP[mpapIndex4].run();
      //MPAPRunning[mpapIndex4] = true;
    }

    else if (Incoming_value == "nonMPAP4")
    {
      MPAP[mpapIndex4].stop();
      MPAP[mpapIndex4].setCurrentPosition(0);
      MPAP[mpapIndex4].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      //MPAPRunning[mpapIndex4] = false;
    }
    //----------------------------- MPAP5
    else if (Incoming_value == "MPAP5")
    {
      MPAP[mpapIndex5].enableOutputs();     // Activer les signaux du MPAP
      MPAP[mpapIndex5].move(mpapNombreDePasAtourner);
      MPAP[mpapIndex5].run();
      //MPAPRunning[mpapIndex5] = true;
    }

    else if (Incoming_value == "nonMPAP5")
    {
      MPAP[mpapIndex5].stop();
      MPAP[mpapIndex5].setCurrentPosition(0);
      MPAP[mpapIndex5].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      //MPAPRunning[mpapIndex5] = false;
    }
    //----------------------------- MPAP6
    else if (Incoming_value == "MPAP6")
    {
      MPAP[mpapIndex6].enableOutputs();     // Activer les signaux du MPAP
      MPAP[mpapIndex6].move(mpapNombreDePasAtourner);
      MPAP[mpapIndex6].run();
      //MPAPRunning[mpapIndex6] = true;
    }

    else if (Incoming_value == "nonMPAP6")
    {
      MPAP[mpapIndex6].stop();
      MPAP[mpapIndex6].setCurrentPosition(0);
      MPAP[mpapIndex6].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      //MPAPRunning[mpapIndex6] = false;
    }
    //----------------------------- MPAP7
    else if (Incoming_value == "MPAP7")
    {
      MPAP[mpapIndex7].enableOutputs();     // Activer les signaux du MPAP
      MPAP[mpapIndex7].move(mpapNombreDePasAtourner);
      MPAP[mpapIndex7].run();
      //MPAPRunning[mpapIndex7] = true;
    }

    else if (Incoming_value == "nonMPAP7")
    {
      MPAP[mpapIndex7].stop();
      MPAP[mpapIndex7].setCurrentPosition(0);
      MPAP[mpapIndex7].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      //MPAPRunning[mpapIndex7] = false;
    }
    //----------------------------- MPAProuge
    else if (Incoming_value == "MPAProuge")
    {
      MPAP[mpapIndexRouge].enableOutputs();     // Activer les signaux du MPAP
      MPAP[mpapIndexRouge].move(mpapNombreDePasAtourner);
      MPAP[mpapIndexRouge].run();
      //MPAPRunning[mpapIndexRouge] = true;
    }

    else if (Incoming_value == "nonMPAProuge")
    {
      MPAP[mpapIndexRouge].stop();
      MPAP[mpapIndexRouge].setCurrentPosition(0);
      MPAP[mpapIndexRouge].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      //MPAPRunning[mpapIndexRouge] = false;
    }
    //----------------------------- MPAPbleu
    else if (Incoming_value == "MPAPbleu")
    {
      MPAP[mpapIndexBleu].enableOutputs();     // Activer les signaux du MPAP
      MPAP[mpapIndexBleu].move(mpapNombreDePasAtourner);
      MPAP[mpapIndexBleu].run();
      //MPAPRunning[mpapIndexBleu] = true;
    }

    else if (Incoming_value == "nonMPAPbleu")
    {
      MPAP[mpapIndexBleu].stop();
      MPAP[mpapIndexBleu].setCurrentPosition(0);
      MPAP[mpapIndexBleu].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      //MPAPRunning[mpapIndexBleu] = false;
    }
    //----------------------------- MPAPjaune
    else if (Incoming_value == "MPAPjaune")
    {
      MPAP[mpapIndexJaune].enableOutputs();     // Activer les signaux du MPAP
      MPAP[mpapIndexJaune].move(mpapNombreDePasAtourner);
      MPAP[mpapIndexJaune].run();
      //MPAPRunning[mpapIndexJaune] = true;
    }

    else if (Incoming_value == "nonMPAPjaune")
    {
      MPAP[mpapIndexJaune].stop();
      MPAP[mpapIndexJaune].setCurrentPosition(0);
      MPAP[mpapIndexJaune].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      //MPAPRunning[mpapIndexJaune] = false;
    }
    //----------------------------- MPAPviolet
    else if (Incoming_value == "MPAPviolet")
    {
      MPAP[mpapIndexViolet].enableOutputs();     // Activer les signaux du MPAP
      MPAP[mpapIndexViolet].move(mpapNombreDePasAtourner);
      MPAP[mpapIndexViolet].run();
      //MPAPRunning[mpapIndexViolet] = true;
    }

    else if (Incoming_value == "nonMPAPviolet")
    {
      MPAP[mpapIndexViolet].stop();
      MPAP[mpapIndexViolet].setCurrentPosition(0);
      MPAP[mpapIndexViolet].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      //MPAPRunning[mpapIndexViolet] = false;
    }
    //----------------------------- MPAPgris
    else if (Incoming_value == "MPAPgris")
    {
      MPAP[mpapIndexGris].enableOutputs();     // Activer les signaux du MPAP
      MPAP[mpapIndexGris].move(mpapNombreDePasAtourner);
      MPAP[mpapIndexGris].run();
      //MPAPRunning[mpapIndexGris] = true;
    }

    else if (Incoming_value == "nonMPAPgris")
    {
      MPAP[mpapIndexGris].stop();
      MPAP[mpapIndexGris].setCurrentPosition(0);
      MPAP[mpapIndexGris].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
      //MPAPRunning[mpapIndexGris] = false;
    }
    //moteur à courant continu
    else if(Incoming_value == "mcc")  
    digitalWrite(relaisPin[12], relaisEtatOn);
    else if(Incoming_value == "nonMcc")
    digitalWrite(relaisPin[12], !relaisEtatOn);
    //rouge
    else if(Incoming_value == "rouge")               // ON 1
    digitalWrite(relaisPin[11], relaisEtatOn);
    else if(Incoming_value == "nonRouge")
    digitalWrite(relaisPin[11], !relaisEtatOn);
    //jaune
    else if(Incoming_value == "jaune")               // ON 2
    digitalWrite(relaisPin[10], relaisEtatOn);
    else if(Incoming_value == "nonJaune")
    digitalWrite(relaisPin[10], !relaisEtatOn);
    //bleu
    else if(Incoming_value == "bleu")               // ON 3
    digitalWrite(relaisPin[9], relaisEtatOn);
    else if(Incoming_value == "nonBleu")
    digitalWrite(relaisPin[9], !relaisEtatOn);
    //gris
    else if(Incoming_value == "gris")               // ON 4
    digitalWrite(relaisPin[8], relaisEtatOn);
    else if(Incoming_value == "nonGris")
    digitalWrite(relaisPin[8], !relaisEtatOn);
    //violet
    else if(Incoming_value == "violet")               // ON 5
    digitalWrite(relaisPin[7], relaisEtatOn);
    else if(Incoming_value == "nonViolet")
    digitalWrite(relaisPin[7], !relaisEtatOn);
    //ing1
    else if(Incoming_value == "ing1")               // ON 6
    digitalWrite(relaisPin[6], relaisEtatOn);
    else if(Incoming_value == "nonIng1")
    digitalWrite(relaisPin[6], !relaisEtatOn);
    //ing2
    else if(Incoming_value == "ing2")               // ON 7
    digitalWrite(relaisPin[5], relaisEtatOn);
    else if(Incoming_value == "nonIng2")
    digitalWrite(relaisPin[5], !relaisEtatOn);
    //ing3
    else if(Incoming_value == "ing3")               // ON 8
    digitalWrite(relaisPin[4], relaisEtatOn);
    else if(Incoming_value == "nonIng3")
    digitalWrite(relaisPin[4], !relaisEtatOn);
    //ing4
    else if(Incoming_value == "ing4")               // ON 9
    digitalWrite(relaisPin[3], relaisEtatOn);
    else if(Incoming_value == "nonIng4")
    digitalWrite(relaisPin[3], !relaisEtatOn);
    //ing5
    else if(Incoming_value == "ing5")               // ON 10
    digitalWrite(relaisPin[2], relaisEtatOn);
    else if(Incoming_value == "nonIng5")
    digitalWrite(relaisPin[2], !relaisEtatOn);
    //ing6
    else if(Incoming_value == "ing6")               // ON 11
    digitalWrite(relaisPin[1], relaisEtatOn);
    else if(Incoming_value == "nonIng6")
    digitalWrite(relaisPin[1], !relaisEtatOn);
    //ing7
    else if(Incoming_value == "ing7")               // ON 12
    digitalWrite(relaisPin[0], relaisEtatOn);
    else if(Incoming_value == "nonIng7")
    digitalWrite(relaisPin[0], !relaisEtatOn);
    else if (Incoming_value == "marcheAv")
    {
      for (int y = 0; y < nombreMPAP; y ++)
      {
        MPAP[y].enableOutputs();
        MPAP[y].move(CONTINUE);
      }
    }
    else if (Incoming_value == "marcheAr")
    {
      for (int y = 0; y < nombreMPAP; y ++)
      {
        MPAP[y].enableOutputs();
        MPAP[y].move(-CONTINUE);
      }
    }
    else if (Incoming_value == "stopMoteurs")
    {
      for (int y = 0; y < nombreMPAP; y ++)
      {
        MPAP[y].stop();
        MPAP[y].disableOutputs(); 
      } 
    }
  }
  //for (int n = 0; n <nombreMPAP; n ++)
  //{
    //if (MPAPRunning[n])
    //{
      //MPAP[n].move(mpapNombreDePasAtourner);
      //MPAP[n].run();
    //}
  //}
  for (int y = 0; y < nombreMPAP; y ++)
  {
    MPAP[y].run(); 
  } 
}

Les moteurs tournent bien collectivement comme voulu mais je ne peux plus les contrôler individuellement comme avant. Précédemment tant que je restait appuyé sur le bouton le moteur dédié continuait de tourner. Avec ce nouveau code le moteur dédié ne tourne que le nombre de pas réglé puis s'arrête même si je reste appuyé sur son bouton.

Je ne suis pas sûr de connaître cette fonction qui met à jour les booléens, quelle est-elle ?
Le code est-il plus convenable selon vous ?

Cordialement

J-M-L · November 23, 2022, 5:58am

Je ne le ferai pas vraiment comme cela sur la structure du code donc ce serait une très grosse modification de ce que vous avez (je prendrais plus une approche objet par moteur et je séparerais plus le langage de commande et je dégagerais l’usage des String et de tout ce qui peut être attente bloquante)
Attendez que @jpbbricole fasse un tour par là, je crois reconnaître son code

Un booléen se met à jour simplement en écrivant true ou false dans la variable.

jpbbricole · November 23, 2022, 8:24am

Bonjour J-M-L

J'ai passé, je regarde

Cordialement
jpbbricole

jpbbricole · November 23, 2022, 10:29am

Bonjour enash

Dans le mouvement collectif tu fais:
MPAP[x].move(CONTINUE); (#define CONTINUE 0x7FFF)

Dans le mouvement individuel tu fais:
MPAP[x].move(mpapNombreDePasAtourner); (long mpapNombreDePasAtourner = 200;)
200 pas ne sont pas suffisants pour assurer un mouvement continu.

Tu as vu l'avantage de mettre tes MAPAP en tableau, tu peux pousser plus loin le profit. Plutôt qu'un long discours, j'ai poussé un peu plus loin cette intégration, tu remarquera la cure d'amaigrissement de ton sketch. On peut faire plus mais je te laisse un peu de travail.
Ainsi, un programme qui gère un certain nombre d'objets similaires est plus facile à gérer.
Tu remarque que ton choix judicieux quand à la syntaxe de tes commandes venant de MAI, a facilité leur interprétation.

Le programme:

#define btSerial Serial1
#define CONTINUE 0x7FFF
#include "AccelStepper.h"

const int relaisPin[] = {22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34};     // Liste des pin des relais
const int relaisNombre = sizeof(relaisPin) / sizeof(int);     // Calcul du nombre de relais
const int relaisEtatOn = HIGH;     // Etat pour faire tirer le relais

String Incoming_value = "";

const byte enable[] = {40, 43, 45, 46, 42, 44, 47, 49, 51, 12, 11, 10};
const byte enableNombre = sizeof(enable) / sizeof(byte);

//int CONTINUE = 32767;

enum mpapIndex {mpapIndex1, mpapIndex2, mpapIndex3, mpapIndex4, mpapIndex5, mpapIndex6, mpapIndex7,
	mpapIndexRouge, mpapIndexBleu, mpapIndexJaune, mpapIndexViolet, mpapIndexGris
};

const byte mpapStepPin[] = {37, 39, 41, 6, 3, 38, 36, 8, 35, 9, 7, 5};
const byte stepNombre = sizeof(mpapStepPin) / sizeof(byte);
const byte stepperDriverType = AccelStepper::DRIVER;
const byte mpapDirReversePin = 4;
//boolean MPAPRunning[11];

//------------------------------------- Tableau de moteurs pas à pas
AccelStepper MPAP[] =
{
	AccelStepper {stepperDriverType, mpapStepPin[mpapIndex1],      mpapDirReversePin},
	AccelStepper {stepperDriverType, mpapStepPin[mpapIndex2],      mpapDirReversePin},
	AccelStepper {stepperDriverType, mpapStepPin[mpapIndex3],      mpapDirReversePin},
	AccelStepper {stepperDriverType, mpapStepPin[mpapIndex4],      mpapDirReversePin},
	AccelStepper {stepperDriverType, mpapStepPin[mpapIndex5],      mpapDirReversePin},
	AccelStepper {stepperDriverType, mpapStepPin[mpapIndex6],      mpapDirReversePin},
	AccelStepper {stepperDriverType, mpapStepPin[mpapIndex7],      mpapDirReversePin},
	AccelStepper {stepperDriverType, mpapStepPin[mpapIndexRouge],  mpapDirReversePin},
	AccelStepper {stepperDriverType, mpapStepPin[mpapIndexBleu],   mpapDirReversePin},
	AccelStepper {stepperDriverType, mpapStepPin[mpapIndexJaune],  mpapDirReversePin},
	AccelStepper {stepperDriverType, mpapStepPin[mpapIndexViolet], mpapDirReversePin},
	AccelStepper {stepperDriverType, mpapStepPin[mpapIndexGris],   mpapDirReversePin},
};
const byte nombreMPAP = sizeof MPAP / sizeof * MPAP;

long mpapNombreDeToursAtourner = 2;
long mpapNombreDePasAtourner = 200;

void setup() {
	// put your setup code here, to run once:
	Serial.begin(115200);
	Serial1.setTimeout(50);     // Pour fin des commandes depuis Bluetooth
	btSerial.begin(9600);

	for (int r = 0; r < relaisNombre; r ++)     // Initialisation des pin des relais
	{
		pinMode(relaisPin[r], OUTPUT);
		digitalWrite(relaisPin[r], !relaisEtatOn);     // Relais à OFF
	}
	for (int e = 0; e < enableNombre; e ++)
	{
		pinMode(enable[e], OUTPUT);
	}
	for (int m = 0; m < stepNombre; m ++)
	{
		MPAP[m].setMaxSpeed(400);
		MPAP[m].setAcceleration(500);
		MPAP[m].setEnablePin(enable[m]); //ligne ajoutée
		MPAP[m].setPinsInverted(mpapDirReversePin, false, true); //ligne modifiée
	}
}

void loop() {
	// put your main code here, to run repeatedly:
	if (btSerial.available())
	{
		Incoming_value = btSerial.readStringUntil('\n');
		Incoming_value.trim();     // Nettoyage de Incoming_value
		Serial.println("Recu : " + Incoming_value);

		//----------------------------- MPAP Start
		if (Incoming_value.startsWith("MPAP"))
		{
			Incoming_value.replace("MPAP", "");     // Supprimer la commande, reste le nom du MPAP

			mpapStart(mpapNomIndex(Incoming_value));
		}
		else if (Incoming_value.startsWith("nonMPAP"))
		{
			Incoming_value.replace("nonMPAP", "");     // Supprimer la commande, reste l'index du MPAP

			mpapStop(mpapNomIndex(Incoming_value));
		}
		//moteur à courant continu
		else if (Incoming_value == "mcc")
		digitalWrite(relaisPin[12], relaisEtatOn);
		else if (Incoming_value == "nonMcc")
		digitalWrite(relaisPin[12], !relaisEtatOn);
		//rouge
		else if (Incoming_value == "rouge")              // ON 1
		digitalWrite(relaisPin[11], relaisEtatOn);
		else if (Incoming_value == "nonRouge")
		digitalWrite(relaisPin[11], !relaisEtatOn);
		//jaune
		else if (Incoming_value == "jaune")              // ON 2
		digitalWrite(relaisPin[10], relaisEtatOn);
		else if (Incoming_value == "nonJaune")
		digitalWrite(relaisPin[10], !relaisEtatOn);
		//bleu
		else if (Incoming_value == "bleu")              // ON 3
		digitalWrite(relaisPin[9], relaisEtatOn);
		else if (Incoming_value == "nonBleu")
		digitalWrite(relaisPin[9], !relaisEtatOn);
		//gris
		else if (Incoming_value == "gris")              // ON 4
		digitalWrite(relaisPin[8], relaisEtatOn);
		else if (Incoming_value == "nonGris")
		digitalWrite(relaisPin[8], !relaisEtatOn);
		//violet
		else if (Incoming_value == "violet")              // ON 5
		digitalWrite(relaisPin[7], relaisEtatOn);
		else if (Incoming_value == "nonViolet")
		digitalWrite(relaisPin[7], !relaisEtatOn);
		//ing1
		else if (Incoming_value == "ing1")              // ON 6
		digitalWrite(relaisPin[6], relaisEtatOn);
		else if (Incoming_value == "nonIng1")
		digitalWrite(relaisPin[6], !relaisEtatOn);
		//ing2
		else if (Incoming_value == "ing2")              // ON 7
		digitalWrite(relaisPin[5], relaisEtatOn);
		else if (Incoming_value == "nonIng2")
		digitalWrite(relaisPin[5], !relaisEtatOn);
		//ing3
		else if (Incoming_value == "ing3")              // ON 8
		digitalWrite(relaisPin[4], relaisEtatOn);
		else if (Incoming_value == "nonIng3")
		digitalWrite(relaisPin[4], !relaisEtatOn);
		//ing4
		else if (Incoming_value == "ing4")              // ON 9
		digitalWrite(relaisPin[3], relaisEtatOn);
		else if (Incoming_value == "nonIng4")
		digitalWrite(relaisPin[3], !relaisEtatOn);
		//ing5
		else if (Incoming_value == "ing5")              // ON 10
		digitalWrite(relaisPin[2], relaisEtatOn);
		else if (Incoming_value == "nonIng5")
		digitalWrite(relaisPin[2], !relaisEtatOn);
		//ing6
		else if (Incoming_value == "ing6")              // ON 11
		digitalWrite(relaisPin[1], relaisEtatOn);
		else if (Incoming_value == "nonIng6")
		digitalWrite(relaisPin[1], !relaisEtatOn);
		//ing7
		else if (Incoming_value == "ing7")              // ON 12
		digitalWrite(relaisPin[0], relaisEtatOn);
		else if (Incoming_value == "nonIng7")
		digitalWrite(relaisPin[0], !relaisEtatOn);
		else if (Incoming_value == "marcheAv")
		{
			for (int y = 0; y < nombreMPAP; y ++)
			{
				mpapStart(y);
			}
		}
		else if (Incoming_value == "marcheAr")
		{
			Serial.println("ALL marcheAr");
			for (int y = 0; y < nombreMPAP; y ++)
			{
				mpapStart(y);
				MPAP[y].move(-CONTINUE);
			}
		}
		else if (Incoming_value == "stopMoteurs")
		{
			Serial.println("ALL stopMoteurs");
			for (int y = 0; y < nombreMPAP; y ++)
			{
				mpapStop(y);
			}
		}
	}

	for (int y = 0; y < nombreMPAP; y ++)
	{
		MPAP[y].run();
	}
	
	//Serial.println(MPAP[0].distanceToGo());
}

void mpapStart(int mpAPindex)
{
	Serial.print(F("MPAP START ")); Serial.println(mpAPindex +1);

	MPAP[mpAPindex].enableOutputs();     // Activer les signaux du MPAP
	MPAP[mpAPindex].move(CONTINUE);
	MPAP[mpAPindex].run();
}

void mpapStop(int mpAPindex)
{
	Serial.print(F("MPAP STOP ")); Serial.println(mpAPindex +1);

	MPAP[mpAPindex].stop();
	MPAP[mpAPindex].setCurrentPosition(0);
	MPAP[mpAPindex].disableOutputs();    // Desactiver les signaux du MPAP (ligne ajoutée)
}

int mpapNomIndex(String mpapNom)
{
	if (mpapNom.length() < 3)     // Si un chiffre et non une couleur
	{
		return mpapNom.toInt() -1;     // Nom de moteur débute à 1, index moteur à 0
	}
	else
	{
		if (mpapNom == F("rouge"))
		{
			return mpapIndexRouge;
		}
		else if (mpapNom == F("bleu"))
		{
			return mpapIndexBleu;
		}
		else if (mpapNom == F("jaune"))
		{
			return mpapIndexJaune;
		}
		else if (mpapNom == F("violet"))
		{
			return mpapIndexViolet;
		}
		else if (mpapNom == F("gris"))
		{
			return mpapIndexGris;
		}
	}
}

Le fichier MAI:
Plusieurs_moteur_mpap_a_l_appuie_B.zip (4.2 KB)

A+
Cordialement
jpbbricole

Topic		Replies	Views
Pilotage de plusieurs moteurs pas à pas via application MAI Français	27	1166	October 6, 2022
Rotation de MPAP en continue Français	15	372	October 8, 2022
PB demi-tour 3 moteurs PAP en simultané Français	58	977	February 16, 2023
2 moteur pas a pas 4 boutons Français	21	335	June 8, 2025
Ciblerie tir sportif Français	1572	13738	June 8, 2026

Problème de sens de rotation de MPAP

Related topics