[RESOLU] Module Ultrason HC-SR04 ne fonctionne pas

Bonjour à tous amis Arduiniens, :smiley:

Je viens vous demander une petite aide, car j’ai passé la journée entière à essayer de faire fonctionner mon module HC-SR04.

Problème : Il ne fonctionne pas, pourtant j’ai testé tout ce que je peux tester, et là je sais plus quoi faire… ::slight_smile:

  • J’ai testé divers codes,
  • J’ai testé divers pin (au cas ou un était hs)
  • J’ai testé d’intervertir le Trip en Echo
  • J’ai remplacé le module (car j’en ais 5)

Rien y fait. :’(

  • J’ai bien branché le Gnd et le 5v et je suis sur qu’ils fonctionne (car testé avec un lcd qui s’allume bien).
  • J’ai bien branché le Trig sur le pin 22 (ici) et le Echo sur le pin 23(ici) mais j’ai aussi testé d’autres pin.

Voici le code, je suppose que j’ai loupé qq chose :
Désolé c’est un peu le bordel dans la fonction FCalcul_Ultrason mais comme je test, je mets pleins de code pour être sure que le problème ne vienne pas du code. :stuck_out_tongue:

const byte Pin_UltrasonIN = 23;
const byte Pin_UltrasonOUT = 22;
float Vitesse_Son = 0;
  
void setup() {
  pinMode(Pin_UltrasonIN, INPUT);
  pinMode(Pin_UltrasonOUT, OUTPUT);
  pinMode(Pin_UltrasonOUT, LOW);
  Vitesse_Son = 343.4 / 1000;
}
void loop() {
  FCalcul_Ultrason();
  delay(1000);
}

float FCalcul_Ultrason(){
// -------------------------------------------
// - Description :
//    Permet de calculer la distance avec l'ultrason
// - Variables :
//    NC
// - Retourne :
//    Distance en mm
// -------------------------------------------
  const unsigned long MEASURE_TIMEOUT = 25000; // 25ms = ~8m à 340m/s
  const float SOUND_SPEED = 340.0 / 1000;
  long duration_hc, distance_hc;
  long measure = pulseIn(Pin_UltrasonIN, HIGH, MEASURE_TIMEOUT);
  float distance_mm = measure / 2.0 * SOUND_SPEED;
  digitalWrite(Pin_UltrasonOUT, HIGH);
  delayMicroseconds(10);
  digitalWrite(Pin_UltrasonOUT, LOW);
  delayMicroseconds(2); 
  digitalWrite(Pin_UltrasonOUT, HIGH);
  delayMicroseconds(10); 
  digitalWrite(Pin_UltrasonOUT, LOW);
  duration_hc = pulseIn(Pin_UltrasonIN, HIGH);
  Serial.println(duration_hc);
  distance_hc = duration_hc / 58;
  Serial.print(F("Distance: "));
  Serial.print(distance_hc);
  Serial.print(F("mm ("));
  Serial.print(distance_hc / 10.0, 2);
  Serial.print(F("cm, "));
  Serial.print(distance_hc / 1000.0, 2);
  Serial.println(F("m)"));
  Serial.print(F("Distance: "));
  Serial.print(distance_mm);
  Serial.print(F("mm ("));
  Serial.print(distance_mm / 10.0, 2);
  Serial.print(F("cm, "));
  Serial.print(distance_mm / 1000.0, 2);
  Serial.println(F("m)"));




  float FCalcul_Ultrason_Return = 0;
  byte FCalcul_Ultrason_Moyenne = 3;
  for (byte i = 0; i < FCalcul_Ultrason_Moyenne; i++) {
    digitalWrite(Pin_UltrasonOUT, HIGH);
    delayMicroseconds(10);
    digitalWrite(Pin_UltrasonOUT, LOW);
    FCalcul_Ultrason_Return += pulseIn(Pin_UltrasonIN, HIGH, 25000UL) / 2 * Vitesse_Son;
    Serial.println(FCalcul_Ultrason_Return);
  }
  FCalcul_Ultrason_Return = FCalcul_Ultrason_Return / FCalcul_Ultrason_Moyenne;
  Serial.println(FCalcul_Ultrason_Return);

delay(1000);
  
  return (FCalcul_Ultrason_Return);
}

Merci pour votre aide, :wink:

Bon, on se calme, on respire un bon coup. Si tu as testé avec 5 capteurs et que ça ne fonctionne pas, ça vient soit de la carte soit du code.

Tu n'as pas dit quelle carte tu utilises.

Côté code, teste celui-ci (trouvé ici) :

/* 
 * Code d'exemple pour un capteur à ultrasons HC-SR04.
 */

/* Constantes pour les broches */
const byte TRIGGER_PIN = 22; // Broche TRIGGER
const byte ECHO_PIN = 23;      // Broche ECHO
 
/* Constantes pour le timeout */
const unsigned long MEASURE_TIMEOUT = 25000UL; // 25ms = ~8m à 340m/s

/* Vitesse du son dans l'air en mm/us */
const float SOUND_SPEED = 340.0 / 1000;

/** Fonction setup() */
void setup() {
   
  /* Initialise le port série */
  Serial.begin(115200);
   
  /* Initialise les broches */
  pinMode(TRIGGER_PIN, OUTPUT);
  digitalWrite(TRIGGER_PIN, LOW); // La broche TRIGGER doit être à LOW au repos
  pinMode(ECHO_PIN, INPUT);
}
 
/** Fonction loop() */
void loop() {
  
  /* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10µs sur la broche TRIGGER */
  digitalWrite(TRIGGER_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGER_PIN, LOW);
  
  /* 2. Mesure le temps entre l'envoi de l'impulsion ultrasonique et son écho (si il existe) */
  long measure = pulseIn(ECHO_PIN, HIGH, MEASURE_TIMEOUT);
   
  /* 3. Calcul la distance à partir du temps mesuré */
  float distance_mm = measure / 2.0 * SOUND_SPEED;
   
  /* Affiche les résultats en cm */
  Serial.print(distance_mm / 10.0, 2);
  Serial.print(F("cm, "));
   
  /* Délai d'attente pour éviter d'afficher trop de résultats à la seconde */
  delay(500);
}

Pense à régler la console sur 115200 bauds. Est-ce que ça marche ?

En même temps, tu n'as pas initialisé la console dans ton setup !!!
  Serial.begin(115200);Ça ne risque pas d'afficher grand chose... :grin:

Bonjour lesept,

Merci pour ton code.
Avec Serial.begin(115200); rien ne change, les résultats sont toujours à 0

Mais avec le reste, ca fonctionne. :astonished: :wink: :smiley:
Merci beaucoup pour ton aide. :-*

Pour le moment, je ne sais pas d'ou vient le problème, mais grace à ce code qui fonctionne je vais pouvoir tester le problème.

J pense que j'ai fais le débile, (a voir) :roll_eyes:

Merci bcp !!!!!!! :grinning:

Re... Bon, ben, j'ai compris pourquoi ca ne fonctionnait pas.

Une journée pour un copier collé.... Rahh, :sob:

En faite, j'ai indiqué :
pinMode(Pin_UltrasonIN, INPUT);
pinMode(Pin_UltrasonOUT, OUTPUT);
pinMode(Pin_UltrasonOUT, LOW);

Alors que j'aurais dû mettre :
pinMode(Pin_UltrasonIN, INPUT);
pinMode(Pin_UltrasonOUT, OUTPUT);
digitalWrite(Pin_UltrasonOUT, LOW);

Grrr c'est ragent,
Et comme le programme a bcp de ligne (au dessus j'avais mis qu'un résumé), ben je ne l'avais pas vu : 8)

Merci encore et désolé pour le dérangement.

Et comme le programme a bcp de ligne (au dessus j'avais mis qu'un résumé), ben je ne l'avais pas vu :

Et bien la prochaine fois tu commencera par tester le nouveau matériel UN par UN et avec des programmes minimum.
Et quand tout fonctionnera individuellement tu assemblera toujours UN par UN.