HC-SR04 ultrasonic sensor, distance 2–450 cm, 5V

The HC-SR04 ultrasonic sensor is the most commonly used component for measuring distance in Arduino projects, being found in mobile robots that need to avoid obstacles, in assisted parking systems, in measuring the liquid level in a tank, or in any setup that needs an approximate distance to an object in front of the sensor.

The module has two ultrasonic transducers visible on the front of the board, an oscillator crystal, and a 4-pin header Vcc, Trig, Echo, and Gnd, being ready to work immediately after connection, without additional calibration.

How it works:

The sensor uses the echolocation principle. You send a HIGH pulse of at least 10 us on the Trig pin, and the module responds by sending a packet of 8 ultrasonic cycles at 40 kHz. At the same time, the Echo pin goes HIGH and stays that way until the sound reflected by the object is received back by the sensor.

The duration in microseconds that Echo stays HIGH is read with the pulseIn function and converted into distance by dividing by 58 for centimeters, the formula coming from the speed of sound of 340 m/s divided by 2, because the sound travels the distance there and back. The farther the object is, the longer the pulse on Echo will be.

What you need:

• 1 x HC-SR04 Ultrasonic Sensor
• 1 x Uno R3 Development Board with ESP8266 Wifi, Arduino compatible
• 4 x 40 Dupont Wires 10cm, Female-Female
• 1 x Breadboard 830 points MB-102

Wiring:

The sensor works at 5 V on all 4 pins, and on an Arduino Uno board, which also has 5 V logic, it connects directly, without a level converter or additional resistors.

Code:

Upload the program below to your Arduino Uno, which generates the trigger pulse, reads the echo duration, and displays the calculated distance on the serial monitor.

// HC-SR04 Ultrasonic Distance Sensor with Arduino Uno
// Wiring:
// HC-SR04 Vcc -> Arduino 5V
// HC-SR04 Trig -> Arduino D9
// HC-SR04 Echo -> Arduino D10
// HC-SR04 Gnd -> Arduino GND
// No library required
const int trigPin = 9;
const int echoPin = 10;
long duration;
float distanceCm;
void setup() {
  Serial.begin(9600);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  digitalWrite(trigPin, LOW);
}
void loop() {
  // Send a clean LOW pulse before triggering
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  // Send the 10 microsecond trigger pulse required by the sensor
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  // Measure the duration of the HIGH pulse on the echo pin, in microseconds
  duration = pulseIn(echoPin, HIGH);
  // Convert the duration to distance in centimeters
  distanceCm = duration / 58.0;
  Serial.print("Distance: ");
  Serial.print(distanceCm);
  Serial.println(" cm");
  // Wait before the next measurement, more than the recommended 60 ms
  delay(100);
}

How the code works:

At the beginning of the program, the constants trigPin and echoPin are defined, which store the numbers of the digital pins D9 and D10 used for the connection, along with the variable duration for the pulse duration and distanceCm for the result in centimeters.

In the setup function, the serial communication is initialized at 9600 baud, the trigPin is configured as an output, and the echoPin as an input, then trigPin is explicitly brought to LOW to start from a known state.

In the loop function, the program first brings trigPin to LOW for 2 microseconds, then raises it to HIGH for 10 microseconds and brings it back to LOW, respecting exactly the minimum trigger duration required by the sensor. The pulseIn function is called on echoPin to measure, in microseconds, how long the pin stays HIGH, this value being stored in duration.

The distance distanceCm is calculated by dividing duration by 58, according to the formula from the datasheet, and the result is displayed on the serial monitor together with the unit of measurement. A 100 millisecond pause at the end of loop ensures a safe interval between two successive measurements, longer than the recommended 60 ms.

Result:

Open the serial monitor at 9600 baud and you will see the measured distance, updated approximately 10 times per second, with values decreasing or increasing as you bring an object closer to or farther from the sensor.

Distance: 23.45 cm
Distance: 23.38 cm
Distance: 45.12 cm
Distance: 120.67 cm
Distance: 118.90 cm
Distance: 450.00 cm
Distance: 8.62 cm
Distance: 8.55 cm

Common issues:

If nothing appears on the serial monitor, check that the speed selected in the monitor is 9600 baud and that you have chosen the correct COM port for the connected board.

If the displayed distance is always 0 or a very large number, check the wires on Trig and Echo, as they are easy to swap, and pulseIn is waiting for the signal on the wrong pin.

If the values are unstable or jump suddenly, move the target object away from edges and angled surfaces, as these reflect the sound in a different direction than towards the sensor.

If the sensor does not react when there is nothing in front of it, the pulseIn function has a default timeout of one second, and the code will wait for this interval before continuing, which slows down the display, being normal in the absence of an object within the measuring range.

If the distance is constantly smaller than the real one, check that the target surface has at least 0.5 square meters, otherwise part of the ultrasonic wave bypasses the object and does not return to the receiver.

Limitations and tips:

The sensor measures correctly only in front of the two transducers, on a cone of about 15 degrees, and soft or absorbent materials such as textiles or foam strongly reduce the echo. The usable distance starts from 2 cm and can reach up to about 450 cm under good conditions, with a resolution on the order of 0.3 cm, sufficient for most robotics and automation projects, however for higher precision measurements or in environments with strong acoustic noise, a specialized ultrasonic or laser sensor is recommended.