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);
  }
}