constrain qui recommence à valeur min

Bonsoir

Je fais une erreur avec constrain(), mais je ne la retrouve pas.

Mon constrain fonction en décrémentant et s'arrête bien à la valeur min, mais lorsque j'incrémente et qu'il atteint la valeur max, il reprend la valeur min, et recommence.

//LINE TRACKER BY KAMMO

//STEPPER, définition des pins
#define E1 10    // Enable PWM Pin for motor 1
#define E2 11    // Enable PWM Pin for motor 2
#define I1 8     // Control pin a for motor 1
#define I2 9     // Control pin b for motor 1
#define I3 5    // Control pin a for motor 2
#define I4 6    // Control pin b for motor 2

//Pins Capteurs:  LL LC CC CR RR
byte PinFF = 7; //Front sensor
byte PinLL = 2; //LPin capteur Left Left
byte PinCC = 3; //Center Center
byte PinRR = 4; //Right Right

//Déclaration des variables de lecture binaire
boolean b3, b2, b1, b0;
int b = 0;

// Vitesse des moteurs PWM
byte vitesse = 125;  //vitesse au démarrage
byte adh = 5;  //1=accélération douce  255=accélération forte
byte Vmin = 90; //vitesse minimum des moteurs
byte Vmax = 255; //vitesse maximum des moteurs



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

  //Pins Moteurs
  pinMode(E1, OUTPUT);
  pinMode(E2, OUTPUT);
  pinMode(I1, OUTPUT);
  pinMode(I2, OUTPUT);
  pinMode(I3, OUTPUT);
  pinMode(I4, OUTPUT);

  //Pins digitaux capteurs
  pinMode ( PinLL , INPUT) ;
  pinMode ( PinCC , INPUT) ;
  pinMode ( PinRR , INPUT) ;
  pinMode ( PinFF , INPUT) ;
  delay(2000);

}


void loop() {

 
//V I T E S S E
//comparateur
  if (digitalRead (PinFF) == LOW) {  //Si le capteur capte du noir
    VITMOTEUR(1); //1=accélérer
  }
  else {  //Si la couleur est claire
    VITMOTEUR(-1); //-1=ralentir
  } //fin du comparateur
  
  Serial.println(vitesse);
  delay(20);  
}//fin de loop()

//   F O N C T I O N S

void VITMOTEUR(byte sens) {

  vitesse = vitesse + (adh * sens);  //byte adh est déclarée en début de code et vaut 5
  vitesse = constrain (vitesse, Vmin, Vmax);  //  Vmin<vitesse<Vmax
  delay(70);
}




/*void print5bits(byte aByte)
  {
  //Serial.println(F("B"));
  //for (int8_t aBit = 2; aBit >= 0; aBit--)
  //  Serial.println(bitRead(aByte, aBit) == 0 ? F("0") : F("1")); // affiche les trois booléens
  Serial.println();
  Serial.println("b0");
  Serial.println (b0);
  Serial.println("aByte");// cette partie renvoie le code binaire en fonction des capteurs
  Serial.println(aByte);
  Serial.println(" ");
  delay(500); }*/

Tu ne peux pas mettre -1 dans un byte, or c'est ce que tu fais lors de l'appel VITMOTEUR(-1);
Change :
void VITMOTEUR(byte sens) {envoid VITMOTEUR(int sens) {et ça devrait aller mieux !

Salut
Avec le -1 ça fonctionnait néanmoins, mais ça aurait généré une erreur tôt ou tard
Mais le résultat est toujours le même, la variable revient à Vmin après avoir atteint Vmax

245
250
255
90
95
100
105
110
115

Je ne trouve rien dans le code qui force à ça

Damned !
Essaye un truc du genre :

  byte vitesse2 = vitesse + (adh * sens);  //byte adh est déclarée en début de code et vaut 5
  vitesse = constrain (vitesse2, Vmin, Vmax);  //  Vmin<vitesse<Vmax
  Serial.print(vitesse2);
  Serial.print(" --> ");
  Serial.println(vitesse);

pour voir comment fonctionne le constrain

Alors je ne sais pas pourquoi mais ca marche avec 250
J'utilise un byte pour commander un PWM, en quoi 255 est un problème? Quel rapport avec constrain

Avec ton code, on approche

230
235 --> 235
235
240 --> 240
240
245 --> 245
245
250 --> 250
250
255 --> 250
250
255 --> 250
250
255 --> 250
250
255 --> 250

ERREUR

J'avais modifié Vmax, je l'ai remise à 255

Surprenant

245
250 --> 250
250
255 --> 255
255
4 --> 100
100
105 --> 105
105
110 --> 110
110
115 --> 115

J'ai renommé les varaible Vmin Vm et VMax Vm pensant qu'elles étaient réservées .... mais non

Je pense que j'ai compris : lorsque tu fais le constrain si tu es à 255, tu renvoies 255. Après si le sens vaut 1, tu passes à 4 parce que c'est un byte : il doit boucler (comme un modulo 255, '%'). Puis le constrain impose Vmin (100 on dirait).
Je pense que si tu mets toutes tes variables en int, ça va passer comme tu veux. Après 255, et sens=1, tu passeras à 260 et le constrain imposera de rester à 255.

Essaye un truc simple (je peux pas le faire car je n'ai pas de µC ici) :

void loop() {
  byte x = 200;
  byte y = 300;
  byte z = x+y;
  Serial.println(z);

Ça donne 245 (500%255) ?

Oui désolé je change des trucs pour voir entre deux :stuck_out_tongue:

Bon il s'avère que j'ai mis un byte à la place d'un int et que ca bride vitesse à 250, et ça plante
si je déclare int vitesse = 255 il est content

Merci de m'avoir soutenu ^^