Problème de Plusieurs conditions

Arzou:
Je me suis fait avoir avec le rouge…

Effectivement rouge vaut 13 dans ton code, cest le numéro de sortie, pas sont état…
Il faut que tu créer une variable qui reflète l’état de ta sortie rouge.

En plus tu devrais continuer à donner des noms qui parlent a tes variables

const int trigPin = 2; ok
const int echoPin = 3; ok
const int buzzer = 9; buzzerPin
const int rouge = 13; rougePin
const int vert = 12; vertPin

Par exemple pour continuer dans ta lancée.

// Pour la variable 

bool Feu_rouge=true;
bool Feu_vert=false;



Plus loin… dans ton programme

Feu_vert=false;

Feu_rouge=true;

Allumage ou extinction des feux

digitalWrite(rouge, Feu_rouge);
  digitalWrite(vert, Feu_vert);

Puis

safetyDistance = distance;
if ((safetyDistance <= 5) && (Feu_rouge )){
  digitalWrite(buzzer, HIGH);
}
else{
  digitalWrite(buzzer, LOW)…




Et ca devrait aller mieux

Merci pour ton aide précieuse je vais essayer

Sa ne fonctionne toujours pas, en fait les leds ce sont un feu de circulation et le capteur c'est comme un radar de feu donc en gros prenons l'exemple des feus de circulation avec radar dessus, Quand une voiture passe à un feu rouge le radar flash, donc ici j'aimerai que quand une voiture passe au rouge il y ait un son qui sorte du buzzer.

J'aimerai bien avoir cette grosse aide parce que moi et mon groupe avons pris beaucoup de retard sur le projet donc j'aimerai avoir fini le projet avant la fin de l'année scolaire (avant le BAC STI2D SIN)

Déjà as tu essayé le prog blink? fonctionne t il chez toi?

Blink

sinon un bon conseil, va voir ici Le Blog d'Eskimom

eric_wagner:
Sa ne fonctionne toujours pas, en fait les leds ce sont un feu de circulation et le capteur c'est comme un radar de feu donc en gros prenons l'exemple des feus de circulation avec radar dessus, Quand une voiture passe à un feu rouge le radar flash, donc ici j'aimerai que quand une voiture passe au rouge il y ait un son qui sorte du buzzer.

J'aimerai bien avoir cette grosse aide parce que moi et mon groupe avons pris beaucoup de retard sur le projet donc j'aimerai avoir fini le projet avant la fin de l'année scolaire (avant le BAC STI2D SIN)

j'ai un peu modifié mon post #19

lors de tes test que te donne Serial?

hello
à tester

/*
 * on suppose que le buzzer est de type actif
 * c'est à dire qu'il se contente de +5V pour retentir
 * un autre type de buzzer ( passif ) 
 * à besoin d'une fréquence pour retentir
 * 
 * mettre moniteur en 115200
 * 
 * une fois le fonctionnement demontrer
 * il faudra allonger la constante "duree_feu"
 */

const int duree_feu= 3000;      // 3000 pour test, ensuite mettre plus long
const byte trigPin =    2;      // ultrason emission
const byte echoPin =    3;      // ultrason reception
const byte buzzer  =    9;      // alarme
const byte rouge   =   13;      // pin de cde led rouge
const byte vert    =   12;      // pin de cde led verte
long  duree        =    0;      // temps de retour ultrason
int distance_mesuree=   0;      // distance mesuree par ultrason
unsigned long deb_tempo=0;
void setup() {
pinMode(trigPin,  OUTPUT);      // ultrason emission est une sortie
pinMode(echoPin,   INPUT);      // ultrason reception est une entree
pinMode(buzzer,   OUTPUT);      // le buzzer d'alarme est une sortie
pinMode(rouge,    OUTPUT);      // la commande de la led rouge est une sortie
pinMode(vert,     OUTPUT);      // la commande de la led verte est une sortie
Serial.begin(115200);           // initialise la liaison serie avec le moniteur à 115200 bauds
digitalWrite(rouge, HIGH);      // le feu passe au rouge
digitalWrite(vert,   LOW);      // le feu vert est eteint
deb_tempo=millis();
}

void loop() {
  if ((millis()-deb_tempo) >= duree_feu)
  {
    inverse_feu();
    deb_tempo=millis();
  }
if((digitalRead(rouge)) == HIGH)//si le feu est rouge
{
digitalWrite(trigPin, LOW);     // ultrason emission au repos avant enoi d'un pulse
delayMicroseconds(2);           // tempo de securisation du repos
digitalWrite(trigPin, HIGH);    // envoi d'un pulse
delayMicroseconds(10);          // de 10 micro-secondes
digitalWrite(trigPin, LOW);     // fin de l'envoi du pulse
duree = pulseIn(echoPin, HIGH); // le pulse est revenu en x microsecondes (aller/retour)
distance_mesuree= duree*0.034/2;// calcul de la distance de l'obstacle 
//distance_mesuree=4;           //pour test
if (distance_mesuree < 5)       // si une voiture est à moins de 5 cm 
{
  digitalWrite(buzzer, HIGH);   // le feu rouge à été grillé, l'alarme est déclenchée
  Serial.print("alarme ON "); 
}
else{
  digitalWrite(buzzer, LOW);    // sinon, pas d'alarme
  Serial.print("alarme OFF ");  
    }
  
     Serial.print("Distance: ");   // affichage de la distance de la voiture sur le moniteur
     Serial.println(distance_mesuree);
    }
}
void inverse_feu()
{
  if ((digitalRead(rouge))==HIGH)
  {
  digitalWrite(vert, HIGH);     // le feu passe au vert
  Serial.println("le feu est vert");
  digitalWrite(rouge, LOW);     // le feu rouge est eteint
  Serial.println("le feu n'est pas rouge");
  }
  else
  {
  digitalWrite(rouge, HIGH);    // le feu passe au rouge
  Serial.println("le feu est rouge");
  digitalWrite(vert, LOW);      // le feu vert est eteint
  Serial.println("le feu n'est pas vert");
  }
}

dfgh:
hello
à tester

/*
  • on suppose que le buzzer est de type actif
  • c’est à dire qu’il se contente de +5V pour retentir
  • un autre type de buzzer ( passif )
  • à besoin d’une fréquence pour retentir
  • mettre moniteur en 115200
  • une fois le fonctionnement demontrer
  • il faudra allonger la constante “duree_feu”
    */

const int duree_feu= 3000;      // 3000 pour test, ensuite mettre plus long
const byte trigPin =    2;      // ultrason emission
const byte echoPin =    3;      // ultrason reception
const byte buzzer  =    9;      // alarme
const byte rouge  =  13;      // pin de cde led rouge
const byte vert    =  12;      // pin de cde led verte
long  duree        =    0;      // temps de retour ultrason
int distance_mesuree=  0;      // distance mesuree par ultrason
unsigned long deb_tempo=0;
void setup() {
pinMode(trigPin,  OUTPUT);      // ultrason emission est une sortie
pinMode(echoPin,  INPUT);      // ultrason reception est une entree
pinMode(buzzer,  OUTPUT);      // le buzzer d’alarme est une sortie
pinMode(rouge,    OUTPUT);      // la commande de la led rouge est une sortie
pinMode(vert,    OUTPUT);      // la commande de la led verte est une sortie
Serial.begin(115200);          // initialise la liaison serie avec le moniteur à 115200 bauds
digitalWrite(rouge, HIGH);      // le feu passe au rouge
digitalWrite(vert,  LOW);      // le feu vert est eteint
deb_tempo=millis();
}

void loop() {
  if ((millis()-deb_tempo) >= duree_feu)
  {
    inverse_feu();
    deb_tempo=millis();
  }
if((digitalRead(rouge)) == HIGH)//si le feu est rouge
{
digitalWrite(trigPin, LOW);    // ultrason emission au repos avant enoi d’un pulse
delayMicroseconds(2);          // tempo de securisation du repos
digitalWrite(trigPin, HIGH);    // envoi d’un pulse
delayMicroseconds(10);          // de 10 micro-secondes
digitalWrite(trigPin, LOW);    // fin de l’envoi du pulse
duree = pulseIn(echoPin, HIGH); // le pulse est revenu en x microsecondes (aller/retour)
distance_mesuree= duree*0.034/2;// calcul de la distance de l’obstacle
//distance_mesuree=4;          //pour test
if (distance_mesuree < 5)      // si une voiture est à moins de 5 cm
{
  digitalWrite(buzzer, HIGH);  // le feu rouge à été grillé, l’alarme est déclenchée
  Serial.print("alarme ON ");
}
else{
  digitalWrite(buzzer, LOW);    // sinon, pas d’alarme
  Serial.print("alarme OFF "); 
    }
 
    Serial.print("Distance: ");  // affichage de la distance de la voiture sur le moniteur
    Serial.println(distance_mesuree);
    }
}
void inverse_feu()
{
  if ((digitalRead(rouge))==HIGH)
  {
  digitalWrite(vert, HIGH);    // le feu passe au vert
  Serial.println(“le feu est vert”);
  digitalWrite(rouge, LOW);    // le feu rouge est eteint
  Serial.println(“le feu n’est pas rouge”);
  }
  else
  {
  digitalWrite(rouge, HIGH);    // le feu passe au rouge
  Serial.println(“le feu est rouge”);
  digitalWrite(vert, LOW);      // le feu vert est eteint
  Serial.println(“le feu n’est pas vert”);
  }
}

je vais essayé

dfgh:
hello
à tester

/*
  • on suppose que le buzzer est de type actif
  • c’est à dire qu’il se contente de +5V pour retentir
  • un autre type de buzzer ( passif )
  • à besoin d’une fréquence pour retentir
  • mettre moniteur en 115200
  • une fois le fonctionnement demontrer
  • il faudra allonger la constante “duree_feu”
    */

const int duree_feu= 3000;      // 3000 pour test, ensuite mettre plus long
const byte trigPin =    2;      // ultrason emission
const byte echoPin =    3;      // ultrason reception
const byte buzzer  =    9;      // alarme
const byte rouge  =  13;      // pin de cde led rouge
const byte vert    =  12;      // pin de cde led verte
long  duree        =    0;      // temps de retour ultrason
int distance_mesuree=  0;      // distance mesuree par ultrason
unsigned long deb_tempo=0;
void setup() {
pinMode(trigPin,  OUTPUT);      // ultrason emission est une sortie
pinMode(echoPin,  INPUT);      // ultrason reception est une entree
pinMode(buzzer,  OUTPUT);      // le buzzer d’alarme est une sortie
pinMode(rouge,    OUTPUT);      // la commande de la led rouge est une sortie
pinMode(vert,    OUTPUT);      // la commande de la led verte est une sortie
Serial.begin(115200);          // initialise la liaison serie avec le moniteur à 115200 bauds
digitalWrite(rouge, HIGH);      // le feu passe au rouge
digitalWrite(vert,  LOW);      // le feu vert est eteint
deb_tempo=millis();
}

void loop() {
  if ((millis()-deb_tempo) >= duree_feu)
  {
    inverse_feu();
    deb_tempo=millis();
  }
if((digitalRead(rouge)) == HIGH)//si le feu est rouge
{
digitalWrite(trigPin, LOW);    // ultrason emission au repos avant enoi d’un pulse
delayMicroseconds(2);          // tempo de securisation du repos
digitalWrite(trigPin, HIGH);    // envoi d’un pulse
delayMicroseconds(10);          // de 10 micro-secondes
digitalWrite(trigPin, LOW);    // fin de l’envoi du pulse
duree = pulseIn(echoPin, HIGH); // le pulse est revenu en x microsecondes (aller/retour)
distance_mesuree= duree*0.034/2;// calcul de la distance de l’obstacle
//distance_mesuree=4;          //pour test
if (distance_mesuree < 5)      // si une voiture est à moins de 5 cm
{
  digitalWrite(buzzer, HIGH);  // le feu rouge à été grillé, l’alarme est déclenchée
  Serial.print("alarme ON ");
}
else{
  digitalWrite(buzzer, LOW);    // sinon, pas d’alarme
  Serial.print("alarme OFF "); 
    }
 
    Serial.print("Distance: ");  // affichage de la distance de la voiture sur le moniteur
    Serial.println(distance_mesuree);
    }
}
void inverse_feu()
{
  if ((digitalRead(rouge))==HIGH)
  {
  digitalWrite(vert, HIGH);    // le feu passe au vert
  Serial.println(“le feu est vert”);
  digitalWrite(rouge, LOW);    // le feu rouge est eteint
  Serial.println(“le feu n’est pas rouge”);
  }
  else
  {
  digitalWrite(rouge, HIGH);    // le feu passe au rouge
  Serial.println(“le feu est rouge”);
  digitalWrite(vert, LOW);      // le feu vert est eteint
  Serial.println(“le feu n’est pas vert”);
  }
}

Ceci Fonctionne mais quand le feu est rouge et que le capteur est en on le temps doit s’arreter pendant 20 secondes et reprendre une fois que les 20 secondes soient finies

Merci pour cette Enorme aide

tu n’es pas clair
il ne faut pas donner les infos au compte goutte
cela fait un cahier des charges évolutif.
je t’ai tenté ceci sans savoir si c’est bien ce que tu veux

/*
 * on suppose que le buzzer est de type actif
 * c'est à dire qu'il se contente de +5V pour retentir
 * un autre type de buzzer ( passif ) 
 * à besoin d'une fréquence pour retentir
 * 
 * mettre moniteur en 115200
 * 
 * une fois le fonctionnement demontrer
 * il faudra allonger la constante "duree_feu"
 */
const int duree_buzzer=2000;
const int duree_feu= 5000;      // 3000 pour test, ensuite mettre plus long
const byte trigPin =    2;      // ultrason emission
const byte echoPin =    3;      // ultrason reception
const byte buzzer  =    9;      // alarme
const byte rouge   =   13;      // pin de cde led rouge
const byte vert    =   12;      // pin de cde led verte
long  duree        =    0;      // temps de retour ultrason
int distance_mesuree=   0;      // distance mesuree par ultrason
unsigned long deb_tempo=0;
unsigned long deb_alarme=0;
void setup() {
pinMode(trigPin,  OUTPUT);      // ultrason emission est une sortie
pinMode(echoPin,   INPUT);      // ultrason reception est une entree
pinMode(buzzer,   OUTPUT);      // le buzzer d'alarme est une sortie
pinMode(rouge,    OUTPUT);      // la commande de la led rouge est une sortie
pinMode(vert,     OUTPUT);      // la commande de la led verte est une sortie
Serial.begin(115200);           // initialise la liaison serie avec le moniteur à 115200 bauds
digitalWrite(rouge, HIGH);      // le feu passe au rouge
digitalWrite(vert,   LOW);      // le feu vert est eteint
deb_tempo=millis();

}

void loop() {
  if ((millis()-deb_tempo) >= duree_feu)
  {
    inverse_feu();
    deb_tempo=millis();
  }
if((digitalRead(rouge)) == HIGH)//si le feu est rouge
{
digitalWrite(trigPin, LOW);     // ultrason emission au repos avant enoi d'un pulse
delayMicroseconds(2);           // tempo de securisation du repos
digitalWrite(trigPin, HIGH);    // envoi d'un pulse
delayMicroseconds(10);          // de 10 micro-secondes
digitalWrite(trigPin, LOW);     // fin de l'envoi du pulse
duree = pulseIn(echoPin, HIGH); // le pulse est revenu en x microsecondes (aller/retour)
distance_mesuree= duree*0.034/2;// calcul de la distance de l'obstacle 
//distance_mesuree=6;;           //pour test
if (distance_mesuree < 5)       // si une voiture est à moins de 5 cm 
{
  deb_alarme=millis();
  while((millis()-deb_alarme) < duree_buzzer)
  {
  digitalWrite(buzzer, HIGH);   // le feu rouge à été grillé, l'alarme est déclenchée
  Serial.println("alarme ON "); 
  }
}
else{
  digitalWrite(buzzer, LOW);    // sinon, pas d'alarme
  Serial.print("alarme OFF ");  
    }
  
     Serial.print("Distance: ");   // affichage de la distance de la voiture sur le moniteur
     Serial.println(distance_mesuree);
    }
}
void inverse_feu()
{
  if ((digitalRead(rouge))==HIGH)
  {
  digitalWrite(vert, HIGH);     // le feu passe au vert
  Serial.println("le feu est vert");
  digitalWrite(rouge, LOW);     // le feu rouge est eteint
  Serial.println("le feu n'est pas rouge");
  }
  else
  {
  digitalWrite(rouge, HIGH);    // le feu passe au rouge
  Serial.println("le feu est rouge");
  digitalWrite(vert, LOW);      // le feu vert est eteint
  Serial.println("le feu n'est pas vert");
  }
}

dfgh:
tu n’es pas clair
il ne faut pas donner les infos au compte goutte
cela fait un cahier des charges évolutif.
je t’ai tenté ceci sans savoir si c’est bien ce que tu veux

/*
  • on suppose que le buzzer est de type actif
  • c’est à dire qu’il se contente de +5V pour retentir
  • un autre type de buzzer ( passif )
  • à besoin d’une fréquence pour retentir
  • mettre moniteur en 115200
  • une fois le fonctionnement demontrer
  • il faudra allonger la constante “duree_feu”
    */
    const int duree_buzzer=2000;
    const int duree_feu= 5000;      // 3000 pour test, ensuite mettre plus long
    const byte trigPin =    2;      // ultrason emission
    const byte echoPin =    3;      // ultrason reception
    const byte buzzer  =    9;      // alarme
    const byte rouge  =  13;      // pin de cde led rouge
    const byte vert    =  12;      // pin de cde led verte
    long  duree        =    0;      // temps de retour ultrason
    int distance_mesuree=  0;      // distance mesuree par ultrason
    unsigned long deb_tempo=0;
    unsigned long deb_alarme=0;
    void setup() {
    pinMode(trigPin,  OUTPUT);      // ultrason emission est une sortie
    pinMode(echoPin,  INPUT);      // ultrason reception est une entree
    pinMode(buzzer,  OUTPUT);      // le buzzer d’alarme est une sortie
    pinMode(rouge,    OUTPUT);      // la commande de la led rouge est une sortie
    pinMode(vert,    OUTPUT);      // la commande de la led verte est une sortie
    Serial.begin(115200);          // initialise la liaison serie avec le moniteur à 115200 bauds
    digitalWrite(rouge, HIGH);      // le feu passe au rouge
    digitalWrite(vert,  LOW);      // le feu vert est eteint
    deb_tempo=millis();

}

void loop() {
  if ((millis()-deb_tempo) >= duree_feu)
  {
    inverse_feu();
    deb_tempo=millis();
  }
if((digitalRead(rouge)) == HIGH)//si le feu est rouge
{
digitalWrite(trigPin, LOW);    // ultrason emission au repos avant enoi d’un pulse
delayMicroseconds(2);          // tempo de securisation du repos
digitalWrite(trigPin, HIGH);    // envoi d’un pulse
delayMicroseconds(10);          // de 10 micro-secondes
digitalWrite(trigPin, LOW);    // fin de l’envoi du pulse
duree = pulseIn(echoPin, HIGH); // le pulse est revenu en x microsecondes (aller/retour)
distance_mesuree= duree*0.034/2;// calcul de la distance de l’obstacle
//distance_mesuree=6;;          //pour test
if (distance_mesuree < 5)      // si une voiture est à moins de 5 cm
{
  deb_alarme=millis();
  while((millis()-deb_alarme) < duree_buzzer)
  {
  digitalWrite(buzzer, HIGH);  // le feu rouge à été grillé, l’alarme est déclenchée
  Serial.println("alarme ON ");
  }
}
else{
  digitalWrite(buzzer, LOW);    // sinon, pas d’alarme
  Serial.print("alarme OFF "); 
    }
 
    Serial.print("Distance: ");  // affichage de la distance de la voiture sur le moniteur
    Serial.println(distance_mesuree);
    }
}
void inverse_feu()
{
  if ((digitalRead(rouge))==HIGH)
  {
  digitalWrite(vert, HIGH);    // le feu passe au vert
  Serial.println(“le feu est vert”);
  digitalWrite(rouge, LOW);    // le feu rouge est eteint
  Serial.println(“le feu n’est pas rouge”);
  }
  else
  {
  digitalWrite(rouge, HIGH);    // le feu passe au rouge
  Serial.println(“le feu est rouge”);
  digitalWrite(vert, LOW);      // le feu vert est eteint
  Serial.println(“le feu n’est pas vert”);
  }
}

sa ne fonctionne pas car le feu passe quand même en vert alors que je voulais qu’il soit de nouveau rouge pendant 20 secondes et après, le buzzer ne doit pas continuer a sonner il doit juste avertir un faux départ ensuite c’est un feu de circulation mais pas comme les autres il doit y avoir un délais qui doit se rajouter pour que la voiture faisant un faux départs se mette en place pour que le chronos du feu puisse recommencer par la suite

Je sais c’est pas très clair mais en gros le feu est rouge, puis si il y a un faux départ le buzzer sonne l’instant de 2 secondes puis le feu reste au rouge et 20 secondes après le chronos du feu recommence et si le chronos est fini sans le faux départs le feu passe au vert et un nouveau chronos commence jusqu’à un autre capteur qui quand une voiture passe devant le chronos s’arrête et le chronos s’affiche dans le moniteur série (rien d’autre)

ton projet évolue encore... :o

il ne faut pas jouer comme ça..........c'est vraiment très désagréable de découvrir les choses au compte goutte. >:(

pour programmer, il faut avoir toutes les données au départ.

je laisse tomber

si un autre gars veut prendre la suite.............

dfgh:
ton projet évolue encore... :o

il ne faut pas jouer comme ça..........c'est vraiment très désagréable de découvrir les choses au compte goutte. >:(

pour programmer, il faut avoir toutes les données au départ.

je laisse tomber

si un autre gars veut prendre la suite.............

et il ne réponds pas aux questions...
je crois que l'on fait le boulot pour lui car tu lui a pondu son programme... et il ne propose rien, aucune piste, ou idée..
j'attends toujours mes réponse au #22 et 23