HC-SR04 Ultraljudssensorer på ett Arduino Uno-kort

Placerad på 2019-09-17

HC-SR04 Ultraljudssensorer på ett Arduino Uno-kort

Att läsa in en HC-SR04-sensor på ett Arduino -kort är relativt enkelt, men vad händer om du vill läsa in flera sensorer? Hur gör man det på ett effektivt sätt? Den här artikeln förklarar med hjälp av ett exempel hur du effektivt kan läsa in 4 sensorer, och hur du kan utöka detta ytterligare till flera sensorer.

Bygg 4x HC-SR04 ultraljudssensorer på ett Arduino Uno-kort

Vad är en HC-SR04

HC-SR04 är ett break-out-kort med ultraljudssensorer. På denna skylt finns två cylindriska föremål, varav ett är märkt med bokstaven "T", som står för "Sändare", vilket betyder "sändare", medan det andra är märkt med bokstaven "R" för "Mottagare", vilket betyder "mottagare". Sändaren skickar ut en ultraljudsvåg och mottagaren "lyssnar" efter att denna ljudvåg kolliderar med ett föremål och reflekteras tillbaka. Tiden som går mellan sändning och mottagning indikerar hur långt objektet är från sensorn. Fladdermöss, delfiner, valar och ekolod i fartyg fungerar enligt en liknande princip, och denna princip kallas ofta för "ekoplacering".

HC-SR04 breakout board

Kan du höra en ultraljudsvåg

Om du inte har din hunds öron kan du inte höra ultraljudsvågor. HC-SR04 använder en ljudvåg med en frekvens på 40kHz, medan ett mänskligt öra bara kan höra 16kHz, och yngre människor kan höra upp till 20-22kHz. Långt under frekvensen för en ultraljudsljudvåg.

Dessutom är en ultraljudsvåg inte en radiovåg (som vågorna från en smartphone), och är helt ofarlig för hälsan.

Hur fungerar HC-SR04

Som tidigare nämnt avger HC-SR04 ett ultraljud, som kolliderar med ett föremål och återgår till sensorn. Sensorn räknar tiden som går mellan att skicka och ta emot denna signal. Om du känner till ljudets hastighet kan du beräkna avståndet mellan sensorn och objektet. Ljudet färdas förstås inte oändligt långt och eftersom sensorns ljudvåg är relativt svag är även mätområdet ganska begränsat. HC-SR04 kan mäta avstånd upp till cirka 400 cm (4m). Sensorns "betraktningsvinkel" eller "mätvinkel" är inte heller oändlig. Föremål som faller utanför en vinkel på 15° kan inte detekteras av sensorn. Därför är det ibland intressant att använda flera sensorer, som man till exempel placerar i en cirkel. På så sätt kan du öka mätvinkeln.

Läs av sensorn

För att läsa HC-SR04 måste du generera en startpuls på sensorns "trigger"-stift. Responsen från sensorn kommer att visas på dess "eko"-stift. Båda stiften är anslutna till digitala I/O-stift på Arduino .

Utlösare

För att generera en startpuls måste du utföra följande steg

Avtryckarstiftet måste vara lågt i minst 2µs (mikro sekunder).
Avtryckarstiftet måste då vara högt i 10µs
Avtryckarstiftet lågt tillbaka

Med Arduino kan du enkelt göra detta med följande kodbit:

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

Eko

Svaret som visas på sensorns ekostift är en puls vars varaktighet är lika med tiden mellan sändning och mottagning av ultraljudsljudvågen, uttryckt i µs (mikrosekunder). En möjlighet att mäta en sådan puls på Arduino är med funktionen "pulseIn":

Meet "echo"

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

Beräkna avstånd

Naturligtvis vet du efter allt detta bara ljudvågens restid, men det betyder inte att du vet avståndet. Lyckligtvis är ljudets hastighet känd, och avståndet kan beräknas med detta:

avstånd [m] = hastighet_ljud [m/s] * tid [s]

och ljudets hastighet är 343m/s, alltså

avstånd [m] = 343 [m/s] * tid [s]

HC-SR04 anger dock tiden i µs, och för enkel räkning skulle avståndet i cm vara bekvämare, men med vissa beräkningar kan formeln justeras till

avstånd [cm] = 0,0343 [cm/µs] * tid [µs]

Det enda problemet som återstår nu är att tiden som indikeras av HC-SR04 är tiden då pulsen färdas fram OCH tillbaka, och eftersom endast avståndet till objektet är användbart, måste du bara dividera tiden med 2:

avstånd = 0,0343 * (tid/2)

Enkel testinställning

En snabb testinställning för att testa funktionen av HC-SR04 kan realiseras med följande schema och kod:

En HC-SR04-sensor på 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

Härifrån blir det lite svårare. Eftersom funktionen "pulseIn" pausar koden, och inte är tillräckligt exakt, använder den utökade koden portregister och avbrott. Om detta låter obekant, kan du hitta mer information på webbplatsen för författaren till denna artikel: http://kunoichi.be/projects/
(webbplatsen är endast tillgänglig på engelska)

Flera sensorer

För att använda flera sensorer kan du fortsätta på tre sätt:

separat trigger per sensor; separat eko per sensor
gemensam trigger; separat eko per sensor
separat trigger per sensor; vanligt eko

separat trigger per sensor; separat eko per sensor

Det enklaste sättet, och minst effektivt, är att ansluta varje trigger- och ekostift för varje sensor till ett separat stift på Arduino .
Med andra ord, 2 stift på Arduino per sensor.

gemensam trigger; separat eko per sensor

Ett annat sätt är att ansluta alla sensorernas triggers och ansluta dem till 1 stift på Arduino . Ekostiftet för varje sensor måste sedan anslutas till ett separat stift på Arduino . Fördelen, såväl som nackdelen, är att alla sensorer skickar sitt svar samtidigt. Det finns en möjlighet att sensorerna kommer att störa varandra, och du behöver också ett separat avbrottsstift för varje sensor ( Arduino Uno har bara 2). Man skulle kunna använda vanliga stift, men då skulle noggrannheten sjunka lite.

separat trigger per sensor; vanligt eko

Om supersnabb avläsning inte är nödvändig kan du ändå uppnå mycket bra noggrannhet med den tredje metoden, och du har inte nackdelen att sensorerna kommer att störa varandra.
Varje triggerstift på sensorn är anslutet separat till Arduino , och alla ekostift är anslutna till ett enda Arduino stift. Detta stift kallas ett avbrottsstift. Eftersom du bestämmer vilken trigger som styrs vet du vilken sensor som svarar på den gemensamma ekopinnen.
Detta är det mest effektiva sättet att använda flera HC-SR04-sensorer på ett enda Arduino kort.

Schema

En liten nackdel med den vanliga ekostiftmetoden är att sensorerna kan störa varandra på detta stift, men det kan enkelt åtgärdas med hjälp av dioder. Systemets struktur är som följer:

Schema 4x HC-SR04-sensorer på vanligt ekostift

Tidsdiagrammet visar hur signalerna fortskrider.

Startpulsen (trigger) för sensor 4 skickas.
Detta svarar på ekotappen.
Startpulsen (trigger) för sensor 3 skickas.
Den svarar på samma ekostift, men eftersom startpulsen övervakas vet man från vilken sensor svaret kommer.
Startpulsen (trigger) för sensor 2 skickas.
...
Upprepa från steg 1

Resten är bokstavligen kopiera/klistra in, och kan enkelt utökas till flera (eller färre) sensorer på detta sätt.

Tidsdiagram 4 triggers, 1 eko

Koden för att läsa av sensorerna är följande:
(Förklaring av koden ges via kommentarsfält i själva koden)

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

Även om detta inte är den snabbaste metoden, och med långa avstånd och många sensorer kan ledtiden vara relativt lång, erbjuder denna metod vissa fördelar

endast 1 avbrottsstift behövs
mycket lätt utbyggbar
sensorer stör inte varandra
optimal användning av antalet sensorer jämfört med tillgängliga I/O-stift

Anmärkning angående strömförsörjning

Eftersom 5V-stiftet på Arduino kan leverera begränsad ström, rekommenderas det att tillhandahålla en extra 5V DC-strömförsörjning för att driva sensorerna. Av denna anledning ingår en "Breadbard Power Supply" i komponentlistan, men i huvudsak kan denna ersättas med vilken 5V DC-strömkälla som helst.

Komponenter

Komponenterna som används i detta projekt finns alla tillgängliga på Opencircuit, och är listade nedan:

HC-SR04 Ultraljudsmodul för avståndsdetektering I lager € 2,30 Breadboard 830 poäng - vit Slut i lager € 3,10 Hane-Mane jumper set 65 stycken I lager € 3,05 Strömförsörjning för brödbräda Slut i lager € 2,30 Arduino Uno R3 - klon I lager € 11,90 1N4004 400V 1A Likriktardiod - 50 stycken Slut i lager € 2,60 Total € 32,15

Postat av Arashi Hemsida

HC-SR04 Ultraljudssensorer på ett Arduino Uno-kort