Discussion :

[cliaUlka]

Bonjour à tous !

Je vous explique mon projet :
- j'ai 10 spots à Leds et 10 capteurs ultrasons HC-SR04.
- Dès qu'un capteur détecte une présence, il allume la LED correspondante.
- Pour éviter les clignotement disgracieux j'aimerais que la LED reste allumée 5 secondes par exemple (et que pendant ce temps les autres capteurs continuent d'être interrogés).
- je sais qu'il me faut utiliser la fonction Millis() mais je crois que je ne l'utilise pas correctement dans mon code c'est pour cela que je sollicite vos lumières :

Je me mélange les pinceaux...

Voici mon code utilisant la bibliothèque Newping:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
#include <NewPing.h>
 
#define SONAR_NUM  2 // nombre de sensors
#define MAX_DISTANCE 150 // maximum distance in cm 
#define PING_INTERVAL 33 // millisecondes entre les pings des sensors
 
/* Creation des variables pour les capteurs */
 
unsigned long pingTimer[SONAR_NUM];
unsigned int cm[SONAR_NUM]; // range les distances de chaque ping
uint8_t currentSensor = 0; // permet de determiner quel sensor est actif
 
NewPing sonar[SONAR_NUM] = { NewPing( 48, 49, MAX_DISTANCE), NewPing( 46, 47, MAX_DISTANCE) }; // trigger pin, echo pin, distance maximale pour déclencher un ping
 
 
/* Creation des variables pour les leds */
#define LED_NUM 2 // nombre de leds
const int LED[LED_NUM] = { 5, 6 } ; // on déclare un tableau contenant les constantes des broches
 
int etat_led = LOW; // variable qui peut changer
 
/* variables pour le temps de pause des LEDs*/
unsigned long previousMillis[LED_NUM] = 0; 
const long interval = 5000;

Ensuite le setup :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
void setup() {
  Serial.begin(9600); // bauds
 
  // leds
  for (uint8_t i = 0 ; i <= LED_NUM ; i++) {
    pinMode(LED[i], OUTPUT);
    analogWrite(LED[i], LOW);
  }
 
  pingTimer[0] = millis() + 75; // premier ping a 75millisecondes (millis est le temps depuis lequel le programme est lancé.)
  for (uint8_t i = 1; i < SONAR_NUM; i++) {
    /* mise en place pour lancer chaque sensor. index i du sensor : sa valeur par défaut est de 1,
      on contrôle qu'elle soit inferieure au nombre de sensors et puis on veut l'incrementer */
    pingTimer[i] = pingTimer[i - 1] + PING_INTERVAL; // on détermine le moment auquel chaque capteur enverra un ping
 
  }
}

Mon loop pour interroger les capteurs en cascade :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
void loop() {
  for (uint8_t i = 0; i < SONAR_NUM; i++) { // créer la boucle pour tous les sensors
    if (millis () >= pingTimer[i]) { // le moment ou pas de lancer un ping pour le sensor en question
      pingTimer[i] += PING_INTERVAL * SONAR_NUM; //mise en place du prochain moment ou le sensor enverra un ping
      if (i == 0 && currentSensor == SONAR_NUM - 1) oneSensorCycle();
      sonar[currentSensor].timer_stop();
      currentSensor = i;
      cm[currentSensor] = 0;
      sonar[currentSensor].ping_timer(echoCheck);
    }
  }
}
void echoCheck() {
  if (sonar[currentSensor].check_timer()) {
    cm[currentSensor] = sonar[currentSensor].ping_result / US_ROUNDTRIP_CM; /* US_ROUNDTRIP_CM = 340 */
  }
}

Et enfin je dois allumer mes leds en fonction des résultats des capteurs et maintenir l'allumage 5 secondes après :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
void oneSensorCycle() { // j'extrais les résultats après un cycle de ping complet et en fait quelque chose
 
  unsigned long currentMillis = millis();
 
  for (uint8_t i = 0 ; i < SONAR_NUM ; i++) {
    if ((cm[i] < 30) && (cm[i] > 5)) {
      etat_led = HIGH;
    }
      if (currentMillis - previousMillis[i] >= interval) {
        previousMillis[i] = currentMillis;
        etat_led = LOW;
    }
    else {
      etat_led = LOW;
    }
    analogWrite(LED[i], etat_led);
  }
}

[Jerome Briot]

Tu devrais stocker l'état de chaque LED indépendamment, non ?

Une idée :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void oneSensorCycle() {
 
  unsigned long currentMillis = millis();
 
  for (uint8_t i = 0 ; i < SONAR_NUM ; i++) {
 
    if (etat_led[i] == HIGH && (currentMillis - previousMillis[i]) >= interval)
      etat_led[i] = LOW;
    else if (etat_led[i] == LOW && cm[i] < 30 && cm[i] > 5) {
      etat_led[i] = HIGH;
      previousMillis[i] = currentMillis;
    }
 
    analogWrite(LED[i], etat_led[i]);
 
  }
 
}

[cliaUlka]

Merci pour ta suggestion je vais la tester.

J'ai essayé celle que j'avais faite hier et ... surprise ça marche : par contre j'ai juste enlevé le "else { etat_LED = LOW ; " qui n'avait aucune utilité.
Et aussi j'ai voulu essayer un délai d'allumage aléatoire en activant le spot en utilisant la fonction "random".
comme ça (je vous épargne le code en entier):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
/* variables pour le temps de pause des LEDs*/
unsigned long previousMillis[LED_NUM];
unsigned long delaiAleatoire;
//const long interval = 5000;
 
void setup() {
  Serial.begin(9600); // bauds
// delai et random
delaiAleatoire = random(1000, 25000);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
void oneSensorCycle() { // j'extrais les résultats après un cycle de ping complet et en fait quelque chose
 
  unsigned long currentMillis = millis();
 
  for (uint8_t i = 0 ; i < SONAR_NUM ; i++) {
    if ((cm[i] < 30) && (cm[i] > 5)) {
      etat_led = HIGH;
    }
    if (currentMillis - previousMillis[i] >= delaiAleatoire){      // >= interval) {
      previousMillis[i] = currentMillis;
      etat_led = LOW;
    }
    digitalWrite(LED[i], etat_led);
  }
}

Par contre c'est un "faux" aléatoire ce qui fait que le cycle commence toujours par la même durée d'allumage.
et j'aimerais qu'à chaque début de cycle, ce soit une valeur différente.
Est-ce possible?

[cliaUlka]

Héhé autant pour moi j'avais fait mes tests qu'avec une seule led alors évidemment !
tu as raison Jerôme Briot il faut bien entendu stocker aussi l'état des leds.
merci beaucoup!!