En soit oui mais je me demande si les valeurs ne sont pas incohérentes. Enfin pour le moment les teste se limitaient à mettre ma main plus ou moins près du capteur donc bon ... Je vais faire des essais plus précis dans pas très longtemps

Merci du tuyau, problème de branchements. Et pourtant c'est pas faute d'avoir vérifié. Enfin, comme nous sommes plusieurs sur ce projet, quelqu'un à pu bouger les fils. Merci beacoup

Rien à faire, le code ne marche pas. La date limite approche à très très grands pas, et je ne sais plus dans quel sens prendre le prendre.

#define trigPin 7      //Trig 
#define echoPin 6      //Echo 


void setup() {
  Serial.begin (9600);  
  pinMode(trigPin, OUTPUT);  //On défini Trig comme une sortie
  pinMode(echoPin, INPUT);   //On défini Echo comme une entrée
}

void loop() {
  long duree, distance;
  digitalWrite(trigPin, LOW);  
  delayMicroseconds(2); 
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10); //Trig envois pendant 10ms 
  digitalWrite(trigPin, LOW);
  
  // On calcul le temps pour l'aller retour du signal
  duree = pulseIn(echoPin, HIGH);
  distance = duree*340.0/(2*10000);  
  Serial.print(distance);
if (distance <= 10) // si distance est inférieure ou égale à 10 faire quelque chose
{
 Serial.println("Attention !");
}
  else {
    Serial.print(distance);
    Serial.print(" cm");
  }
  delay(100);
}

J'ai changé les pin pour voir si c'était là le problème, mais non. J'ai vérifié plusieurs fois si c'était un câble inversé avec un autre, mais c'est pas ça non plus. Peut-être juste que ma tête revient pas à la carte ?

Non, plus sérieusement, je suis vraiment perdue. J'ai écrit un code plus complexe que ça et il semble nickel (pas encore testé sur le terrain, pour ça il faudrait que le capteur fonctionne ... ) ...

Ajoutée

Il manque un if avant le else c'est pour ça que le compilateur râle et en plus t'es en dehors du loop sans fonction du coup il ne comprends pas doublement.

D'accord, merci beaucoup

vaut mieux utiliser println qui fait un saut à la ligne ce qui rends les données plus lisibles.

Je prends en note, je vais modifier de ce pas.

Je crois que tu devrai voir les bases du C parce que tu n'as pas l'air de les avoir. (Je ne veux pas être méchant du tout et je m'excuse si le je l'ai déjà dis.)

C'est sûr que je suis débutante. Je n'ai que ce que l'on a vu en cours, c'est à dire rien du tout (ça se limite à faire clignoter une LED d'abord simplement pendant 0.5s, puis pour faire un SOS). Pour le reste, je me base beaucoup sur Internet

Non ce n'est pas de la méchanceté, c'est du réalisme. De plus, le fait de le dire aide à garder les pieds sur terre. Donc pas de soucis

Ok merci.

J'ai fait les modification, ce qui donne ça

#define trigPin 12      //Trig 
#define echoPin 11      //Echo 


void setup() {
  Serial.begin (9600);  
  pinMode(trigPin, OUTPUT);  //On défini Trig comme une sortie
  pinMode(echoPin, INPUT);   //On défini Echo comme une entrée
}

void loop() {
  long duree, distance;
  digitalWrite(trigPin, LOW);  
  delayMicroseconds(2); 
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10); //Trig envois pendant 10ms 
  digitalWrite(trigPin, LOW);
  
  // On calcul le temps pour l'aller retour du signal
  duree = pulseIn(echoPin, HIGH);
  distance = duree*340.0/(2*10000);  
  Serial.println(distance);
}
  else {
    Serial.print(distance);
    Serial.print(" cm ");
  }
  delay(100);
}

Mais j'ai une erreur sur le else. Le logiciel me dit "exit status 1
expected unqualified-id before 'else' ". Je ne comprends pas et je ne peux pas y regarder avant demain

Bonjour bonjour

Pour tester la fiabilité du capteur, j'ai écrit ce petit code

#define trigPin 12      //Trig 
#define echoPin 11      //Echo 


void setup() {
  Serial.begin (9600);  
  pinMode(trigPin, OUTPUT);  //On défini Trig comme une sortie
  pinMode(echoPin, INPUT);   //On défini Echo comme une entrée
}

void loop() {
  long duree, distance;
  digitalWrite(trigPin, LOW);  
  delayMicroseconds(2); 
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10); //Trig envois pendant 10ms 
  digitalWrite(trigPin, LOW);
  
  // On calcul le temps pour l'aller retour du signal
  duree = pulseIn(echoPin, HIGH);
  distance = duree*340/(2*10000);  

   
  //Pour le moniteur série
  if ( distance <= 0){  
    Serial.println("Hors de portee");
  }
  else {
    Serial.print(distance);
    Serial.print(" cm ");
  }
  delay(100);
}

Simplement voilà, quand je vais dans le moniteur série, ça m'affiche "Hors de portée" soit zéro, même quand je met ma main devant le capteur (à plusieurs distances différentes). Je ne vois pas où ça ne marche pas. Le problème viendrais du code où d'ailleurs ?

Merci beaucoup, je vais commencer de ce pas

Merci

Hem, pour le moment il n'avance pas trop niveau programmation ... On est plus centrés sur la définition du scénario et les cours ^^' J'espère que le projet va repartir

Exact, je débute ^^'

Si j'étais toi je me ferai une petite plateforme ou je peux facilement ajouter tout ce que je veux

C'est à dire ? Je crois que je n'ai pas compris

Pour la programmation je ferai quelques exercices faciles (Je peux t'en donner si tu veux.) ce qui permettrai de mieux comprendre.

Eh bien je suis preneuse, merci beaucoup

Okay, j'ai tout compris. Merci beaucoup de ton aide Mike

Je ne comprends pas pour "affiche(int v)". Je dois la définir au début du programme ou j'ai oublié de la mettre quelque part dans le programme ?

Le reste est modifié, merci beaucoup encore une fois

Au fait, je me pose une question. Comme dans le projet je n'ai fait que commander un capteur, le brancher à la carte et faire son programme, je dois tester les deux types de capteurs pour lesquels j'hésitais (ultrasons et infrarouge). Et comme j'ai déjà un programme complet (enfin je crois) sous la main, je me demandais s'il est possible de le changer, à plus ou moins grande échelle, pour l'utiliser pour mon capteur IR.

Il faut dire que j'ai eu un bon professeur   

Le voilà

#define PROCHE 20
#define DANGER 10
#define AFOND 200
#define PRUDENT 50
#define NBMESURE 5
#define VSON 59
définit variables qd faut agir
enum { CASDANGER
     CASPRUDENT
     CASDEFAULT }
//initialisation
int pinSRF=2; //pin numérique utilisé pour le capteur ultrasons.

void setup() {
  Serial.begin(9600);
}

void loop() {
  switch (mesure()){ //utilisation de la condition switch
    case : CASDANGER //l'obstacle est dans la zone DANGER
      Serial.println("*DANGER*");
      arret(); // on arrête le robot
      delay(200);
      recule(PRUDENT); // on le fait reculer un peu
      delay(200);
      break;
    case :CASPRUDENT //l'obstacle est dans la zone PROCHE
      Serial.println("Attention...");
      avance(PRUDENT); // on ralentit la vitesse
    default:
      avance(AFOND);
  }
   }
//fonctions
int mesure(){
  //fonction qui mesure une distance avec le capteur
  unsigned long mesure = 0; // variable de mesure
  unsigned long cumul = 0; //variable pour la moyenne
  for (int t = 0; t < NBMESURE; t++) { // boucle pour effectuer les mesures
    pinMode (pinSRF, OUTPUT); //on prépare le pin pour envoyer le signal
    digitalWrite(pinSRF, LOW); //on commence à l'état bas
    delayMicroseconds(2); //on attend que le signal soit clair
    digitalWrite(pinSRF, HIGH);//mise à l'état haut
    delayMicroseconds(10); //pendant 10 µs
    digitalWrite(pinSRF, LOW); //mise à l'état bas
    pinMode(pinSRF, INPUT); //on prépare le pin pour recevoir un état
    mesure = pulseIn(pinSRF, HIGH); // fonction pulseIn qui attend un état haut et renvoie le temps d'attente
    cumul+=mesure; //on cumule les mesures
    delay(50); //attente obligatoire entre deux mesures
  }
  mesure=cumul/NBMESURE; //on calcule la moyenne des mesures
  mesure=mesure/VSON;//on transforme en cm
 
  if (mesure<=DANGER){//on teste si l'obstacle est dans la zone DANGER
    return CASDANGER; //si oui, on retourne le code de danger
  }
  else if (mesure>DANGER && mesure<=PROCHE){//on teste s'il est dans la zone PROCHE
    return CASPRUDENT; //si oui, on retourne le code de proche
  }
  return CASDEFAULT; // on retourne le code sans risque
}
void recherche(){
  //fonction pour rechercher un passage
  tourneGauche(AFOND); //on positionne le robot à gauche (facultatif)
  delay (300);
  int etat=0; //variable de test de possibilité d'avancer
  while (etat!=2){ // tant que la distance n'est pas suffisante
    etat=mesure(); // on effectue la mesure
    tourneDroite(PRUDENT); //on fait tourner le robot
  }
  Serial.println("La voie est libre !");
  //retour au programme principal
}
void arret(){
  Serial.println("Je stoppe");
  //fonction d'arrêt du moteur
}
void avance(int v){
  Serial.print("J'avance");
  affiche(v);
  //fonction de mise en route du moteur dans le sens avant
}
void recule(int v){
  Serial.print("Je recule");
  //fonction de mise en route du moteur dans le sens arrière
}
void tourneDroite(int v){
  Serial.print("Je tourne a droite");
  //fonction de rotation à droite
}
void tourneGauche(int v){
  Serial.print("Je tourne a gauche");
  //fonction de rotation à gauche
}

Verdict ?

Merci beaucoup pour tes explications Mike

#define PROCHE 20
#define DANGER 10
#define AFOND 200
#define PRUDENT 50
#define NBMESURE 5
#define VSON 59
//initialisation
int pinSRF=2; //pin numérique utilisé pour le capteur ultrasons.

void setup() {
  Serial.begin(9600);
}

void loop() {
  switch (mesure()){ //utilisation de la condition switch
    case 0: //l'obstacle est dans la zone DANGER
      Serial.println("*DANGER*");
      arret(); // on arrête le robot
      delay(200);
      recule(PRUDENT); // on le fait reculer un peu
      delay(200);
      recherche(); // on recherche la bonne voie
      break;
    case 1: //l'obstacle est dans la zone PROCHE
      Serial.println("Attention...");
      avance(PRUDENT); // on ralentit la vitesse
    default:
      avance(AFOND);
  }
   }
//fonctions
int mesure(){
  //fonction qui mesure une distance avec le capteur
  unsigned long mesure = 0; // variable de mesure
  unsigned long cumul = 0; //variable pour la moyenne
  for (int t = 0; t < NBMESURE; t++) { // boucle pour effectuer les mesures
    pinMode (pinSRF, OUTPUT); //on prépare le pin pour envoyer le signal
    digitalWrite(pinSRF, LOW); //on commence à l'état bas
    delayMicroseconds(2); //on attend que le signal soit clair
    digitalWrite(pinSRF, HIGH);//mise à l'état haut
    delayMicroseconds(10); //pendant 10 µs
    digitalWrite(pinSRF, LOW); //mise à l'état bas
    pinMode(pinSRF, INPUT); //on prépare le pin pour recevoir un état
    mesure = pulseIn(pinSRF, HIGH); // fonction pulseIn qui attend un état haut et renvoie le temps d'attente
    cumul+=mesure; //on cumule les mesures
    delay(50); //attente obligatoire entre deux mesures
  }
  mesure=cumul/NBMESURE; //on calcule la moyenne des mesures
  mesure=mesure/VSON;//on transforme en cm
 
  if (mesure<=DANGER){//on teste si l'obstacle est dans la zone DANGER
    return 0; //si oui, on retourne le code de danger
  }
  else if (mesure>DANGER && mesure<=PROCHE){//on teste s'il est dans la zone PROCHE
    return 1; //si oui, on retourne le code de proche
  }
  return 2; // on retourne le code de sans risque
}
void recherche(){
  //fonction pour rechercher un passage
  tourneGauche(AFOND); //on positionne le robot à gauche (facultatif)
  delay (300);
  int etat=0; //variable de test de possibilité d'avancer
  while (etat!=2){ // tant que la distance n'est pas suffisante
    etat=mesure(); // on effectue la mesure
    tourneDroite(PRUDENT); //on fait tourner le robot
  }
  Serial.println("La voie est libre !");
  //retour au programme principal
}
void arret(){
  Serial.println("Je stoppe");
  //fonction d'arrêt des moteurs
}
void avance(int v){
  Serial.print("J'avance");
  affiche(v);
  //fonctin de mise en route des deux moteurs dans le sens avant
  // on utilise la variable v pour le pilotage PWM
}
void recule(int v){
  Serial.print("Je recule");
  affiche(v);
  //fonctin de mise en route des deux moteurs dans le sens arrière
  // on utilise la variable v pour le pilotage PWM
}
void tourneDroite(int v){
  Serial.print("Je tourne a droite");
  affiche(v);
  //fonction de rotation à droite : un moteur dans un sens, l'autre dans le sens opposé
  // on utilise la variable v pour le pilotage PWM
}
void tourneGauche(int v){
  Serial.print("Je tourne a gauche");
  affiche(v);
  //fonction de rotation à gauche : un moteur dans un sens, l'autre dans le sens opposé
  // on utilise la variable v pour le pilotage PWM
}
void affiche(int v){
  //fonction complémentaire d'affichage
  if (v==AFOND){
    Serial.println(" a fond !");
  }
  else{
    Serial.println(" prudemment...");
  }
}

Je crois que c'est mieux comme ça. Je m'excuse pour l'inconfort.

Donc Mike, si j'ai bien compris, je remplace #define par enum, c'est bien ça ?

Il n'est pas prévu pour détecter le feu mais les obstacles devant le robot qui pourraient êtres masqués par la fumée, et donc non-visible par l’œil humain à travers la caméra.

J'ai  vérifié et au niveau de la syntaxe, il n'y a aucun problème. Je me suis mal exprimée; ce que j'entendais, c'est "est-ce que mon programme correspond à ce que je veux ?" car je n'en suis pas sûre ...

Merci de ta réponse thermo_nono

Bonjour,

En bref, je dois faire une robot incendie pour le Bac. Ce robot possède un capteur ultrasons HC-SR04. (plus de détails sur le robot http://www.robot-maker.com/forum/topic/11816-robot-incendie/)
 

Je me questionne donc sur la valibité de mon programme. Est-il bon ? Contient-il des erreurs de définition de variables, des contradictions ... ? Je ne connais pas trop la programmation, alors merci d'avance de votre aide

Après un mois de réflexions, j'ai finit par choisir des capteurs ultrasons, probablement des HC-SR04 à moins qu'un autre type puisse mieux correspondre au projet. Le capteur va être fixé sur un servomoteur et tournera à 180°. Merci à tous pour vos réponses

Et Forthman, comme il s'agit d'un projet scolaire, à aucun moment notre robot s'approchera d'un bon feu. A la rigueur un petit feu de camp, mais pas beaucoup plus

Bonjour à vous et merci pour vos réponses

Salut, brumisateur + capteur us = étincelles.

Un capteur Us avec une porter de 10m devrais être bien et tiendrai le bot a distance du feux. Mais je vois pas l'utilité, surtout si le robot est commandé a distance.

Eh bien comme je l'ai dis plus haut, les capteurs ne servent concrètement à rien. Ils sont juste là pour donner du travail à l'un des membres. Mais en effet ils sont inutiles.

Sur ce site, http://www.sitedunxt.fr/articles/print.php?id=14 il est dit que la variation de température affecte la transmission des ondes de moins d'1%. Donc je pense que le problème ne se pose pas, ou peu. Après je ne suis pas professionnelle, donc je vais demander à des gens qui connaissent mieux que moi

Après une longue absence, je reviens plus déterminée que jamais.

Je me suis enfin décidée pour les capteurs, à savoir des ultrasons. Bon, il reste maintenant à savoir quels capteurs ultrasons prendre ...

Et j'ai aussi trouvé (enfin !) un système pour faire une brume autour des capteurs pour ne pas qu'ils chauffent trop. Je voulais donc votre avis sur le système

http://www.conrad.fr/ce/fr/product/1216692/Brumisateur-piezo-avec-electronique-de-commande-QuickCool-QUV-HEVFT25-16-A-1-pcs/?ref=detview1&rt=detview1&rb=1

Voilà voilà, merci à tous encore une fois

Pardon du temps de réponse et merci beaucoup à tous pour vos suggestions

Il s'agit effectivement d'un projet scolaire, donc nous pouvons nous permettre des choix qui ne seraient pas logiques sur un appareil construit pour aller vraiment sur le terrain. D'où le choix de roues au lieu de chenilles.

Pour les capteurs, il s'agit plus du fait qu'il fallait du travail pour un membre arrivé en cours de route et qu'il fallait lui trouver quelque chose à faire. Ils ne sont donc effectivement pas très utiles mais sinon l'un des membres n'aurait rien à faire.

Pour tester notre robot, nous n'avons encore pas réfléchit à des conditions, mais ça serait plus dans des conditions de feu de camp.

Plus de détails sur le projet, j'ai enfin pu récupéré les fichiers

Utilisation d'un tuyau d'arrosage 15 mm et d'une électrovanne 15 mm aussi

Batterie RC

Moteur 100 W+ servomoteur

Entre autres

(impossible de joindre les fichiers solidwork, je réessayerais plus tard)

Bonne soirée à tous

Nous sommes un groupe de 4 (où je suis la porte parole), et nous construisons un robot incendie type colossus (mais en version réduite tout de même, pas le même budget).

Notre robot est donc prévu pour s'approcher d'un feu, possèdes des roues au lieu de chenilles, a une caméra embarquée, une lance que le robot traînera derrière lui et les capteurs. Et c'est là que ce pose le premier problème majeur : quels capteurs prendre ? Ultrasons, infrarouges ? Des résistants à la chaleur, des normaux protégés par un quelconque moyen ? J'en appelle donc à votre aide car nous ne savons plus que faire.

Merci de vos réponses