HC-SR04 Ultrasonische sensoren op een Arduino Uno bord

Geplaatst op 2019-09-17

HC-SR04 Ultrasonische sensoren op een Arduino Uno bord

Een HC-SR04 sensor op een Arduino bord inlezen is relatief makkelijk, maar wat als je meerdere sensoren wil inlezen? Hoe doe je dat best op een efficiënte manier? In dit artikel wordt uitgelegd aan de hand van een voorbeeld hoe je 4 sensoren efficiënt kan inlezen, en hoe je dit verder kan uitbreiden naar meerdere sensoren.

Opbouw 4x HC-SR04 ultrasone sensoren op een Arduino Uno bord

Wat is een HC-SR04

De HC-SR04 is een “break-out board” met ultrasone sensoren. Op dit bordje bevinden zich twee cilindervormige voorwerpen waarvan één gemerkt is met de letter “T”, welke staat voor “Transmitter”, wat “zender” betekent, terwijl de andere gemerkt is met de letter “R” van “Receiver”, wat “ontvanger” betekent. De zender zendt een ultrasone geluidsgolf uit, en de ontvanger “luistert” naar deze geluidsgolf die tegen een object botst, en teruggekaatst wordt. De tijd die tussen het zenden en ontvangen verloopt, geeft aan hoever dat object verwijderd is van de sensor. Vleermuizen ,dolfijnen, walvissen en sonar in schepen werken op eenzelfde principe, en dit principe wordt vaak “echo locatie” genoemd.

HC-SR04 break-out board

Kan je een ultrasone geluidsgolf horen

Tenzij je de oren van je hond hebt, kan je ultrasone geluidsgolven niet horen. De HC-SR04 gebruikt een geluidsgolf met een frequentie van 40kHz, terwijl een menselijk oor slechts 16kHz kan horen, en jongere mensen soms tot 20 a 22kHz. Ver onder de frequentie van een ultrasone geluidsgolf dus.

Verder is een ultrasone geluidsgolf geen radiogolf (zoals de golven van een smartphone), en zijn volkomen onschadelijk voor de gezondheid.

Hoe werkt de HC-SR04

Zoals eerder vermeld, zend de HC-SR04 een ultrasoon geluid uit, dat tegen een object botst en terugkeert naar de sensor. De sensor telt die tijd die verstrijkt tussen het zenden en ontvangen van dit signaal. Als je de snelheid van het geluid kent, dan kan je de afstand berekenen tussen de sensor en het object. Uiteraard reist geluid niet oneindig ver en omdat de geluidsgolf van de sensor relatief zwak is, is ook het meetbereik vrij beperkt. De HC-SR04 kan afstanden meten tot ongeveer 400cm (4m). Ook de “kijkhoek” of “meethoek” van de sensor is niet oneindig. Objecten die buiten een hoek van 15° vallen, kunnen niet door de sensor gedetecteerd worden. Daarom is het soms interessant om meerdere sensoren te gebruiken, die je bijvoorbeeld in een cirkel plaatst. Op die manier kan je de meethoek vergroten.

De sensor uitlezen

Om de HC-SR04 uit te lezen dien je een startpuls te genereren op de “trigger” pin van de sensor. Het antwoord van de sensor komt tevoorschijn op zijn “echo” pin. Beide pinnen sluit je aan op digitale I/O pinnen van de Arduino.

Trigger

Om een startpuls te generen dien je volgende stappen te doorlopen

Trigger pin moet minstens 2µs (micro seconden) laag zijn
Trigger pin moet daarna 10µs hoog zijn
Trigger pin terug laag

Bij de Arduino kan dat makkelijk met volgend stukje code:

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

Echo

Het antwoord dat op de echo pin van de sensor verschijnt, is een puls waarvan de duur gelijk is aan de tijd tussen het zenden en ontvangen van de ultrasone geluidsgolf, uitgedrukt in µs (micro seconden). Eén mogelijkheid om zo een puls te meten op de Arduino is met de functie “pulseIn”:

Meet "echo"

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

Afstand berekenen

Uiteraard weet je na dit alles enkel de reistijd van de geluidsgolf, maar hiermee ken je nog geen afstand. Gelukkig is de snelheid van het geluid gekend, en kan hiermee de afstand berekend worden:

afstand [m] = snelheid_geluid [m/s] * tijd [s]

en de snelheid van het geluid is 343m/s, zodoende

afstand [m] = 343 [m/s] * tijd [s]

Echter, de HC-SR04 geeft de tijd in µs, en om makkelijk te tellen zou de afstand in cm handiger zijn, maar met wat rekenwerk kan de formule aangepast worden naar

afstand [cm] = 0,0343 [cm/µs] * tijd [µs]

Het enige probleem dat nu nog heerst, is dat de tijd die de HC-SR04 aangeeft, de tijd is dat de puls heen EN weer reist, en aangezien enkel de afstand tot het object nuttig is, dien je de tijd gewoon door 2 te delen:

afstand = 0,0343 * (tijd/2)

Eenvoudige test opstelling

Een snelle testopstelling om de werking van de HC-SR04 te testen, kan je met volgend schema en code verwezenlijken:

Eén HC-SR04 sensor op de 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

Vanaf hier wordt het een klein beetje moeilijker. Omdat de functie “pulseIn” de code pauzeert, en niet voldoende nauwkeurig is, wordt in de uitgebreide code gebruikt gemaakt van poort registers en interrupts. Indien dit onbekend klinkt, kan je meer informatie vinden op de website van de auteur van dit artikel: http://kunoichi.be/projects/
(de website is enkel in het Engels beschikbaar)

Meerdere sensoren

Om meerdere sensoren te gebruiken, kan je op drie manieren te werk gaan:

aparte trigger per sensor ; aparte echo per sensor
gemeenschappelijke trigger ; aparte echo per sensor
aparte trigger per sensor ; gemeenschappelijke echo

aparte trigger per sensor ; aparte echo per sensor

De meest eenvoudige manier, en minst efficiënte, is door elke trigger en elk echo pin van elke sensor te verbinden met een aparte pin op de Arduino.
Met andere woorden, 2 pinnen op de Arduino per sensor.

gemeenschappelijke trigger ; aparte echo per sensor

Een andere manier is door alle triggers van de sensoren te verbinden, en op 1 pin op de Arduino aan te sluiten. De echo pin van elke sensor dient dan aangesloten te worden op een aparte pin op de Arduino. Het voordeel , en zowel het nadeel, is dat alle sensoren tegelijkertijd hun antwoord doorsturen. Hierbij bestaat de mogelijkheid dat de sensoren elkaar storen, en heb je ook voor elke sensor een aparte interrupt pin nodig (de Arduino Uno heeft er slechts 2). Je zou gewone pinnen kunnen gebruiken, maar dan gaat de nauwkeurigheid wat achteruit.

aparte trigger per sensor ; gemeenschappelijke echo

Als super snel lezen geen noodzaak is, kan je met de derde methode toch een zeer goede nauwkeurigheid halen, en heb je niet het nadeel dat de sensoren elkaar gaan storen.
Hierbij wordt elke trigger pin van de sensor apart verbonden met de Arduino, en worden alle echo pinnen op 1 enkel Arduino pin aangesloten. Deze pin is wel een interrupt pin. Omdat je zelf beslist welke trigger wordt aangestuurt, weet je van welke sensor het antwoord op de gemeenschappelijke echo pin is.
Dit is de meest efficiënte manier om meerdere HC-SR04 sensoren te gebruiken op één enkel Arduino bord.

Schema

Een klein nadeel bij de gemeenschappelijk echo pin methode, is dat de sensoren elkaar kunnen storen op deze pin, maar dat kan zeer eenvoudig verholpen worden door gebruikt te maken van diodes. De opbouw van het systeem is als volgt:

Schema 4x HC-SR04 sensoren op gemeenschappelijk echo pin

Op het tijdsdiagram is te zien hoe de signalen verlopen.

De startpuls (trigger) voor sensor 4 wordt gestuurd.
Deze antwoord op de echo pin.
De startpuls (trigger) voor sensor 3 wordt gestuurd.
Deze antwoord op dezelfde echo pin, maar aangezien de startpuls wordt gecontroleerd, is gekend van welke sensor het antwoord komt.
De startpuls (trigger) voor sensor 2 wordt gestuurd.
...
Herhaling vanaf stap 1

De rest is letterlijk copy/paste, en kan op deze manier ook makkelijk uitgebreid worden naar meerdere (of minder) sensoren.

Tijdsdiagram 4 triggers, 1 echo

De code voor het uitlezen van de sensoren is als volgt:
(Uitleg van de code, is voorzien via commentaar velden in de code zelf)

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

Hoewel dit niet de snelste methode is, en bij lange afstanden en veel sensoren de doorlooptijd relatief hoog kan oplopen, biedt deze methode enkele voordelen

slechts 1 interrupt pin nodig
zeer makkelijk uitbreidbaar
sensoren storen elkaar niet
optimaal gebruik aantal sensoren versus beschikbare I/O pinnen

Opmerking aangaande voeding

Omdat de 5V pin op de Arduino beperkte stroom kan leveren, is het aangeraden een extra 5V DC voeding te voorzien voor het voeden van de sensoren. Om deze reden is in de componenten lijst een “Breadbard Power Supply” opgenomen, maar in weze kan deze vervangen worden door eender welke 5V DC voedingsbron.

Componenten

De componenten gebruikt in dit project, zijn allen verkrijgbaar bij OpenCircuit.nl, en zijn hieronder opgelijst:

HC-SR04 Ultrasonische afstands detectie module Direct leverbaar € 2,25 Breadboard 830 punten - wit Niet op voorraad € 3,00 Male-Male jumper set 65 stuks Direct leverbaar € 2,95 Breadboard Power Supply Niet op voorraad € 2,20 Arduino Uno R3 - clone Direct leverbaar € 11,50 1N4004 400V 1A Rectifier diode - 50 stuks Niet op voorraad € 2,50 Totaal € 31,15

Geschreven door Arashi Website

HC-SR04 Ultrasonische sensoren op een Arduino Uno bord