Contrôler plusieurs moteurs à des vitesses differentes.

Bonjours,
A l’aide de deux kits L298N, j’aimerais contrôler la vitesse de 4 moteurs avec un potentiomètre.
J’arrive à contrôler la vitesse progressivement d’un moteur et son sens, mais pas les autres.
Pourriez vous m’aider?

l298N_2_motorAetB_2.ino (4.99 KB)

Vous avez posté cela déjà ailleurs, pas la peine de dupliquer... vous avez une premiere réponse la bas - explorez la

Oui c’est vrai, car j’espère augmenter mes chances d’être aider! :slight_smile:

Et je pensais au décalage horaire.

J’ai nettoyé et fait des objets moteurs pour contrôler la vitesse, mais ça n’a rien changé.
Si vous avez une idée, merci de m’aiguiller ou donner un exemple.

Je mets le programme

// PORT POUR KIT L298N 1 
 
//Ports de commande du moteur B 

int motorPinB1 = 4;
int motorPinB2 = 5;
const int enablePinB = 6; //  Commande de vitesse moteur, to Output ENB
 
//Ports de commande du moteur A  

int motorPinA1 = 2; // 
int motorPinA2 = 3; // 
const int enablePinA =  7; // Commande de vitesse moteur,to Output ENA

// PORT POUR KIT L298N 2

//Ports de commande du moteur D

int motorPinD1 = 9;
int motorPinD2 = 10;
const int enablePinD = 8; //  Commande de vitesse moteur, to Output ENB pour L298 2 

//Ports de commande du moteur C

int motorPinC1 = 11;
int motorPinC2 = 12;
const int enablePinC= 13; // //  Commande de vitesse moteur, to Output ENA pour L298 2 

// VITESSE pour moteur B,A,D,C. SPEED to motor B,A,D,C

int stateB=0; // vitesse assignée au moteur B (speed assigned motor B )
int stateA=0; // vitesse assignée au moteur A 
int stateD=0; // vitesse assignée au moteur D 
int stateC=0; // vitesse assignée au moteur C 


void setup() {

 //CONTROLE MOTEUR B et A
  
    // Configuration des ports en mode "sortie" pour moteur B
    pinMode(motorPinB1, OUTPUT);
    pinMode(motorPinB2, OUTPUT);
    pinMode(enablePinB, OUTPUT);
    
    // Configuration des ports en mode "sortie" pour moteur A
    pinMode(motorPinA1, OUTPUT);
    pinMode(motorPinA2, OUTPUT);
    pinMode(enablePinA, OUTPUT);
   
 //CONTROLE MOTEUR D et C 
   
 // Configuration des ports en mode "sortie" D
    pinMode(motorPinD1, OUTPUT);
    pinMode(motorPinD2, OUTPUT);
    pinMode(enablePinD, OUTPUT);
    
    // Configuration des ports en mode "sortie" C
    pinMode(motorPinC1, OUTPUT);
    pinMode(motorPinC2, OUTPUT);
    pinMode(enablePinC, OUTPUT);

    // Initialisation du port série
    Serial.begin(9600);
}
 
void loop() {

  // read the sensor value:
  int sensorReading = analogRead(A0);
  // map it to a range from -value to value
  int motorSpeedB= map(sensorReading, 0, 1023, -155, 155);
  stateB= map(sensorReading, 0, 1023, -250, 250);
  stateC= map(stateB,-155,155, -250, 250);
  stateD= motorSpeedB; 
  stateA= map(stateD,-200,200, -250, 250);

    
    // CONTROLE MOTEUR D sur KIT 2 
    // Pont en H L298N //CONTROL MOTOR D on H BRIDGE L298N KIT 2
    // Sens du mouvement// way of clockwise 
     
      if (stateD > 0) // avant // CW
      {
        digitalWrite(motorPinD1, HIGH); 
        digitalWrite(motorPinD2, LOW);
        Serial.print("AvantD2 ");
        Serial.println(stateD);
      }
      else if (stateD < 0) // arrière // CCW
      {
        digitalWrite(motorPinD1, LOW); 
        digitalWrite(motorPinD2, HIGH);
        Serial.print("ArriereD2 ");
        Serial.println(stateD);
      }
      else // Stop (freinage)
      {
        digitalWrite(motorPinD1, HIGH); 
        digitalWrite(motorPinD2, HIGH);
        Serial.println("StopD2");
      }
 
      // Vitesse du mouvement
      //analogWrite(enablePinD, abs(stateD));
       delay(100);

// CONTROLE MOTEUR C  // CONTROL C MOTOR on KIT 2
// Pont en H L298N // H BRIDGE L298N   

    if (stateC > 0) // avant // CW
      {
        digitalWrite(motorPinC1, HIGH); 
        digitalWrite(motorPinC2, LOW);
        Serial.print("AvantC2 ");
        Serial.println(stateC);
      }
      else if (stateC < 0) // arrière // CCW
      {
        digitalWrite(motorPinD1, LOW); 
        digitalWrite(motorPinD2, HIGH);
        Serial.print("ArriereD2 ");
        Serial.println(stateC);
      }
      else // Stop (freinage)
      {
        digitalWrite(motorPinC1, HIGH); 
        digitalWrite(motorPinC2, HIGH);
        Serial.println("StopC2");
      }
 
      // Vitesse du mouvement
      //analogWrite(enablePinC, abs(stateC));
       delay(100);


// CONTROLE MOTEUR B  // CONTROL B MOTOR on KIT 1
// Pont en H L298N // H BRIDGE L298N

      // Sens du mouvement
      //
      if (stateB > 0) // avant
      {
        digitalWrite(motorPinB1, HIGH); 
        digitalWrite(motorPinB2, LOW);
        Serial.print("AvantB ");
        Serial.println(stateB);
      }
      else if (stateB < 0) // arrière
      {
        digitalWrite(motorPinB1, LOW); 
        digitalWrite(motorPinB2, HIGH);
        Serial.print("ArriereB ");
        Serial.println(stateB);
      }
      else // Stop (freinage)
      {
        digitalWrite(motorPinB1, HIGH); 
        digitalWrite(motorPinB2, HIGH);
        Serial.println("StopB");
      }
      // Vitesse du mouvement
      //
      //analogWrite(enablePinB, abs(stateB));
      delay(100);
      
// CONTROLE MOTEUR A proportionnel à state
// Pont en H L298N // H BRIDGE L298N

    
    if (stateA > 0) // avant
      {
        digitalWrite(motorPinA1, HIGH); 
        digitalWrite(motorPinA2, LOW);
        Serial.print("AvantA ");
        Serial.println(stateA);
      }
      else if (stateA < 0) // arrière
      {
        digitalWrite(motorPinA1, LOW); 
        digitalWrite(motorPinA2, HIGH);
        Serial.print("ArriereA ");
        Serial.println(stateA);
      }
      else // Stop (freinage)
      {
        digitalWrite(motorPinA1, HIGH); 
        digitalWrite(motorPinA2, HIGH);
        Serial.println("Stop");
      }
      // Vitesse du mouvement
      //
     // analogWrite(enablePinA, abs(stateA));
      
        delay(100);

        ControlMotorD(abs(stateD));
        ControlMotorC(abs(stateC));
        ControlMotorB(abs(stateB));
        ControlMotorA(abs(stateA));

        Serial.println(motorSpeedB);
       
 }


 void ControlMotorD(int powerRate){
 
    analogWrite(enablePinD, powerRate);

}

 void ControlMotorC(int powerRate){
 
    analogWrite(enablePinC, powerRate);

}
  
 void ControlMotorB(int powerRate){

    analogWrite(enablePinB, powerRate);

}

 void ControlMotorA(int powerRate){
  
    analogWrite(enablePinA, powerRate);

    Serial.println (A0); 
    Serial.print ("stateD :"); Serial.println(stateD);
    Serial.print ("stateB :"); Serial.println(stateB);
    Serial.print ("stateA :"); Serial.println(stateA);
    Serial.print ("stateC :"); Serial.println(stateC);
}

hello, j'ai commencé à lire ton code et je suis interloqué des les premieres lignes

int sensorReading = analogRead(A0);
  // map it to a range from -value to value
  int motorSpeedB= map(sensorReading, 0, 1023, -155, 155);
  stateB= map(sensorReading, 0, 1023, -250, 250);
  stateC= map(stateB,-155,155, -250, 250);
  stateD= motorSpeedB; 
  stateA= map(stateD,-200,200, -250, 250);

reviens à dire

int sensorReading = analogRead(A0);
  stateB= map(sensorReading, 0, 1023, -250, 250);
  stateC= map(stateB,-155,155, -250, 250);
  stateD= map(sensorReading, 0, 1023, -155, 155); 
  stateA= map(stateD,-200,200, -250, 250);

et ça

stateB= map(sensorReading, 0, 1023, -250, 250);
  stateC= map(stateB,-155,155, -250, 250);

ou ça

stateD= map(sensorReading, 0, 1023, -155, 155); 
  stateA= map(stateD,-200,200, -250, 250);

je me demande ce que ça donne

ce genre de résultats

AvantD2 48
AvantC2 124
AvantB 77
AvantA 60
14
stateD :48
stateB :77
stateA :60
stateC :124
48
ArriereD2 -8
ArriereD2 -20
ArriereB -12
ArriereA -10
14
stateD :-8
stateB :-12
stateA :-10
stateC :-20

J'ai corrigé mes print.ln.

Voila les résultats, mais je pense que c'est pas le map qui fait dysfonctionner le programme.

ArriereD -17
ArriereC -44
ArriereB -27
ArriereA -22
14
stateD :-17
stateB :-27
stateA :-22
stateC :-44
-17
AvantD 43
AvantC 111
AvantB 69
AvantA 53
14
stateD :43
stateB :69
stateA :53
stateC :111
43
AvantD 38
AvantC 100
AvantB 62
AvantA 47
14
stateD :38
stateB :62
stateA :47
stateC :100
38
AvantD 59
AvantC 153
AvantB 95
AvantA 73
14
stateD :59
stateB :95
stateA :73
stateC :153
59
AvantD 48
AvantC 124
AvantB 77
AvantA 60
14

Tu as pris en compte la remarque de MorganS concernant les PWM?

La fonction map ne sature pas le premier argument s'il est en dehors de la plage in_min, in_max. Du coup tu peux avoir des résultats "inattendus". Si tu veux éviter ces problèmes, il faudrait utiliser constrain() sur le premier argument

Merci fdufnews.

J'ai bien pris compte des remarques de MorganS et mon programme fonctionne!

Maintenant, j'essaye de le nettoyer avec des objects pour contrôler les moteurs mais c'est nouveau pour moi.

Je reviendrai pour des conseils.