Problème séléction pseudo aléatoire d'une sortie

Bonjour à tous,

Voilà je vous expose mon problème, je veux élaborer un programme qui, à l'aide d'un pont en H permettant de faire passer la puissance (ici modélisé par un L293D) et d'un arduino permet de faire la chose suivante :

Faire tourner un Moteur de manière aléatoire soit à gauche soit à droite à une vitesse aléatoire pendant une durée aléatoire, sauf si une des deux limites du moteur est atteinte, alors il ira forcément dans l'autre sens et toujours à une vitesse aléatoire et pendant une durée aléatoire, puis marquer une pause d'une durée aléatoire et recommencer son cycle.

Le soucis est que je ne parviens pas à le faire tourner de manière aléatoire d'un sens ou de l'autre... Le reste semble fonctionner avec le code suivant, mais cette partie me bloque un peu, donc si l'un d'entre vous avait une idée pour me mettre sur la voie...

`int MotorLeft = 2;
int MotorRight = 4;
int MotorSpeed = 3;
int LeftLimit = A0;
int RightLimit = A1;

void setup() {
  // put your setup code here, to run once:
  pinMode(MotorLeft, OUTPUT);
  pinMode(MotorRight, OUTPUT);
  pinMode(MotorSpeed, OUTPUT);
  pinMode(LeftLimit, INPUT);
  pinMode(RightLimit, INPUT);
  randomSeed(analogRead(A2));
}

void loop() {
  // put your main code here, to run repeatedly:
  delay(random(2000, 5000));
  if (LeftLimit == 0 && RightLimit == 0) analogWrite(MotorSpeed, random(0, 256));
  digitalWrite(MotorLeft || MotorRight, HIGH);
  delay(random(2000, 5000));
  if (LeftLimit != 0) digitalWrite(MotorRight, HIGH);
  digitalWrite(MotorLeft, LOW);
  analogWrite(MotorSpeed, random(0, 256));
  delay(random(2000, 5000));
  if (RightLimit != 0) digitalWrite(MotorLeft, HIGH);
  digitalWrite(MotorRight, HIGH);
  analogWrite(MotorSpeed, random(0, 256));
  delay(random(2000, 5000));
}`

Bonjour bencash62

Tout d'abord, corriges ton post pour mettre ton code entre les balises idoines image

Pour sélectionner un port de façon aléatoire, il faut mettre les ports en tableau,
const int motorLefrRightPorts[ ] = {2, 4};

Si tu n'as que 2 ports, les indices de ces ports seront 0 et 1.
Tu sélectionne un indice de façon aléatoire et tu fait
digitalWrite(motorLefrRightPorts[nombreAléatoire], HIGH);

Cordialement
jpbbricole

:warning: La rédaction de votre message ne répond pas aux critères attendus. Il n'aura sans doute pas de réponse tant que vous n'aurez pas pris en compte et mis en application les recommandations listées dans "Les bonnes pratiques du Forum Francophone”

il n'a rien non plus à faire dans Réalisations et Projets Finis donc je l'ai déplacé dans le forum principal


comme indices

  • vous ne lisez pas LeftLimit et RightLimit
  • cette commande
    digitalWrite(MotorLeft || MotorRight, HIGH);

ne veut rien dire (le ou logique va dire vrai ou faux, ici vrai qui sera traduit en 1 et donc vous envoyez HIGH sur la pin D1...)

plus d'infos / de discussion si vous corrigez votre premier post, merci d'avance.

image
Et donc j'ai oublié de vous joindre un schéma du montage que voici.

J-M-L

Oui le "||" "ou" logique ne fonctionne pas mais c'était pour indiquer l'endroit du code où se situe mon problème. Lire LeftLimit et RightLimit ?
Je ne comprend pas pourquoi je devrais le faire...

jpbbricole

Je devrais donc insérer dans mon setup une commande
const int MotorLRPorts[] = {2, 4};
Sommes nous bien d'accord que je ne dois rien mettre entre les crochets ?

Puis je n'aurais qu'à appeler un des deux ports au hasard dans mon loop à l'aide de la commande
digitalWrite(MotorLRPorts[random(0, 2)], HIGH);

D'avance merci à vous, ma femme me harcèle pour que je termine ce projet...

Un digitalRead serait pas mal

if (LeftLimit == 0 && RightLimit == 0)

Parce que les valeurs sinon sont connues

int LeftLimit = A0;
int RightLimit = A1;

Oui le compilateur va calculer la taille pour vous

Pas tout à fait car si on met un port à HIGH, il faut mettre l'autre à LOW (ne pas donner les deux sens en même temps. Pour éviter un problème:

digitalWrite(MotorLRPorts[0], LOW);
digitalWrite(MotorLRPorts[1], LOW);
digitalWrite(MotorLRPorts[random(0, 2)], HIGH);

Ainsi ils ne peuvent être à HIGH en même temps même pendant 1µs

Parce que les valeurs sinon sont connues

Ah oui effectivement je n'avais pas prêté attention à ce détail comme je n'ai pas mis les capteurs sur le montage mais ç peut être utile pour la suite.
Ce qui nous donne

int MotorLeft = 2;
int MotorRight = 4;
int MotorSpeed = 3;
int LeftLimit = A0;
int RightLimit = A1;
const int MotorLRPorts[] = {2, 4};

void setup() {
  // put your setup code here, to run once:
  pinMode(MotorLeft, OUTPUT);
  pinMode(MotorRight, OUTPUT);
  pinMode(MotorSpeed, OUTPUT);
  pinMode(LeftLimit, INPUT);
  pinMode(RightLimit, INPUT);
  randomSeed(analogRead(A2));
}

void loop() {
  // put your main code here, to run repeatedly:
  delay(random(2000, 5000));
  digitalWrite(MotorLRPorts[0], LOW);
  digitalWrite(MotorLRPorts[1], LOW);
  digitalRead(LeftLimit);
  digitalRead(RightLimit);
  if (LeftLimit == 0 && RightLimit == 0) analogWrite(MotorSpeed, random(0, 256));
  digitalWrite(MotorLRPorts[random(0, 2)], HIGH);
  delay(random(2000, 5000));
  if (LeftLimit != 0) digitalWrite(MotorLRPorts[1], HIGH);
  digitalWrite(MotorLRPorts[0], LOW);
  analogWrite(MotorSpeed, random(0, 256));
  delay(random(2000, 5000));
  if (RightLimit != 0) digitalWrite(MotorLRPorts[0], HIGH);
  digitalWrite(MotorLRPorts[1], HIGH);
  analogWrite(MotorSpeed, random(0, 256));
  delay(random(2000, 5000));
}

Mais lorsque j'exécute le code en simulation sur le montage précédent mon moteur effectue un mouvement dans le sens anti-horaire, puis, sans marquer de temps d'arrêt comme je le voudrais, il repars dans le sens horaire, et seulement après marque un temps d'arrêt, je pense qu'il y a une histoire de commande else if et else à insérer sur le loop à la place des deux derniers if mais je n'y parviens pas sans erreur...

Ceci lit le port LeftLimit et ne fait rien de la lecture. Puis la condition porte sur les numéros des broches et pas leur état. Ces trois lignes seraient à remplacer par

  if (digitalRead(LeftLimit) == 0 && digitalRead(RightLimit) == 0) analogWrite(MotorSpeed, random(0, 256));

digitalRead(LeftLimit) == 0 ne serait pas plutôt digitalRead(LeftLimit) == LOW?

Avec des commentaires dans le code, on est plus à même de savoir ce que tu veux faire.

Pour moi le premier delay(random(2000, 5000)); et le tout derniers sont l'un à la suite de l'autre...

Les delay sont bloquant. Ce qui veut dire que si le moteur tourne, il ne s'arrêtera pas sur les fins de course, mais au bout de 3 à 5 secondes.

C'est le sauf si qui ne peut pas être pris en compte

Ce qu'il faut par exemple faire, en français:
~ prendre un temps au hasard
~ arrêter le moteur
~ en fonction des capteurs faire démarrer le moteur
~ ne rien faire si le temps n'est pas écoulé et si on n'arrive pas sur un fin de course
~ attendre 2 à 5 secondes

Salut à tous,

Le manque de temps a fait que j'avais un peu mis ce projet de côté...
Mais me voici de retour avec mon histoire qui comporte beaucoup d'aléatoires...
J'ai remanié légèrement le code et je l'ai décrit un peu avec ce que je pense que les lignes font et surtout ce que j'aimerais qu'elles fassent... Sur le simulateur sans les capteurs de seuils limites ça fonctionne, mais je vois bien que mes seuils vont me bloquer et j'ai bien compris en français ce qu'il faudrait faire comme l'a décrit @vileroi , mais là je ne vois pas du tout comment le mettre en œuvre dans le code... Je pense qu'il faudrait soit que je rajoute un "until" quelque part, soit que je crée des cas différents avec "switch" ... "case" mais je ne vois pas comment les insérer là dedans.
Peut-être devrais-je reprendre le code sur une feuille vierge ?

D'avance merci pour votre soutien et votre aide.

int MotorLeft = 2;
// Le pin 2 va faire tourner le moteur dans le sens anti-horaire
int MotorRight = 4;
// Le pin 4 va faire tourner le moteur dans le sens horaire
int MotorSpeed = 3;
// Le pin 3 donne la vitesse de rotation du moteur 
int LeftLimit = A0;
// Le pin A0 donne le seuil à ne pas dépasser dans le sens anti-horaire via un capteur
int RightLimit = A1;
// Le pin A1 donne le seuil à ne pas dépasser dans le sens horaire via un capteur
const int MotorLRPorts[] = {2, 4};
// Les pin 2 et 4 sont séléctionnés par un appel de MotorLRPorts[] soit 0 soit 1


void setup() {
  // put your setup code here, to run once:
  pinMode(MotorLeft, OUTPUT);
  // Définit le pin 2 comme sortie
  pinMode(MotorRight, OUTPUT);
  // Définit le pin 4 comme sortie
  pinMode(MotorSpeed, OUTPUT);
  // Définit le pin 3 comme sortie
  pinMode(LeftLimit, INPUT);
  // Définit le pin A0 comme entrée
  pinMode(RightLimit, INPUT);
  // Définit le pin A1 comme entrée
  randomSeed(analogRead(A2));
  // Crée une entrée aléatoire en A2
}

void loop() {
  // put your main code here, to run repeatedly:
  analogWrite(MotorSpeed, 0);
  // Définit la vitesse du moteur sur 0
  digitalWrite(MotorLRPorts[0], LOW);
  // Désactive le sens anti-horaire du moteur
  digitalWrite(MotorLRPorts[1], LOW);
  // Désactive le sens horaire du moteur
  delay(random(2000, 5000));
  // Attend un délai aléatoire compris entre 2 et 5 secondes
  if (digitalRead(LeftLimit) == LOW && digitalRead(RightLimit) == LOW) {
  analogWrite(MotorSpeed, random(0, 256));
  digitalWrite(MotorLRPorts[random(0, 2)], HIGH);
  // Vérifie que les seuils ne sont pas atteints et s'ils ne sont pas atteint commande au moteur de tourner dans un sens aléatoirement définit et à vitesse aléatoire
  delay(random(2000, 5000));
  // Fait durer les paramètres précédents pour une durée aléatoire comprise entre 2 et 5 secondes
  }
  if (digitalRead(LeftLimit != LOW)) {
  digitalWrite(MotorLRPorts[1], HIGH);
  digitalWrite(MotorLRPorts[0], LOW);
  analogWrite(MotorSpeed, random(0, 256));
  // Si le seuil gauche est atteint commande au moteur de tourner dans le sens horaire à vitesse aléatoire
  delay(random(2000, 5000));
  // Fait durer les paramètres précédents pour une durée aléatoire
  }
  if (digitalRead(RightLimit != LOW)) {
  digitalWrite(MotorLRPorts[0], HIGH);
  digitalWrite(MotorLRPorts[1], HIGH);
  analogWrite(MotorSpeed, random(0, 256));
  // Si le seuil droit est atteint commande au moteur de tourner dans le sens anti-horaire à vitesse aléatoire
  delay(random(2000, 5000));
  // Fait durer les paramètres précédents pour une durée aléatoire
  }
}

peut-être maintenant que vous avez un peu de recul, vous devriez prendre le temps d'écrire en français le cahier des charges complet.

est-ce que

Faire tourner un Moteur de manière aléatoire soit à gauche soit à droite à une vitesse aléatoire pendant une durée aléatoire, sauf si une des deux limites du moteur est atteinte, alors il ira forcément dans l'autre sens et toujours à une vitesse aléatoire et pendant une durée aléatoire, puis marquer une pause d'une durée aléatoire et recommencer son cycle.

correspond toujours exactement à la description ?

Oui c'est pour ça que j'ai mis les descriptions sur mon code en fait je voulais vérifier mon cahier des charges tout en codant et ça m'a l'air pas mal hormis mon histoire de seuils qui n'est pas correctement gérée.
Oui oui la description est toujours la même, en fait pour vous expliquer c'est un drapeau qui va se trouver sur une corde et qui doit faire un mouvement aléatoire droite ou gauche pour apprendre a un cheval par le jeu a suivre le drapeau, mais bien entendu il ne vaudrait mieux pas que mon drapeau passe dans le moteur...

OK

c'est typiquement une définition de programme qui se prête bien à la programmation par machine à états (cf mon tuto éventuellement)

ça pourrait ressembler à cela (tapé ici, non testé). le code devrait afficher dans la console à 115200 bauds les mouvements choisis.

const byte pinMoteurGauche = 2; // sens anti-horaire
const byte pinMoteurDroite = 4; // sens horaire
const byte pinVitesseMoteur = 3; // pour la vitesse
const byte pinLimiteGauche = A0;
const byte pinLimiteDroite = A1;
const byte LIMITE_ACTIVE = LOW; // on utilise un pullup sur les entrées, LOW veut dire apppui
const byte VitesseMin = 25;
const byte VitesseMax = 255;
const int DureeMin = 2000;
const int DureeMax = 5000;

enum t_etat : byte {ARRET, VERS_GAUCHE, VERS_DROITE} etat = ARRET;

unsigned long duree, tempsDebut;
byte vitesse; // PWM

void afficheEtat() {
  switch (etat) {
    case VERS_GAUCHE: Serial.print(F("VERS_GAUCHE")); break;
    case VERS_DROITE: Serial.print(F("VERS_DROITE")); break;
    case ARRET:  Serial.print(F("ARRET")); break;
    default: break;
  }
  Serial.print(F(" pour "));
  Serial.print(duree / 1000.0, 2);
  Serial.println(F(" s."));
}

void arret() {
  analogWrite(pinVitesseMoteur, 0);
  digitalWrite(pinMoteurDroite, LOW);
  digitalWrite(pinMoteurGauche, LOW);
  etat = ARRET;
  afficheEtat();
}

void allerAGauche() {
  analogWrite(pinVitesseMoteur, vitesse);
  digitalWrite(pinMoteurDroite, LOW);
  digitalWrite(pinMoteurGauche, HIGH);
  etat = VERS_GAUCHE;
  afficheEtat();
}

void allerADroite() {
  analogWrite(pinVitesseMoteur, vitesse);
  digitalWrite(pinMoteurGauche, LOW);
  digitalWrite(pinMoteurDroite, HIGH);
  etat = VERS_DROITE;
  afficheEtat();
}

void generationAleatoire() {
  // on ne veut pas répéter le même mouvement deux fois de suite
  t_etat choixPossibles[2];
  switch (etat) {
    case ARRET: choixPossibles[0] = VERS_GAUCHE; choixPossibles[1] = VERS_DROITE; break;
    case VERS_GAUCHE: choixPossibles[0] = ARRET; choixPossibles[1] = VERS_DROITE; break;
    case VERS_DROITE: choixPossibles[0] = ARRET; choixPossibles[1] = VERS_GAUCHE; break;
  }

  t_etat choix = choixPossibles[random(0, 2)]; // on choisit un nouvel état aléatoirement
  vitesse = (choix == ARRET) ? 0 : random(VitesseMin, VitesseMax + 1); // vitesse aléatoire si on n'est pas à l'arrêt
  duree = random(DureeMin, DureeMax + 1); // durée aléatoire de cette action
  tempsDebut = millis();
  switch (choix) {
    case ARRET: arret(); break;
    case VERS_GAUCHE: allerAGauche(); break;
    case VERS_DROITE: allerADroite(); break;
  }
}

void testDuree() {
  if (millis() - tempsDebut >= duree) generationAleatoire(); // il est temps de donner un nouvel ordre
}

void testLimites() {
  switch (etat) {
    case VERS_GAUCHE: if (digitalRead(pinLimiteGauche) == LIMITE_ACTIVE) allerADroite(); break;
    case VERS_DROITE: if (digitalRead(pinLimiteDroite) == LIMITE_ACTIVE) allerAGauche(); break;
    case ARRET:  break; // rien à faire sinon
  }
}

void setup() {
  pinMode(pinMoteurGauche, OUTPUT);
  pinMode(pinMoteurDroite, OUTPUT);
  pinMode(pinVitesseMoteur, OUTPUT);
  arret();
  pinMode(pinLimiteGauche, INPUT_PULLUP); // pullup interne activé
  pinMode(pinLimiteDroite, INPUT_PULLUP); // pullup interne activé
  randomSeed(analogRead(A2));
  Serial.begin(115200);
  Serial.println(F("\nC'EST PARTI !!!"));
  generationAleatoire();
}

void loop() {
  testDuree();
  testLimites();
}

Si on touche un limit switch, le mouvement s'inverse et continue pour le temps restant (puisque c'était aléatoire, ça reste un temps aléatoire)

la structuration en petites fonctions dédiées à une tâche rend le code plus lisible et la définition d'un état du système permet de prendre des décisions sur quoi faire lorsqu'un événement attendu survient (le temps est écoulé ou on touche un fin de course)

vous remarquerez qu'il n'y a aucun appel à delay() dans le code. C'est un appel bloquant et vous ne voulez pas cela sinon vous ne pouvez pas tester si un fin de course et touché pendant ce temps là.

➜ à tester et affiner sans doute

Tout d'abord merci de prendre le temps de m'aider, j'apprends beaucoup grâce à ces interventions.
J'ai testé le code sur mon montage modélisé sur Tinkercad, effectivement ça fonctionne, le seul soucis c'est que j'ai besoin d'avoir ce mouvement un temps donné entre 2 et 5 secondes si on n'atteint pas l'un des des deux seuils, et de marquer des temps d'arrêt entre deux variations du mouvement du moteur.
Ici, le code permet vraiment un mouvement aléatoire du moteur tant dans son sens de rotation que dans sa vitesse mais la variation est continue.
La fonction delai() est bien celle qui me bloque mais elle est essentielle pour que mon système fonctionne comme je le voudrais.

J'en profite également pour demander si quelqu'un à une idée d'un shield que je pourrais mettre sur mon montage qui permettrait d'encaisser un peu plus de puissance que mon petit L293D ? Parce que ça me semble compliqué de gérer le montage avec un maximum de 6.5 W de puissance moteur en admettant que j'ai un moteur avec une rendement de 0.9
J'ai bien pensé aux transistors ou aux relais de puissance mais le montage va se compliquer.
Sinon j'avais pensé aussi à une carte Cytron mais je ne comprends pas bien comment elle fonctionne

ça veut dire quoi ? il faut s'arrêter si on tape un des 2 détecteurs de fin de course ?

et si vous voulez un arrêt après un mouvement, il suffit de modifier la fonction generationAleatoire() pour que seul ARRET soit choisi si l'état précédent était différent de ARRET

Admettons que j'ai une distance entre deux capteurs de 20 mètres, et une corde entre deux qui va tourner sur le moteur afin de déplacer le drapeau qui se situe à un point fixe sur cette corde, je voudrais que durant 2 à 5 secondes le drapeau se dirige aléatoirement d'un coté ou de l'autre à une vitesse aléatoire constante, puis s'arrête durant 2 à 5 secondes, puis reparte durant 2 à 5 secondes aléatoirement d'un coté ou de l'autre à une vitesse aléatoire constante, puis s'arrête...etc
Mais il faut que si ma limite droite est atteinte il s'arrête et ne reparte pas dans la mauvaise direction, et pareil si la limite gauche est atteinte.
Je ne sais pas si c'est bien clair mon histoire.
Pour le mouvement sans les limites ça fonctionne avec mon code cité précédemment mais je n'arrive pas à inclure les limites dans le code afin de stopper le moteur même si le temps de rotation qui avait été définit n'est pas écoulé.
Je peux peut-être vous mettre un lien vers une vidéo d'un système qui existe en version télécommandée uniquement.

Ici le système est manuel et effectue la totalité de sa course en un mouvement, moi j'aimerais l'automatiser et lui donner plus de souplesse dans ses mouvement pour ne pas habituer le cheval à un mouvement toujours identique.

ben voilà - l'expression des besoins est plus claire maintenant !

sur la vidéo on dirait que c'est dans un sens et dans l'autre, jamais deux fois de suite dans le même sens

Oui mais c'est une des choses que je voudrais ne pas reproduire :face_with_raised_eyebrow:
Pour bien comprendre le but de cet exercice avec le cheval est de l'entraîner à suivre les mouvement d'une vache en face à face sans avoir besoin d'une vache...
Il n'est pas impossible que la vache s'arrête dans son mouvement et reprenne après dans la même direction, donc il faut que mon système puisse effectuer le mouvement dans le même sens aussi aléatoirement.
Exemple avec une vache :

On peut voir vers 2 minutes 20 secondes que notre vache prend deux fois la même direction en marquant une pause entre les deux.

un truc du genre alors ?

const byte pinMoteurGauche = 2; // sens anti-horaire
const byte pinMoteurDroite = 4; // sens horaire
const byte pinVitesseMoteur = 3; // pour la vitesse
const byte pinLimiteGauche = A0;
const byte pinLimiteDroite = A1;
const byte LIMITE_ACTIVE = LOW; // on utilise un pullup sur les entrées, LOW veut dire apppui
const byte VitesseMin = 25;
const byte VitesseMax = 255;
const int DureeMin = 2000;
const int DureeMax = 5000;

enum t_etat : byte {ARRET, VERS_GAUCHE, VERS_DROITE} etat = ARRET;

unsigned long duree, tempsDebut;
byte vitesse; // PWM

void afficheEtat() {
  switch (etat) {
    case VERS_GAUCHE: Serial.print(F("VERS_GAUCHE")); break;
    case VERS_DROITE: Serial.print(F("VERS_DROITE")); break;
    case ARRET:  Serial.print(F("ARRET")); break;
    default: break;
  }
  Serial.print(F(" pour "));
  Serial.print(duree / 1000.0, 2);
  Serial.println(F(" s."));
}

void arret() {
  analogWrite(pinVitesseMoteur, 0);
  digitalWrite(pinMoteurDroite, LOW);
  digitalWrite(pinMoteurGauche, LOW);
  etat = ARRET;
  afficheEtat();
}

void allerAGauche() {
  analogWrite(pinVitesseMoteur, vitesse);
  digitalWrite(pinMoteurDroite, LOW);
  digitalWrite(pinMoteurGauche, HIGH);
  etat = VERS_GAUCHE;
  afficheEtat();
}

void allerADroite() {
  analogWrite(pinVitesseMoteur, vitesse);
  digitalWrite(pinMoteurGauche, LOW);
  digitalWrite(pinMoteurDroite, HIGH);
  etat = VERS_DROITE;
  afficheEtat();
}

void generationAleatoire() {
  // on ne veut pas répéter le même mouvement deux fois de suite
  t_etat choixPossibles[2];
  t_etat choix;
  switch (etat) {
    case ARRET: choixPossibles[0] = VERS_GAUCHE; choixPossibles[1] = VERS_DROITE; choix = choixPossibles[random(0, 2)]; break;
    case VERS_GAUCHE:
    case VERS_DROITE:
    default: choix = ARRET; break;
  }

  vitesse = (choix == ARRET) ? 0 : random(VitesseMin, VitesseMax + 1); // vitesse aléatoire si on n'est pas à l'arrêt
  duree = random(DureeMin, DureeMax + 1); // durée aléatoire de cette action
  tempsDebut = millis();
  switch (choix) {
    case ARRET: arret(); break;
    case VERS_GAUCHE: allerAGauche(); break;
    case VERS_DROITE: allerADroite(); break;
  }
}

void pauseAtteinteLimite() {
  arret();
  delay(random(DureeMin, DureeMax + 1));
  vitesse =  random(VitesseMin, VitesseMax + 1); // vitesse aléatoire si on n'est pas à l'arrêt
  duree = random(DureeMin, DureeMax + 1); // durée aléatoire de la prochaine action
  tempsDebut = millis();
  if (etat == VERS_GAUCHE) allerADroite(); else allerADroite();
}

void testDuree() {
  if (millis() - tempsDebut >= duree) generationAleatoire(); // il est temps de donner un nouvel ordre
}

void testLimites() {
  switch (etat) {
    case VERS_GAUCHE: if (digitalRead(pinLimiteGauche) == LIMITE_ACTIVE) pauseAtteinteLimite(); break;
    case VERS_DROITE: if (digitalRead(pinLimiteDroite) == LIMITE_ACTIVE) pauseAtteinteLimite(); break;
    case ARRET:  break; // rien à faire sinon
  }
}

void setup() {
  pinMode(pinMoteurGauche, OUTPUT);
  pinMode(pinMoteurDroite, OUTPUT);
  pinMode(pinVitesseMoteur, OUTPUT);
  arret();
  pinMode(pinLimiteGauche, INPUT_PULLUP); // pullup interne activé
  pinMode(pinLimiteDroite, INPUT_PULLUP); // pullup interne activé
  randomSeed(analogRead(A2));
  Serial.begin(115200);
  Serial.println(F("\nC'EST PARTI !!!"));
  generationAleatoire();
}

void loop() {
  testDuree();
  testLimites();
}

Ce code là ne fonctionne pas, mais tu m'as peut-être apporté la solution au problème, je vais réécrire le programme avec une fonction vérification des seuils, une fonction mise en marche moteur délai inclu, une fonction arrêt moteur délai inclu, et avec un "while" je pense que je peux dire : tant que la fonction vérification des seuils donne pour valeur "FAUX", exécuter la fonction mise en marche moteur.
Dans ma tête ça doit fonctionner, j'essaierai surement de coder ça ce soir