Ultrasone sensor HC-SR04 en Arduino - Complete gids

HC-SR04 ultrasone sensor pinout

Hier is de pin-out van de sensor:

De sensor heeft 4 pinnen. VCC en GND ga naar 5V en GND pinnen op de Arduino en de Trig en Echo ga naar een digitale Arduino-pin. De Trig . gebruiken pin sturen we de ultrasone golf van de zender, en met de Echo pin we luisteren naar het gereflecteerde signaal.

Hoe werkt de HC-SR04 ultrasone afstandssensor?

Het zendt een ultrageluid uit op 40 000 Hz dat door de lucht reist en als er een object of obstakel op zijn pad is, zal het terugkaatsen naar de module. Rekening houdend met de reistijd en de snelheid van het geluid kun je de afstand berekenen.

Om de echo te kunnen genereren, moeten we de Trig-pin op een hoge stand zetten voor 10 µs. Dat zal een 8-cyclus ultrasone burst uitzenden die met de snelheid van het geluid zal reizen. De Echo-pinnen worden meteen hoog nadat die 8-cyclus ultrasone burst is verzonden, en het begint te luisteren of te wachten tot die golf wordt weerkaatst door een object.

Als er geen object of gereflecteerde puls is, zal de Echo-pin na 38 ms een time-out geven en terugkeren naar de lage status.

Als we een gereflecteerde puls ontvangen, gaat de Echo-pin eerder naar beneden dan die 38 ms. Afhankelijk van de tijd dat de Echo-pin HOOG was, kunnen we de afstand bepalen die de geluidsgolf heeft afgelegd, dus de afstand van de sensor tot het object.

Voor dat doel gebruiken we de volgende basisformule voor het berekenen van afstand:

Afstand =Snelheid x Tijd

We kennen eigenlijk zowel de snelheids- als de tijdwaarden. De tijd is de tijd dat de Echo-pin HOOG was, en de snelheid is de geluidssnelheid die 340 m/s is. Er is nog een extra stap die we moeten doen, en dat is het eindresultaat delen door 2. en dat komt omdat we de tijd meten die de geluidsgolf nodig heeft om naar het object te reizen en terug te kaatsen.

Laten we zeggen dat de Echo-pin 2 ms HOOG was. Als we het resultaat van de afstand in cm willen krijgen, kunnen we de geluidssnelheid omrekenen van 340 m/s naar 34 cm/ms.

Afstand =(Snelheid x Tijd) / 2 =(34 cm/ms x 1,5 ms) / 2 =25,5 cm.

Dus als de Echo-pin 2 ms HOOG was (wat we meten met de pulseIn() functie), is de afstand van de sensor tot het object 34 cm.

Hoe de HC-SR04 ultrasone sensor op Arduino aan te sluiten

Hier leest u hoe we de HC-SR04-sensor op een Arduino-bord moeten aansluiten.

De aarde- en de VCC-pinnen van de module moeten respectievelijk worden aangesloten op de aarde en de 5 volt-pinnen op het Arduino-bord en de trig- en echo-pinnen op elke digitale I/O-pin op het Arduino-bord.

Je kunt deze componenten die nodig zijn voor deze tutorial verkrijgen via een van de onderstaande sites:

• Ultrasone sensor HC-SR04 ………… 
• Arduino-bord …………………………
• Broodplank en springdraden ……… 

HC-SR04 Ultrasone sensor Arduino-code

Hier is een code voor het meten van afstand met behulp van de HC-SR04 ultrasone sensor en Arduino.

/*
  Ultrasonic Sensor HC-SR04 and Arduino Tutorial

  by Dejan Nedelkovski,
  www.HowToMechatronics.com

*/
// defines pins numbers
const int trigPin = 9;
const int echoPin = 10;
// defines variables
long duration;
int distance;
void setup() {
  pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
  pinMode(echoPin, INPUT); // Sets the echoPin as an Input
  Serial.begin(9600); // Starts the serial communication
}
void loop() {
  // Clears the trigPin
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  // Sets the trigPin on HIGH state for 10 micro seconds
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  // Reads the echoPin, returns the sound wave travel time in microseconds
  duration = pulseIn(echoPin, HIGH);
  // Calculating the distance
  distance = duration * 0.034 / 2;
  // Prints the distance on the Serial Monitor
  Serial.print("Distance: ");
  Serial.println(distance);
}Code language: Arduino (arduino)

Code Uitleg

Eerst moeten we de Trig- en Echo-pinnen definiëren. In dit geval zijn dit de pinnen nummer 9 en 10 op het Arduino-bord en heten ze trigPin en echoPin. Dan hebben we een lange variabele nodig, genaamd 'duur' voor de reistijd die we van de sensor krijgen en een integer-variabele voor de afstand.

// defines pins numbers
const int trigPin = 9;
const int echoPin = 10;

// defines variables
long duration;
int distance;Code language: Arduino (arduino)

In de setup moeten we de trigPin als output en de echoPin als input definiëren en ook de seriële communicatie starten om de resultaten op de seriële monitor te tonen.

void setup() {
  pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
  pinMode(echoPin, INPUT); // Sets the echoPin as an Input
  Serial.begin(9600); // Starts the serial communication
}Code language: Arduino (arduino)

In de lus moeten we er eerst voor zorgen dat de trigPin duidelijk is, dus je moet die pin op een LOW-status zetten voor slechts 2 µs. Voor het genereren van de ultrageluidsgolf moeten we de trigPin nu op HIGH State zetten voor 10 µs.

// Clears the trigPin
digitalWrite(trigPin, LOW);
delayMicroseconds(2);

// Sets the trigPin on HIGH state for 10 micro seconds
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);Code language: Arduino (arduino)

De pulseIn() . gebruiken functie lezen we de reistijd en zetten die waarde in de variabele "duur". Deze functie heeft 2 parameters, de eerste is de naam van de Echo-pin en de tweede is de status van de puls die we aan het lezen zijn, ofwel Hoog of Laag.

// Reads the echoPin, returns the sound wave travel time in microseconds
duration = pulseIn(echoPin, HIGH);Code language: Arduino (arduino)

In dit geval hebben we deze ingesteld op HOOG, omdat de HC-SR04-sensoren de Echo-pin op Hoog zetten na het verzenden van de 8-cyclus ultrasone burst van de zender. Dit start eigenlijk de timing en zodra we de gereflecteerde geluidsgolf ontvangen, gaat de Echo-pin naar Laag, waardoor de timing stopt. Aan het einde geeft de functie de lengte van de puls in microseconden terug.

Om de afstand te krijgen, vermenigvuldigen we de duur met 0,034 en delen we deze door 2, zoals we deze vergelijking eerder hebben uitgelegd.

// Calculating the distance
distance= duration*0.034/2;

// Prints the distance on the Serial Monitor
Serial.print("Distance: ");
Serial.println(distance);Code language: Arduino (arduino)

Aan het einde zullen we de waarde van de afstand op de seriële monitor afdrukken.

Arduino ultrasone sensor en lcd-scherm voorbeeld

Hier is nog een voorbeeld van het gebruik van de ultrasone sensor met Arduino en het weergeven van de resultaten op een LCD.

U kunt de ultrasone sensor en de LDC als volgt aansluiten:

De code die de afstand meet, is vrijwel hetzelfde als het basisvoorbeeld. Hier, in plaats van de resultaten op de seriële monitor af te drukken, printen we ze op het LCD-scherm. Als je meer details nodig hebt over het gebruik en het aansluiten van een LCD-scherm met Arduino, kun je mijn specifieke tutorial ervoor raadplegen.

/*
  Ultrasonic Sensor HC-SR04 and Arduino Tutorial

  by Dejan Nedelkovski,
  www.HowToMechatronics.com

*/
#include <LiquidCrystal.h> // includes the LiquidCrystal Library
LiquidCrystal lcd(1, 2, 4, 5, 6, 7); // Creates an LCD object. Parameters: (rs, enable, d4, d5, d6, d7)
const int trigPin = 9;
const int echoPin = 10;
long duration;
int distanceCm, distanceInch;
void setup() {
  lcd.begin(16, 2); // Initializes the interface to the LCD screen, and specifies the dimensions (width and height) of the display
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
}
void loop() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distanceCm = duration * 0.034 / 2;
  distanceInch = duration * 0.0133 / 2;
  lcd.setCursor(0, 0); // Sets the location at which subsequent text written to the LCD will be displayed
  lcd.print("Distance: "); // Prints string "Distance" on the LCD
  lcd.print(distanceCm); // Prints the distance value from the sensor
  lcd.print(" cm");
  delay(10);
  lcd.setCursor(0, 1);
  lcd.print("Distance: ");
  lcd.print(distanceInch);
  lcd.print(" inch");
  delay(10);
}Code language: Arduino (arduino)

Voorbeeldcode met behulp van de NewPing-bibliotheek

Er is eigenlijk een eenvoudigere en betere manier om de Arduino te programmeren om afstand te meten met behulp van de HC-SR04 ultrasone sensor, en dat is met behulp van de NewPing-bibliotheek.

In de eerder uitgelegde code hebben we de sensor handmatig getriggerd en de ontvangen signaalpulsduur gemeten. Vervolgens hebben we op basis van die resultaten de afstand berekend. Met behulp van de NewPing-bibliotheek kunnen we de afstand bepalen met slechts een enkele regel code.

Hier is een voorbeeldcode:

#include <NewPing.h>

#define TRIGGER_PIN  9
#define ECHO_PIN     10
#define MAX_DISTANCE 400 // Maximum distance we want to measure (in centimeters).


NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and maximum distance.

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

void loop() {
  delay(50);                    // Wait 50ms between pings (about 20 pings/sec). 29ms should be the shortest delay between pings.

  int distance = sonar.ping_cm(); // Send ping, get distance in cm and print result (0 = outside set distance range)

  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println("cm");
}Code language: Arduino (arduino)

Het is veel eenvoudiger dan het vorige voorbeeld. We gebruiken gewoon de aanroep ping_cm() methode op het NewPing-sonarobject en we krijgen de afstand in centimeters. Als we de afstand in inches willen, kunnen we de ping_in() . gebruiken in plaats daarvan.

De bibliotheek heeft ook enkele andere handige functies. Bijvoorbeeld met de ping_median(iterations [, max_cm_distance]) methode, kunnen we nauwkeurigere resultaten krijgen, omdat het een mediaan of de middelste waarde van verschillende metingen retourneert. Met de iteraties parameter stellen we het aantal samples in dat het programma nodig heeft om de middelste waarde te berekenen. De standaardwaarde is 5 iteraties. De ping_median() retourneert de ontvangen pulsduur in microseconden.

Desalniettemin, voor meer info en details kun je de NewPing wiki-pagina bekijken.

Nauwkeurigheid van de HC-SR04-afstandssensor verbeteren met DHT22-temperatuursensor

De HC-SR04-sensor is redelijk nauwkeurig, maar omdat zijn werking afhankelijk is van de geluidssnelheid, moeten we voor nauwkeurigere resultaten ook rekening houden met de luchttemperatuur. De snelheid van het geluid kan aanzienlijk veranderen als de luchttemperatuur verandert. Bij 20°C is de geluidssnelheid bijvoorbeeld ongeveer 340 m/s, maar bij -20°C is de geluidssnelheid ongeveer 315 m/s. De relatieve vochtigheid heeft ook invloed op de snelheid.

Dus als we deze sensor gebruiken om afstanden bij verschillende temperaturen te meten, moeten we een temperatuurcompensatie implementeren, en dat kunnen we doen met de volgende formule:

Snelheid =331,4 + 0,6 x temperatuur + 0,0124 x relatieve vochtigheid

Hier is een voorbeeld:

Naast de HC-SR04 ultrasone sensor zullen we de DHT11 / DHT22-sensor gebruiken om de temperatuur en de vochtigheid van de omgeving te meten en de snelheid van de geluidswaarde dienovereenkomstig aan te passen.

Arduino-code

/*
  Example made by Dejan, How To Mechatronics,
  https://howtomechatronics.com/

*/

#include <NewPing.h>  // https://bitbucket.org/teckel12/arduino-new-ping/wiki/Home
#include "dht.h"      // https://github.com/RobTillaart/DHTlib

#define TRIGGER_PIN  9
#define ECHO_PIN     10
#define MAX_DISTANCE 400
#define dht22 5 // DHT22 temperature and humidity sensor

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);
dht DHT; // Creats a DHT object

int readDHT, temp, hum;
float speedOfSound, distance, duration;

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

void loop() {
  delay(100);

  // Read temperature and humidity from DHT22 sensor
  readDHT = DHT.read22(dht22); // Reads the data from the sensor
  temp = DHT.temperature; // Gets the values of the temperature
  hum = DHT.humidity; // Gets the values of the humidity


  speedOfSound = 331.4 + (0.6 * temp) + (0.0124 * hum); // Calculate speed of sound in m/s

  duration = sonar.ping_median(10); // 10 interations - returns duration in microseconds
  duration = duration/1000000; // Convert mircroseconds to seconds
  distance = (speedOfSound * duration)/2;
  distance = distance * 100; // meters to centimeters

  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println("cm");

}Code language: Arduino (arduino)

Dus eerst lezen we de temperatuur- en vochtigheidswaarden van de DHT22-sensor en gebruiken die waarden om de geluidssnelheid te berekenen. Vervolgens krijgen we de duur van de reis van de geluidsgolf in microseconden, converteren ze naar seconden en berekenen we de afstand van de sensor tot de objecten in centimeters.

HC-SR04 Afmetingen en 3D-model

Ik heb een 3D-model gemaakt van de HC-SR04 ultrasone sensor voor het geval je er een nodig hebt bij het maken van je volgende project. Je kunt het downloaden via de onderstaande link.

U kunt dit 3D-model vinden en downloaden op Thangs.

Dit zijn de afmetingen van de HC-SR04-sensor:

Houd er rekening mee dat ze soms een beetje kunnen verschillen, afhankelijk van de fabrikant.

Conclusie

We hebben dus vrijwel alles besproken wat we moeten weten over het gebruik van de HC-SR04 ultrasone sensor met Arduino. Het is een geweldige sensor voor veel doe-het-zelf-elektronicaprojecten waarbij we een contactloze afstandsmeting, detectie van aanwezigheid of objecten, waterpas of positie enz. nodig hebben.

Ik noemde de projecten die ik met deze sensor heb gemaakt al aan het begin van de post. Hier zijn enkele andere coole projecten die de HC-SR04-sensor en Arduino gebruiken:

• Touchless automatische bewegingssensor prullenbak
• Handgebaar Smart Light Control
• Mini akoestische levitatie
• Obstakel vermijdende robot

Ik hoop dat je deze tutorial leuk vond en iets nieuws hebt geleerd. Stel gerust een vraag in de opmerkingen hieronder en vergeet niet mijn volledige verzameling van 30+ Arduino-projecten te bekijken.