Capteurs à ultrasons HC-SR04 sur une carte Arduino Uno

Placé sur 2019-09-17

Capteurs à ultrasons HC-SR04 sur une carte Arduino Uno

La lecture d'un capteur HC-SR04 sur une carte Arduino est relativement facile, mais que se passe-t-il si vous voulez lire plusieurs capteurs ? Comment faire cela de manière efficace ? Cet article explique à l'aide d'un exemple comment vous pouvez lire efficacement dans 4 capteurs et comment vous pouvez étendre cela à plusieurs capteurs.

Construisez 4 capteurs à ultrasons HC-SR04 sur une carte Arduino Uno

Qu'est-ce qu'un HC-SR04

Le HC-SR04 est une carte break-out avec des capteurs à ultrasons. Sur ce panneau se trouvent deux objets cylindriques, dont l'un est marqué de la lettre "T", qui signifie "émetteur", qui signifie "expéditeur", tandis que l'autre est marqué de la lettre "R" pour "récepteur", qui signifie « récepteur ». L'émetteur envoie une onde sonore ultrasonique et le récepteur "écoute" cette onde sonore pour entrer en collision avec un objet et être réfléchie. Le temps qui s'écoule entre la transmission et la réception indique à quelle distance cet objet se trouve du capteur. Les chauves-souris, les dauphins, les baleines et les sonars des navires fonctionnent sur un principe similaire, et ce principe est souvent appelé "emplacement d'écho".

Carte de dérivation HC-SR04

Pouvez-vous entendre une onde sonore ultrasonique

À moins d'avoir les oreilles de votre chien, vous ne pouvez pas entendre les ondes sonores ultrasonores. Le HC-SR04 utilise une onde sonore d'une fréquence de 40 kHz, alors qu'une oreille humaine ne peut entendre que 16 kHz et que les plus jeunes peuvent entendre jusqu'à 20-22 kHz. Bien en dessous de la fréquence d'une onde sonore ultrasonique.

De plus, une onde sonore ultrasonore n'est pas une onde radio (comme les ondes d'un smartphone), et est totalement inoffensive pour la santé.

Comment fonctionne le HC-SR04

Comme mentionné précédemment, le HC-SR04 émet un son ultrasonique, qui entre en collision avec un objet et revient au capteur. Le capteur compte le temps qui s'écoule entre l'envoi et la réception de ce signal. Si vous connaissez la vitesse du son, vous pouvez calculer la distance entre le capteur et l'objet. Bien sûr, le son ne voyage pas infiniment loin et comme l'onde sonore du capteur est relativement faible, la plage de mesure est également assez limitée. Le HC-SR04 peut mesurer des distances jusqu'à environ 400 cm (4 m). L'« angle de vue » ou « angle de mesure » du capteur n'est pas non plus infini. Les objets qui tombent en dehors d'un angle de 15° ne peuvent pas être détectés par le capteur. C'est pourquoi il est parfois intéressant d'utiliser plusieurs capteurs, que l'on place en cercle par exemple. De cette façon, vous pouvez augmenter l'angle de mesure.

Lire le capteur

Pour lire le HC-SR04, vous devez générer une impulsion de démarrage sur la broche "déclencheur" du capteur. La réponse du capteur apparaîtra sur sa broche « écho ». Les deux broches sont connectées aux broches d'E/S numériques de l' Arduino .

Déclencher

Pour générer une impulsion de démarrage, vous devez suivre les étapes suivantes

La broche de déclenchement doit être basse pendant au moins 2 µs (microsecondes).
La broche de déclenchement doit alors être haute pendant 10 µs
Goupille de déclenchement vers le bas

Avec l' Arduino , vous pouvez facilement le faire avec le morceau de code suivant :

HC-SR04 "Trigger"

// Zend start signaal "trigger"
digitalWrite(2, LOW);   // Zet pin 2 LAAG
delayMicroseconds(2);   // Wacht 2µs
digitalWrite(2, HIGH);  // Zet pin 2 HOOG
delayMicroseconds(10);  // Wacht 10µs
digitalWrite(2, LOW);   // Zet pin 2 terug LAAG

Écho

La réponse qui apparaît sur la broche d'écho du capteur est une impulsion dont la durée est égale au temps entre l'émission et la réception de l'onde sonore ultrasonore, exprimée en µs (micro secondes). Une possibilité de mesurer une telle impulsion sur l' Arduino est avec la fonction "pulseIn":

Meet "echo"

reistijd_geluidsgolf = pulseIn(2, HIGH);   // Meet de tijd dat de puls HOOG (true) is op pin 2

Calculer la distance

Bien sûr, après tout cela, vous ne connaissez que le temps de parcours de l'onde sonore, mais cela ne signifie pas que vous connaissez la distance. Heureusement, la vitesse du son est connue, et la distance peut être calculée avec ceci :

distance [m] = vitesse_son [m/s] * temps [s]

et la vitesse du son est de 343 m/s, donc

distance [m] = 343 [m/s] * temps [s]

Cependant, le HC-SR04 donne le temps en µs, et pour un comptage facile, la distance en cm serait plus pratique, mais avec certains calculs, la formule peut être ajustée à

distance [cm] = 0,0343 [cm/µs] * temps [µs]

Le seul problème qui subsiste maintenant est que le temps indiqué par le HC-SR04 est le temps d'aller-retour de l'impulsion, et comme seule la distance à l'objet est utile, il suffit de diviser le temps par 2 :

distance = 0,0343 * (temps/2)

Configuration de test simple

Une configuration de test rapide pour tester le fonctionnement du HC-SR04 peut être réalisée avec le schéma et le code suivants :

Un capteur HC-SR04 sur l' Arduino Uno

Eenvoudige code voor het testen van een HC-SR04 op een Arduino Uno

#define triggerPin 4      // Pin voor de trigger
#define echoPin 2         // Pin voor de echo
#define soundSpeed 343.0  // Snelheid van het geluid (m/s)

// Init variables
long echoTime = 0;
float distance = 0;

// Eenmalige doorloop (setup)
void setup()
{
  Serial.begin(115200);
  while (!Serial) {
    ; // Wacht op seriele monitor
  }
  Serial.println("--- Seriele monitor gestart ---");
  pinMode(triggerPin, OUTPUT);  // Zet trigger pin als uitgang
  pinMode(echoPin, INPUT);      // Zet echo pin als ingang
}

// Continue doorloop (loop)
void loop()
{
  // Zend startpuls (trigger)
  digitalWrite(triggerPin, LOW);    // Make sure trigger pin is low
  delayMicroseconds(2);             // for at least 2µs
  digitalWrite(triggerPin, HIGH);   // Set trigger pin HIGH
  delayMicroseconds(10);            // for at least 10µs
  digitalWrite(triggerPin, LOW);    // Set LOW again

  // Meet lengte van de echo puls
  echoTime = pulseInLong(echoPin, HIGH);
  // en bereken hiermee de aftsand (in cm)
  distance = float(echoTime) / 2 * (soundSpeed / 10000.0);
  // Geef weer op de seriele monitor
  Serial.print("Afstand = ");
  Serial.print((String)distance);
  Serial.println(" cm");
  // And wacht 500ms
  delay(500);
}

Multi HC-SR04

A partir de là, cela devient un peu plus difficile. Parce que la fonction "pulseIn" met le code en pause et n'est pas suffisamment précise, le code étendu utilise des registres de port et des interruptions. Si cela ne vous semble pas familier, vous pouvez trouver plus d'informations sur le site Web de l'auteur de cet article : http://kunoichi.be/projects/
(le site n'est disponible qu'en anglais)

Plusieurs capteurs

Pour utiliser plusieurs capteurs, vous pouvez procéder de trois manières :

déclenchement séparé par capteur ; écho séparé par capteur
déclencheur commun ; écho séparé par capteur
déclenchement séparé par capteur ; écho commun

déclenchement séparé par capteur ; écho séparé par capteur

Le moyen le plus simple et le moins efficace consiste à connecter chaque broche de déclenchement et d'écho de chaque capteur à une broche distincte sur l' Arduino .
En d'autres termes, 2 broches sur l' Arduino par capteur.

déclencheur commun ; écho séparé par capteur

Une autre façon consiste à connecter tous les déclencheurs des capteurs et à les connecter à 1 broche sur l' Arduino . La broche d'écho de chaque capteur doit alors être connectée à une broche distincte sur l' Arduino . L'avantage, ainsi que l'inconvénient, est que tous les capteurs envoient leur réponse en même temps. Il est possible que les capteurs interfèrent les uns avec les autres, et vous avez également besoin d'une broche d'interruption séparée pour chaque capteur (l' Arduino Uno n'en a que 2). Vous pourriez utiliser des épingles ordinaires, mais la précision diminuerait un peu.

déclenchement séparé par capteur ; écho commun

Si une lecture ultra rapide n'est pas nécessaire, vous pouvez toujours obtenir une très bonne précision avec la troisième méthode, et vous n'avez pas l'inconvénient que les capteurs interfèrent les uns avec les autres.
Chaque broche de déclenchement du capteur est connectée séparément à l' Arduino , et toutes les broches d'écho sont connectées à 1 seule broche Arduino . Cette broche est appelée broche d'interruption. Parce que vous décidez quel déclencheur est contrôlé, vous savez quelle est la réponse du capteur à la broche d'écho commune.
C'est le moyen le plus efficace d'utiliser plusieurs capteurs HC-SR04 sur une seule carte Arduino .

Schème

Un petit inconvénient avec la méthode de la broche d'écho commune est que les capteurs peuvent interférer les uns avec les autres sur cette broche, mais cela peut être facilement résolu en utilisant des diodes. La structure du système est la suivante :

Schéma 4x capteurs HC-SR04 sur broche d'écho commune

Le diagramme temporel montre la progression des signaux.

L'impulsion de démarrage (trigger) du capteur 4 est envoyée.
Cela répond à la broche d'écho.
L'impulsion de démarrage (trigger) du capteur 3 est envoyée.
Il répond à la même broche d'écho, mais comme l'impulsion de démarrage est surveillée, on sait de quel capteur provient la réponse.
L'impulsion de démarrage (trigger) pour le capteur 2 est envoyée.
...
Répétez à partir de l'étape 1

Le reste est littéralement copié/collé et peut facilement être étendu à plusieurs (ou moins) capteurs de cette manière.

Chronogramme 4 déclencheurs, 1 écho

Le code de lecture des capteurs est le suivant :
(L'explication du code est fournie via des champs de commentaire dans le code lui-même)

Uitbreidbare code voor het uitlezen van meerdere sensoren

#define tSENS 4            // Totaal aantal sensoren
#define echoPin 2          // Pin van de gemeenschappelijke echo --> Dit is een interrupt PIN !
#define pingDelay 50       // Tijd tussen elke nieuwe meting (best > 5ms houden)
#define soundSpeed 343.0   // Snelheid van het geluid in m/s

volatile unsigned long startEcho;     // Place to store start time (interrupt)
volatile unsigned long stopEcho;      // Place to store stop time (interrupt)
float distancesCm[tSENS];             // Distances in cm

// Plaats de pin nummers van de trigger pinnen hier (aantal = tSENS !)
int triggerPins[tSENS] = {4, 5, 6, 7};      // Trigger pin voor elke sensor

// Poll timer
unsigned long lastPingMillis;

/****************************************************************
      SETUP
****************************************************************/
void setup()
{
  Serial.begin(115200);
  while (!Serial) {
    ; // Wait for Serial
  }
  Serial.println("--- Serial monitor started ---");
  // Zet alle trigger pinnen als uitgangen
  for (int i = 0; i < tSENS; i++) {
    pinMode(triggerPins[i], OUTPUT);
  }
  // Set echo pin
  pinMode(echoPin, INPUT);                  // Zet echo pin as ingang (geen pullup bij diodes !)
  attachInterrupt(0, ISR_ECHO, CHANGE );    // Definieer interrupt call voor echo pin
  lastPingMillis = millis();
}

/****************************************************************
      LOOP
****************************************************************/
void loop()
{
  // Ping elke x ms
  if (millis() - lastPingMillis >= pingDelay)
  {
    doMeasurement();  // Roep meet procedure op
    // Toon metingen op seriele monitor
    Serial.println(String(distancesCm[0]) + " - " + String(distancesCm[1]) + " - " + String(distancesCm[2])  + " - " + String(distancesCm[3]));
    lastPingMillis = millis();
  }
}

/****************************************************************
      Retrieve measurement and set next trigger
****************************************************************/
void doMeasurement()
{
  // Eerste uitlezing is fout of 0
  unsigned long startWait;
  unsigned long timeout = 30; // 30ms is de max tijd wachten op echo (23ms = 4m = buiten bereik)
  // Voor elke sensor ...
  for (int s = 0; s < tSENS; s++)
  {
    startEcho = 0;  // Reset start tijd
    stopEcho = 0;   // Reset stop tijd
    // Start volgende trigger
    // digitalWrite(triggerPins[s], LOW);  // Hier niet nodig
    // delayMicroseconds(2);
    digitalWrite(triggerPins[s], HIGH);    // HOOG gedurende min. 10µs
    delayMicroseconds(10);
    digitalWrite(triggerPins[s], LOW);    // Terug LAAG
    startWait = millis();   // Onthoud de start tijd "wachten op echo"
    while (startEcho == 0 or stopEcho == 0) {
      // Doorloop tot start en stoptijd verschillend is van 0, of timeout optreedt
      if (startWait + timeout < millis())
      {
        // Forceer resultaat naar 0
        startEcho = 0;
        stopEcho = 0;
        break;  // onderbreak de while cycles
      }
    }
    noInterrupts();   // cli()
    distancesCm[s] = (stopEcho - startEcho) * (float)soundSpeed / 1000.0 / 10.0 / 2.0;   // in cm
    interrupts();   // sei();
  }
}

/****************************************************************
      INTERRUPT handling (keep as fast(=short) as possible)
****************************************************************/
void ISR_ECHO()
{
  // For ATmega328(P) chips, INT0 as at pin PD2
  byte pinRead = PIND >> 2 & B0001;  // Lees de status van de interrupt pin 2 (Arduino Uno)
  if (pinRead)  {
    // Pin = HOOG -> Onthoud de start tijd
    startEcho = micros();
  }
  else {
    // Pin is LAAG -> Onthoud de stop tijd
    stopEcho = micros();
  }
}
//EINDE

Bien que ce ne soit pas la méthode la plus rapide, et avec de longues distances et de nombreux capteurs, le délai peut être relativement élevé, cette méthode offre certains avantages

1 seule broche d'interruption nécessaire
très facilement extensible
les capteurs n'interfèrent pas les uns avec les autres
utilisation optimale du nombre de capteurs par rapport aux broches d'E/S disponibles

Remarque concernant l'alimentation

Étant donné que la broche 5V de l' Arduino peut fournir un courant limité, il est recommandé de fournir une alimentation supplémentaire de 5V CC pour alimenter les capteurs. Pour cette raison, une "Breadbard Power Supply" est incluse dans la liste des composants, mais elle peut essentiellement être remplacée par n'importe quelle source d'alimentation 5V DC.

Composants

Les composants utilisés dans ce projet sont tous disponibles sur Opencircuit, et sont répertoriés ci-dessous :

Module de détection de distance à ultrasons HC-SR04 Rupture de stock € 2,20 Planche à pain 830 points - blanc Disponible immédiatement € 3,05 Ensemble pull Homme-Homme 65 pièces Disponible immédiatement € 2,95 Alimentation de planche à pain Rupture de stock € 2,20 Arduino Uno R3 - cloner Disponible immédiatement € 11,40 Diode de redressement 1N4004 400V 1A - 50 pièces Disponible immédiatement € 2,50 Total € 30,90

Posté par Arashi Site Internet

Capteurs à ultrasons HC-SR04 sur une carte Arduino Uno