code pour plusieurs moteurs , utilisation d'un tableau

Bonsoir,

Je ne m’en sors pas ,( mauvaise maitrise de la gestion des tableaux, pourtant j’ai été voir un peu partout sur internet )

struct elementSequence_t {
  byte numPin;
  unsigned long debut;
  unsigned long fin;
  byte etat;
};

elementSequence_t maSequence[] = {
  {11, 0ul, 500ul, LOW},
  {6, 500ul, 8500ul, LOW},
  {13, 500ul, 6500ul, LOW},
  {10, 8500ul, 38500ul, LOW},
  {9, 8500ul, 18500ul, LOW},
  {7, 18500ul, 26500ul, LOW},
  {6, 38500ul, 46500ul, LOW},
  {12, 46500ul, 56500ul, LOW},
  {3, 56500ul, 62500ul, LOW},
  {7, 56500ul, 64500ul, LOW},
  {8, 64500ul, 84500ul, LOW}
};

const byte nbElementSequence = sizeof(maSequence) / sizeof(maSequence[0]);

/* Partie "capteur ULTRASON"  */
const byte trigPin = 4;
const byte echoPin = 5;
const int distanceCritique = 11; // en cm

/* Partie " fonctions " */
int lireDistance()
{
  static int cm;


  digitalWrite(trigPin, HIGH);
    delayMicroseconds(10);
    digitalWrite(trigPin, LOW);
    cm = pulseIn(echoPin, HIGH) / 58;
  
  Serial.print("Distance cm : ");
  Serial.println( cm);
  return cm;


}
  unsigned long topDistanceCritique;
void setup() {
    pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  digitalWrite(trigPin, LOW);
  delay (20);
  Serial.begin(115200);
  for (byte i = 0; i < nbElementSequence; i++) {
    pinMode(maSequence[i].numPin, OUTPUT);//////////////////////pinMode(pinArray[count], OUTPUT);
    digitalWrite(maSequence[i].numPin, maSequence[i].etat);
  }

  topDistanceCritique = 2300ul; // on simule que l'on est passé sous 11cm à ce moment là
}

void loop()
{
 int distance = lireDistance();
if (distance < distanceCritique)

{


 digitalWrite( maSequence[numPin],HIGH);


}
  
 }

Comment aller chercher les elements 'numPin ’ ( de la séquence du tableau pour les mettre dans
la loop ?

et unsigned long debut;
unsigned long fin;
byte etat;
ils doivent bien servir à quelque chose ;
comment puis-je les utiliser ?
Merci de m’orienter,
Amicalement
Frida

Bonsoir FRIDA24

Pour ressortir le numpin de l’élément 2 du tableau:

int newNumPin = maSequence[2].numPin;

Cette façon d’atteindre une variable dans une structure te permettra de répondre aux autres questions, si pas le cas, n’hésite pas.

Cordialement
jpbbricole

Merci pour ta réponse, :slight_smile:
je vois ça demain,et te dis quoi
Frida

Bonjour Frida

Hier j'ai oublié, regardes, ici, une explication des structures.

Bonne journée
jpbbricole

Bonjour Frida, je vous avais mis exprès dans le setup() un usage d’une boucle pour lire toutes les pins et les metttre en output et dans le bon état initial:

  for (byte i = 0; i < nbElementSequence; i++) {
    pinMode(maSequence[i].numPin, OUTPUT);
    digitalWrite(maSequence[i].numPin, maSequence[i].etat);
  }

ça aurait dû vous aider à comprendre l’accès aux éléments d’un tableau, et comme c’est un tableau de structures (un groupe de variables) comment accéder à une des ces variables (numPin ou etat).

Commencez par écrire - pour jouer un peu et comprendre - un bout de code dans le setup() qui imprime le contenu du tableau (chaque élément de la structure) et postez le ici.

Ensuite dans la loop, si la distance critique a été franchie, vous devez tester si chaque pin est LOW et dans ce cas voir si c’est le moment où vous devez la passer HIGH (donc si millis()- topDistanceCritique est entre XXX et YYY) ou si la pin est déjà high de voir si c’est le bon moment pour éteindre (donc si millis()- topDistanceCritique est plus grand que YYY).

Procédez par étapes là aussi: commencez par ne pas tenir compte du capteur de distance et de prendre le topDistanceCritique que j’ai mis dans le set up comme étant le top départ et gérez dans la loop le séquencement des pins (Je vous laisse réfléchir à comment trouver XXX, YYY pour chaque pin)

Enfin ajoutez le capteur et trouvez comment gérer le topDistanceCritique

Merci JML,
J'ai donc de quoi m'occuper aujourd'hui..
Cordialement

Bonsoir,
Voilà ce que j’ai pu faire:

struct elementSequence_t {
  byte numPin;
  unsigned long debut;
  unsigned long fin;
  byte etat;
};

elementSequence_t maSequence[] = {   //  Initialiser la structure elementSequence_t avec les variables  maSequence[]
  {11, 0ul, 500ul, LOW},
  {6, 500ul, 8500ul, LOW},
  {13, 500ul, 6500ul, LOW},
  {10, 8500ul, 38500ul, HIGH},
  {9, 8500ul, 18500ul, HIGH},
  {7, 18500ul, 26500ul, HIGH},
  {6, 38500ul, 46500ul, LOW},
  {12, 46500ul, 56500ul, LOW},
  {3, 56500ul, 62500ul, LOW},
  {7, 56500ul, 64500ul, HIGH},
  {8, 64500ul, 84500ul, HIGH}
};
const byte nbElementSequence = sizeof(maSequence) / sizeof(maSequence[0]);
unsigned long topDistanceCritique;

void setup() {
  Serial.begin(115200);
  for (byte i = 0; i < nbElementSequence; i++) {
    pinMode(maSequence[i].numPin, OUTPUT);
    digitalWrite(maSequence[i].numPin, maSequence[i].etat);
  }

  topDistanceCritique = 2300ul; // on simule que l'on est passé sous 11cm à ce moment là

  Serial.println(maSequence[0].etat );// ceci est l'exercice que m'a demandé mon professeur  :) 
  Serial.println(maSequence[1].etat );
  Serial.println(maSequence[2].etat );
  Serial.println(maSequence[3].etat );
  Serial.println(maSequence[4].etat );
  Serial.println(maSequence[5].etat );
  Serial.println(maSequence[6].etat );
  Serial.println(maSequence[7].etat );
  Serial.println(maSequence[8].etat );
  Serial.println(maSequence[9].etat );
  Serial.println(maSequence[10].etat );


  Serial.println(maSequence[0].numPin );
  Serial.println(maSequence[1].numPin );
  Serial.println(maSequence[2].numPin );
  Serial.println(maSequence[3].numPin );
  Serial.println(maSequence[4].numPin );
  Serial.println(maSequence[5].numPin );
  Serial.println(maSequence[6].numPin );
  Serial.println(maSequence[7].numPin );
  Serial.println(maSequence[8].numPin );
  Serial.println(maSequence[9].numPin );
  Serial.println(maSequence[10].numPin );

  Serial.println(maSequence[0].debut );
  Serial.println(maSequence[1].debut );
  Serial.println(maSequence[2].debut );
  Serial.println(maSequence[3].debut );
  Serial.println(maSequence[4].debut );
  Serial.println(maSequence[5].debut );
  Serial.println(maSequence[6].debut );
  Serial.println(maSequence[7].debut );
  Serial.println(maSequence[8].debut );
  Serial.println(maSequence[9].debut );
  Serial.println(maSequence[10].debut );

  Serial.println(maSequence[0].fin );
  Serial.println(maSequence[1].fin );
  Serial.println(maSequence[2].fin );
  Serial.println(maSequence[3].fin );
  Serial.println(maSequence[4].fin );
  Serial.println(maSequence[5].fin );
  Serial.println(maSequence[6].fin );
  Serial.println(maSequence[7].fin );
  Serial.println(maSequence[8].fin );
  Serial.println(maSequence[9].fin );
  Serial.println(maSequence[10].fin );

  topDistanceCritique = 2300ul; // on simule que l'on est passé sous 11cm à ce moment là
}

void loop()
{


  switch (maSequence[0].etat )
  {
    case LOW:
      if ( millis() - topDistanceCritique > (maSequence[0].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[0].fin ))

          maSequence[0].etat = ! maSequence[0].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[1].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[1].fin ))

          maSequence[1].etat = ! maSequence[1].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[2].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[2].fin ))

          maSequence[0].etat = ! maSequence[2].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[1].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[1].fin ))

          maSequence[1].etat = ! maSequence[1].etat;
      break;


      if ( millis() - topDistanceCritique > (maSequence[3].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[3].fin ))

          maSequence[0].etat = ! maSequence[3].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[4].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[4].fin ))

          maSequence[1].etat = ! maSequence[4].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[5].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[5].fin ))

          maSequence[0].etat = ! maSequence[5].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[6].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[6].fin ))

          maSequence[1].etat = ! maSequence[6].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[7].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[7].fin ))

          maSequence[0].etat = ! maSequence[7].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[8].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[8].fin ))

          maSequence[1].etat = ! maSequence[8].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[9].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[9].fin ))

          maSequence[0].etat = ! maSequence[9].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[10].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[10].fin ))

          maSequence[1].etat = ! maSequence[10].etat;
      break;

    case HIGH:
      if ( millis() - topDistanceCritique > (maSequence[0].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[0].fin ))

          maSequence[0].etat = maSequence[0].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[1].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[1].fin ))

          maSequence[1].etat = maSequence[1].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[2].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[2].fin ))

          maSequence[0].etat = maSequence[2].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[1].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[1].fin ))

          maSequence[1].etat = maSequence[1].etat;
      break;


      if ( millis() - topDistanceCritique > (maSequence[3].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[3].fin ))

          maSequence[0].etat = maSequence[3].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[4].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[4].fin ))

          maSequence[1].etat = maSequence[4].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[5].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[5].fin ))

          maSequence[0].etat = maSequence[5].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[6].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[6].fin ))

          maSequence[1].etat = maSequence[6].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[7].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[7].fin ))

          maSequence[0].etat = maSequence[7].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[8].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[8].fin ))

          maSequence[1].etat = maSequence[8].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[9].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[9].fin ))

          maSequence[0].etat = maSequence[9].etat;
      break;

      if ( millis() - topDistanceCritique > (maSequence[10].debut ))
        if ( millis() - topDistanceCritique <= (maSequence[10].fin ))

          maSequence[1].etat = maSequence[10].etat;
      break;
  }
}

Je me rend compte qu’il y a beaucoup de répétitions à certainement simplifier.
D’autre part, le fait que " topDistanceCritique " soit un temps , à relier à une mesure de distance me pose problème.
Aussi j’aimerai que vous me donniez votre avis avant de continuer .
Amicalement
Frida

Euh ya de l’idée pour le;premier écoute mais faut apprendre les boucles...
vous avez regardé comment j’ai fait pour mettre dans le set up toutes les pins en OUTPUT et à LOW?

Pour le second un switch n’est pas trop adapté.. combinez une boucle avec des if

Bonjour JML,
Et comme ça ?

struct elementSequence_t {
  byte numPin;
  unsigned long debut;
  unsigned long fin;
  byte etat;
};

elementSequence_t maSequence[] = {   //  Initialiser la structure elementSequence_t avec les variables  maSequence[]
  {11, 0ul, 500ul, LOW},
  {6, 500ul, 8500ul, LOW},
  {13, 500ul, 6500ul, LOW},
  {10, 8500ul, 38500ul, LOW},
  {9, 8500ul, 18500ul, LOW},
  {7, 18500ul, 26500ul, LOW},
  {6, 38500ul, 46500ul, LOW},
  {12, 46500ul, 56500ul, LOW},
  {3, 56500ul, 62500ul, LOW},
  {7, 56500ul, 64500ul, LOW},
  {8, 64500ul, 84500ul, LOW}
};
const byte nbElementSequence = sizeof(maSequence) / sizeof(maSequence[0]);
unsigned long topDistanceCritique;

void setup() {
  Serial.begin(115200);
  for (byte i = 0; i < nbElementSequence; i++) {
    pinMode(maSequence[i].numPin, OUTPUT);
    digitalWrite(maSequence[i].numPin, maSequence[i].etat);
  }

  topDistanceCritique = 2300ul; // on simule que l'on est passé sous 11cm à ce moment là

  for (byte i = 0; i < nbElementSequence; i++) {
    Serial.println(maSequence[i].etat );
    Serial.println(maSequence[i].numPin );
    Serial.println(maSequence[i].debut );
    Serial.println(maSequence[i].fin );

    topDistanceCritique = 2300ul; // on simule que l'on est passé sous 11cm à ce moment là
  }
}
void loop()
{
  for (byte i = 0; i < nbElementSequence; i++) {
    if ((maSequence[i].etat == LOW ) && millis() >= (maSequence[i].debut )) {
      maSequence[i].etat == HIGH;

      if ((maSequence[i].etat == HIGH ) && millis() >= (maSequence[i].fin )) {
        maSequence[i].etat == LOW;
      }
    }
  }
}

Merci
Frida

c’est déjà bcp mieux et bcp plus court, non? :slight_smile: :smiley:

cela dit:

Que fait le

topDistanceCritique = 2300ul; // on simule que l'on est passé sous 11cm à ce moment là

dans la boucle for de l’exercice ? pas besoin de répéter cela 11 fois :slight_smile:

dans la boucle, une fois que le temps de fin est dépassé (plus grand que maSequence[ i].fin) → vous avez éteint la LED, que va-t-il se passer au prochain tour de boucle quand vous testez si la LED est LOW et que le temps est plus grand que le début ? petit soucis là :slight_smile:

bien sûr pour allumer la LED il ne faut pas qu’enregistrer l’état, un petit digitalWrite serait utile aussi, non ?

enfin - il y a un petit soucis sur la comparaison au niveau du temps: ce n’est pas directement millis() qu’il faut comparer avec debut et fin (car début et fin sont des moments absolus par rapport au t0 qui sera le moment où votre distance est passée sous 11cm) → c’est là où la variable topDistanceCritique doit rentrer en ligne de compte… → comment doivent s’écrire les test sur le temps donc?

qu’en pensez vous ?

struct elementSequence_t {
  byte numPin;
  unsigned long debut;
  unsigned long fin;
  byte etat;
};

elementSequence_t maSequence[] = {   //  Initialiser la structure elementSequence_t avec les variables  maSequence[]
  {11, 0ul, 500ul, LOW},
  {6, 500ul, 8500ul, LOW},
  {13, 500ul, 6500ul, LOW},
  {10, 8500ul, 38500ul, LOW},
  {9, 8500ul, 18500ul, LOW},
  {7, 18500ul, 26500ul, LOW},
  {6, 38500ul, 46500ul, LOW},
  {12, 46500ul, 56500ul, LOW},
  {3, 56500ul, 62500ul, LOW},
  {7, 56500ul, 64500ul, LOW},
  {8, 64500ul, 84500ul, LOW}
};
const byte nbElementSequence = sizeof(maSequence) / sizeof(maSequence[0]);
unsigned long topDistanceCritique;

void setup() {
  Serial.begin(115200);
  topDistanceCritique = 2300ul; // on simule que l'on est passé sous 11cm à ce moment là

  for (byte i = 0; i < nbElementSequence; i++) {
    pinMode(maSequence[i].numPin, OUTPUT);
    digitalWrite(maSequence[i].numPin, maSequence[i].etat);
  }
  for (byte i = 0; i < nbElementSequence; i++) {
    Serial.println(maSequence[i].etat );
    Serial.println(maSequence[i].numPin );
    Serial.println(maSequence[i].debut );
    Serial.println(maSequence[i].fin );
  }
}
void loop()
{
  for (byte i = 0; i < nbElementSequence; i++) {
    if ((maSequence[i].etat == LOW ) && ( millis() - topDistanceCritique ) >= (millis() - maSequence[i].debut )) {
      maSequence[i].etat == HIGH;
      digitalWrite(maSequence[i].etat, HIGH);

      if ((maSequence[i].etat == HIGH ) && ( millis() - topDistanceCritique) >= (maSequence[i].fin )) {
        maSequence[i].etat == LOW;
        digitalWrite(maSequence[i].etat, LOW);
      }
    }
  }
}

Que fait le…topDistanceCritique = 2300ul; // on simule que l'on est passé sous 11cm à ce moment là Rien, j’ai oublié de l’enlever

C’est bcp mieux sur la gestion du temps mais vous avez une erreur de logique sur les tests (et un bug dans les digitalWrite - vérifiez donc sur quelle pin vous essayez d’écrire)

Pour la partie erreur de logique demandez vous si vous êtes à l’instant relatif T ce que vous devez faire pour l’entree i du tableau —> Quand est-ce que la pin doit être ON et quand doit elle être OFF?

Bonsoir,
J’ai corrigé le bug dans les digitalWrite, est-ce bon ?

Pour l’ erreur de logique, je crois que, à l’instant où ça rentre dans la loop ,( maSequence_.debut ) c’est sur “off” ,puis on doit le mettre sur " on" , puis au moment ou ça fini, maSequence*.fin , on met sur “off”, et on recommence …_
Soit , avant de commencer , tout est à “off”, à distance critique atteinte => 0 ul : pin 11 passe à “on” et à 500 ul pin 11 passe à “off” en même temps que pin 6 passe à “on” etc… Et à 84500ul pin 8 passe à “off”, et tout se retrouve à off jusqu’à la prochaine détection d’une 'distance critique.
Je vous ai mis les "off (=0) et les on (=1) que j’ai noté sur le moniteur série.
Mais en réalité ça va pas… et le code est le même que celui que vous m’avez dit de changer !
Mais ,malgré mes recherches , je n’arrive pas à voir ce qui cloche.
Il est vrai que j’ai du mal avec les termes " maSequence, nbElementSequence ,maSequence_.debutmaSequence.etat "pour voir exactement ce qu’ils représentent dans le code ,ce langage de programmation est un peu confus pour moi .
Merci de votre soutien et de l’aide que vous m’apportez .
Frida
code avec les résultats au moniteur série :
```*_

*struct elementSequence_t {
  byte numPin;
  unsigned long debut;
  unsigned long fin;
  byte etat;
};
elementSequence_t maSequence = {  //  Initialiser la structure elementSequence_t avec les variables  maSequence
  {11, 0ul, 500ul, LOW},
  {6, 500ul, 8500ul, LOW},
  {13, 500ul, 6500ul, LOW},
  {10, 8500ul, 38500ul, LOW},
  {9, 8500ul, 18500ul, LOW},
  {7, 18500ul, 26500ul, LOW},
  {6, 38500ul, 46500ul, LOW},
  {12, 46500ul, 56500ul, LOW},
  {3, 56500ul, 62500ul, LOW},
  {7, 56500ul, 64500ul, LOW},
  {8, 64500ul, 84500ul, LOW}
};

const byte nbElementSequence = sizeof(maSequence) / sizeof(maSequence[0]);
unsigned long topDistanceCritique;

void setup()
{
  Serial.begin(115200);
  topDistanceCritique = 2300ul; // on simule que l’on est passé sous 11cm à ce moment là

for (byte i = 0; i < nbElementSequence; i++) {
    pinMode(maSequence[i].numPin, OUTPUT);
    digitalWrite(maSequence[i].numPin, maSequence[i].etat);
  }
}
void loop()
{
  for (byte i = 0; i < nbElementSequence; i++) {                          /////// Au départ c’est à OFF
    Serial.println(55);// pour marquer le début
    if ((maSequence[i].etat == LOW ) && ( millis() - topDistanceCritique ) >= (millis() - maSequence[i].debut )) {
    //                                                Serial.println(maSequence[i].etat );---->  0FF
      maSequence[i].etat = HIGH;
      //                                              Serial.println(maSequence[i].etat );---->    ON
      digitalWrite(maSequence[i].etat, HIGH);
    //                                              Serial.println(maSequence[i].etat );---->    ON
    //                                                              Serial.println( maSequence[i].numPin);----> voir commentaire
      if ((maSequence[i].etat == HIGH ) && ( millis() - topDistanceCritique) >= (maSequence[i].fin ))
      //                                                              Serial.println( maSequence[i].numPin);----> voir commentaire
      //                                              Serial.println(maSequence[i].etat );---->    ON
      maSequence[i].etat = LOW;
      //                                              Serial.println(maSequence[i].etat );---->    0FF
      digitalWrite(maSequence[i].etat, LOW);
      //                                              Serial.println(maSequence[i].etat );---->    0FF
    }
  }
}

_*_</em></em></em> <em><em><em>_*Et code sans les résultats au moniteur série :*_</em></em></em> <em><em><em>_**_
*struct elementSequence_t {
  byte numPin;
  unsigned long debut;
  unsigned long fin;
  byte etat;
};
elementSequence_t maSequence = {  //  Initialiser la structure elementSequence_t avec les variables  maSequence
  {11, 0ul, 500ul, LOW},
  {6, 500ul, 8500ul, LOW},
  {13, 500ul, 6500ul, LOW},
  {10, 8500ul, 38500ul, LOW},
  {9, 8500ul, 18500ul, LOW},
  {7, 18500ul, 26500ul, LOW},
  {6, 38500ul, 46500ul, LOW},
  {12, 46500ul, 56500ul, LOW},
  {3, 56500ul, 62500ul, LOW},
  {7, 56500ul, 64500ul, LOW},
  {8, 64500ul, 84500ul, LOW}
};

const byte nbElementSequence = sizeof(maSequence) / sizeof(maSequence[0]);
unsigned long topDistanceCritique;

void setup()
{
  Serial.begin(115200);
  topDistanceCritique = 2300ul; // on simule que l’on est passé sous 11cm à ce moment là

for (byte i = 0; i < nbElementSequence; i++) {
    pinMode(maSequence[i].numPin, OUTPUT);
    digitalWrite(maSequence[i].numPin, maSequence[i].etat);
  }
}
void loop()
{
  for (byte i = 0; i < nbElementSequence; i++) {                     
    Serial.println(55);// pour marquer le début
    if ((maSequence[i].etat == LOW ) && ( millis() - topDistanceCritique ) >= (millis() - maSequence[i].debut )) {                                               
      maSequence[i].etat = HIGH;                                           
      digitalWrite(maSequence[i].etat, HIGH);                                                                                                       
      if ((maSequence[i].etat == HIGH ) && ( millis() - topDistanceCritique) >= (maSequence[i].fin ))                                                                                                     
      maSequence[i].etat = LOW;                                           
      digitalWrite(maSequence[i].etat, LOW);                                           
    }
  }
}

_```*_

imaginez pour la pin 6 on allume à début = 500 et on éteinte à fin=8500.

vous êtes LOW, le temps T vaut 400, c'est avant début --> on ne fait rien
vous êtes LOW, le temps T vaut 500, c'est bon on est au début on allume la LED
On est maintenant HIGH
T vaut 3000, 4000, 5000, 6000 etc on ne fait rien
On arrive à T=8500, c'est la fin donc on éteint la LED --> on est LOW.

maintenant à la prochaine boucle vous allez avoir T=8501 et vous êtes LOW.

Vous testez donc si T est plus grand que début, soit est-ce que 8501 est plus grand que 500... la réponse est vraie et donc vous allumez la LED --> Ooops problème...

le LED ne doit être allumé que ENTRE début et fin...

--> ça vous donne une meilleur idée?

Qu’en pensez vous ?

struct elementSequence_t {
  byte numPin;
  unsigned long debut;
  unsigned long fin;
  byte etat;
};

elementSequence_t maSequence[] = {   //  Initialiser la structure elementSequence_t avec les variables  maSequence[]
  {11, 0ul, 500ul, LOW},
  {6, 500ul, 8500ul, LOW},
  {13, 500ul, 6500ul, LOW},
  {10, 8500ul, 38500ul, LOW},
  {9, 8500ul, 18500ul, LOW},
  {7, 18500ul, 26500ul, LOW},
  {6, 38500ul, 46500ul, LOW},
  {12, 46500ul, 56500ul, LOW},
  {3, 56500ul, 62500ul, LOW},
  {7, 56500ul, 64500ul, LOW},
  {8, 64500ul, 84500ul, LOW}
};

const byte nbElementSequence = sizeof(maSequence) / sizeof(maSequence[0]);
unsigned long topDistanceCritique;

void setup()
{
  Serial.begin(115200);
  topDistanceCritique = 2300ul; // on simule que l'on est passé sous 11cm à ce moment là

  for (byte i = 0; i < nbElementSequence; i++) {
    pinMode(maSequence[i].numPin, OUTPUT);
    digitalWrite(maSequence[i].numPin, maSequence[i].etat);
  }
}
void loop()
{
  for (byte i = 0; i < nbElementSequence; i++) {

    if (( millis() - topDistanceCritique)  < (millis() - maSequence[i].debut )) { }

    if ( (( millis() - topDistanceCritique)  >= (millis() - maSequence[i].debut )) &&   (( millis() - topDistanceCritique) <= (millis() - maSequence[i].fin )))
    {
      maSequence[i].etat = HIGH;
      digitalWrite(maSequence[i].etat, HIGH);
    }

    if (( millis() - topDistanceCritique) > (millis() - maSequence[i].fin ))
    {
      maSequence[i].etat = HIGH;
      digitalWrite(maSequence[i].etat, HIGH);
    }
  }
}

Ce ne serait pas un cas de machine à état, ou on laisse comme ça ( … si ça va …)?

C’est quoi ça if (( millis() - topDistanceCritique)  < (millis() - maSequence[i].debut )) { }faut relire ce que vous postez… Quand on voit ça on se dit que vous y allez au pif…

Pourquoi vous faites une soustraction entre millis et début et fin ??

Prenez un bout de papier et écrivez le temps commme je l’ai fait ci dessus et regardez quelles doivent être les comparaisons

Une fois que ce sera corrigé il faudra rajouter le capteur, c’est là qu’une petite machine à état (ai-je déclenché sous 11cm ou pas) sera utilsée

Bonjour,
Avant de voir pour rajouter le capteur, pourriez vous me donner votre avis sur mon code revu?

Merci

long prevMillis=0;  // variable utilisée de 0 à 84500
unsigned long n=1; //variable utisée pour compter le nombre de tours de la loop, permet d'utiliser prevMillis en mode modulo
struct elementSequence_t {
  byte numPin;
  unsigned long debut;
  unsigned long fin;
  byte etat;
};
elementSequence_t maSequence[] = {   //  Initialiser la structure elementSequence_t avec les variables  maSequence[]
  {11, 0ul, 500ul, LOW},
  {6, 500ul, 8500ul, LOW},
  {13, 500ul, 6500ul, LOW},
  {10, 8500ul, 38500ul, LOW},
  {9, 8500ul, 18500ul, LOW},
  {7, 18500ul, 26500ul, LOW},
  {6, 38500ul, 46500ul, LOW},
  {12, 46500ul, 56500ul, LOW},
  {3, 56500ul, 62500ul, LOW},
  {7, 56500ul, 64500ul, LOW},
  {8, 64500ul, 84500ul, LOW}
};

const byte nbElementSequence = sizeof(maSequence) / sizeof(maSequence[0]);
unsigned long topDistanceCritique;

void setup()
{
  Serial.begin(115200);
  topDistanceCritique = 2300ul; // on simule que l'on est passé sous 11cm à ce moment là

  for (byte i = 0; i < nbElementSequence; i++) {
    pinMode(maSequence[i].numPin, OUTPUT);
    digitalWrite(maSequence[i].numPin, maSequence[i].etat);
  }
}
void loop()
{
// Serial. println (millis()-topDistanceCritique);
  for (byte i = 0; i < nbElementSequence; i++)  {

if ((maSequence[i].etat == LOW ) && (millis()- prevMillis)-topDistanceCritique <(maSequence[i].debut )) {
      }  // rien faire

if ((maSequence[i].etat == LOW ) &&( millis()- prevMillis)-topDistanceCritique >= (maSequence[i].debut )) {
      maSequence[i].etat = HIGH;
       digitalWrite(maSequence[i].numPin, HIGH); 
       }

      if ((maSequence[i].etat == HIGH ) &&( millis()- prevMillis)-topDistanceCritique >= (maSequence[i].fin )) {
     
        maSequence[i].etat = LOW;
        digitalWrite(maSequence[i].numPin, LOW);}
        if( millis()> maSequence[10].fin*n ){ prevMillis=millis();n++;}
        Serial. println(millis() );
        Serial. println(prevMillis ); 
        Serial. println(111 );
        Serial. println(millis()-prevMillis ); 
        Serial. println(222 ); 
 Serial. println(n ); 
 Serial. println();
        
}

}

ça a l’air de fonctionner.
Bon Week-end
Frida

non ça ne va pas marcher…

vous n’avez pas besoin de prevMillis (encore moins en long, tout ce qui touche à millis() doit être en unsigned long…) ni de n

comme je l’ai déjà dit il faut absolument tester si vous êtes entre debut et FIN

voici la loop, à vous de remplir les if…

void loop()
{
  unsigned long t0 = millis() - topDistanceCritique;
  for (byte i = 0; i < nbElementSequence; i++) {
    if (maSequence[i].etat == LOW) {
      // on regarde s'il faut l'allumer
      if ((t0 >= maSequence[i].debut) && (t0 <= maSequence[i].fin)) {
          // FAIRE DES TRUCS
      }
    } else {
      // on est HIGH on regarde s'il faut éteindre, c'est uniquement après la fin
      if ((t0 > maSequence[i].fin)) {
          // FAIRE DES TRUCS
      }
    }
  } // end for
}

Bonsoir ,
Voilà ce que j’ai pu faire

 struct elementSequence_t {
  byte numPin;
  unsigned long debut;
  unsigned long fin;
  byte etat;
};
elementSequence_t maSequence[] = {   //  Initialiser la structure elementSequence_t avec les variables  maSequence[]
  {11, 0ul, 500ul, LOW},
  {6, 500ul, 8500ul, LOW},
  {13, 500ul, 6500ul, LOW},
  {10, 8500ul, 38500ul, LOW},
  {9, 8500ul, 18500ul, LOW},
  {7, 18500ul, 26500ul, LOW},
  {6, 38500ul, 46500ul, LOW},
  {12, 46500ul, 56500ul, LOW},
  {3, 56500ul, 62500ul, LOW},
  {7, 56500ul, 64500ul, LOW},
  {8, 64500ul, 84500ul, LOW}
};
const byte nbElementSequence = sizeof(maSequence) / sizeof(maSequence[0]);
unsigned long topDistanceCritique;

void setup() {
  Serial.begin(115200);
  topDistanceCritique = 2300ul; // on simule que l'on est passé sous 11cm à ce moment là
  for (byte i = 0; i < nbElementSequence; i++) {
    pinMode(maSequence[i].numPin, OUTPUT);
    digitalWrite(maSequence[i].numPin, maSequence[i].etat);
  }
}
void loop()
{
  unsigned long t0 = millis() - topDistanceCritique;
  for (byte i = 0; i < nbElementSequence; i++) {
    if (maSequence[i].etat == LOW) {            

      // on regarde s'il faut l'allumer
      if ((t0 >= maSequence[i].debut) && (t0 <= maSequence[i].fin)) {
        // FAIRE DES TRUCS
        digitalWrite(maSequence[i].numPin, HIGH);  //<-----------
      }
    } else {
      // on est HIGH on regarde s'il faut éteindre, c'est uniquement après la fin
      if ((t0 > maSequence[i].fin)) {
        // FAIRE DES TRUCS
        digitalWrite(maSequence[i].numPin, LOW); //<---------
      }
    }
  } // end for
}

Mais, je remarque que pour les pins appelés 2 fois , ( ex pin 6 ou 7 ), elles réagissent la première fois, mais ,après non… Il doit manquer quelque chose, mais je ne vois pas quoi…
:disappointed_relieved: vraiment désolée de vous ennuyer ainsi de par ma nullité :slightly_frowning_face:

qui va donc bien dire à [nobbc] maSequence[i].etat[/nobbc] d'être LOW ou HIGH... je me le demande...