HC-SR04 Ultrasonic Sensor: Wiring, Code and Real Accuracy

The HC-SR04 is the first sensor almost every embedded project uses, and the first one almost every project gets wrong. It is not a rangefinder — it is a stopwatch attached to a loudspeaker. Once you treat it that way, the accuracy problems, the stuck readings and the phantom 0 cm values all have obvious fixes.

This guide covers the working wiring for both 5 V and 3.3 V boards, the timing maths behind pulseIn(), temperature compensation, three levels of code (blocking, non-blocking, filtered), the beam geometry that decides what the sensor can and cannot see, and a troubleshooting table built from the failures we see most often in the lab.

• Range 2–400 cm
• Accuracy ±3 mm (ideal)
• Beam ~15° cone
• Supply 5 V, ~15 mA
• Interface Trig / Echo
• Rate ≤ 25 Hz practical

How the HC-SR04 actually measures distance

The module holds a 40 kHz transmitter (marked T) and a receiver (marked R). The sequence never changes:

1. You raise Trig for 10 µsAnything shorter and the module may ignore it; anything much longer is harmless but wasted time.
2. The module fires an eight-cycle 40 kHz burstThat burst leaves the transmitter as a cone of sound, not a laser line — this is the single most important physical fact about the sensor.
3. Echo goes HIGHIt stays HIGH until the receiver detects a returning burst, or until the module gives up (~38 ms).
4. You measure how long Echo stayed HIGHThat pulse width, in microseconds, is the round-trip flight time of the sound.

So the distance is not measured — it is calculated from time. At 20 °C, sound travels at roughly 343 m/s, or 0.0343 cm/µs. The pulse covers the distance twice (out and back), which gives the formula every Arduino tutorial repeats without explaining:

distance_cm = pulse_us × 0.0343 / 2
            = pulse_us / 58.3          // the "magic" 58 in most sketches

Wiring to Arduino, ESP32 and ESP8266

The HC-SR04 is a 5 V part. It needs 5 V on VCC to fire a burst with usable energy, and its Echo pin drives out at 5 V logic. That is fine on an Arduino Uno and not fine on an ESP32 or ESP8266, whose GPIO are 3.3 V.

The divider on Echo is two resistors: 1 kΩ from Echo to the GPIO, and 2 kΩ from that GPIO node to GND. That drops 5 V to about 3.3 V. It costs two components and saves the board.

Code: blocking, non-blocking and filtered

Level 1 — the standard blocking read

Correct, readable, and fine for a first project. Note the timeout: without it, pulseIn() blocks for a full second when no echo returns.

Arduino / ESP32 · blocking

const uint8_t TRIG = 5;
const uint8_t ECHO = 18;
const unsigned long TIMEOUT_US = 30000UL;   // ~5 m of round trip

void setup() {
  Serial.begin(115200);
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  digitalWrite(TRIG, LOW);
}

// returns distance in cm, or -1.0 on timeout
float readDistanceCm() {
  digitalWrite(TRIG, LOW);
  delayMicroseconds(4);
  digitalWrite(TRIG, HIGH);
  delayMicroseconds(10);            // the datasheet's 10 us trigger
  digitalWrite(TRIG, LOW);

  unsigned long us = pulseIn(ECHO, HIGH, TIMEOUT_US);
  if (us == 0) return -1.0;         // nothing came back
  return us / 58.3;                 // cm at ~20 C
}

void loop() {
  float d = readDistanceCm();
  if (d < 0)        Serial.println("out of range");
  else              Serial.printf("%.1f cm\n", d);
  delay(60);                        // >= 60 ms between pings: let echoes die
}

Level 2 — non-blocking with interrupts

pulseIn() stalls your whole program for up to the timeout. On an ESP32 running Wi-Fi, or any robot that must keep its motors alive, measure the echo with an interrupt instead.

ESP32 · interrupt-driven, no blocking

const uint8_t TRIG = 5;
const uint8_t ECHO = 18;

volatile unsigned long riseUs = 0;
volatile unsigned long echoUs = 0;
volatile bool          haveReading = false;

void IRAM_ATTR onEcho() {
  if (digitalRead(ECHO)) {
    riseUs = micros();                      // burst left
  } else {
    echoUs = micros() - riseUs;             // burst returned
    haveReading = true;
  }
}

unsigned long lastPing = 0;

void setup() {
  Serial.begin(115200);
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  attachInterrupt(digitalPinToInterrupt(ECHO), onEcho, CHANGE);
}

void loop() {
  // fire a ping every 60 ms without ever blocking
  if (millis() - lastPing >= 60) {
    lastPing = millis();
    digitalWrite(TRIG, HIGH);
    delayMicroseconds(10);
    digitalWrite(TRIG, LOW);
  }

  if (haveReading) {
    haveReading = false;
    unsigned long us = echoUs;
    if (us > 200 && us < 30000) {           // ignore junk edges
      Serial.printf("%.1f cm\n", us / 58.3);
    }
  }

  // ... motors, Wi-Fi, display all keep running here
}

Level 3 — the filter that makes it usable

A raw HC-SR04 stream contains occasional wild outliers: a burst that found a chair leg, or an edge missed under interrupt load. A median of the last five readings removes them almost completely, and unlike an average it does not smear a real, sudden change in distance.

Any board · median-of-5 filter

float buf[5];
uint8_t idx = 0;
bool filled = false;

float medianDistance(float fresh) {
  if (fresh < 0) return -1.0;
  buf[idx] = fresh;
  idx = (idx + 1) % 5;
  if (idx == 0) filled = true;
  uint8_t n = filled ? 5 : idx;

  float t[5];
  for (uint8_t i = 0; i < n; i++) t[i] = buf[i];
  for (uint8_t i = 1; i < n; i++) {          // insertion sort, n = 5
    float k = t[i]; int8_t j = i - 1;
    while (j >= 0 && t[j] > k) { t[j+1] = t[j]; j--; }
    t[j+1] = k;
  }
  return t[n / 2];
}

Accuracy, temperature and the speed of sound

The ±3 mm figure on the datasheet is a laboratory number: a flat, hard target, square to the sensor, at room temperature, at about 30 cm. In a real project the dominant error is not the module — it is the constant in your formula. The speed of sound changes with air temperature by roughly 0.6 m/s per °C:

speed_m_s = 331.3 + 0.606 × T_celsius

Five centimetres of error at two metres, purely from heat. If your project needs better than a few percent — a tank level gauge, a height measurement, a parking stop line — pair the HC-SR04 with a temperature sensor you already have in the kit and compute the speed at runtime:

// with a DHT22 / DS18B20 already reading tempC
float speed  = 331.3 + 0.606 * tempC;        // m/s
float cmPerUs = speed * 100.0 / 1000000.0;   // cm per microsecond
float dist_cm = (pulse_us * cmPerUs) / 2.0;

What the beam can and cannot see

The burst spreads out in a cone of roughly 15°. At 1 m that cone is about 26 cm wide; at 3 m it is nearly 80 cm wide. The module reports the first strong echo inside that cone — not the object you are pointing at.

Two practical consequences. First, mount the sensor at least 20–30 cm above the floor and tilt it slightly up, or the cone will find the ground and report the floor distance forever. Second, if you need to know which object is where, one HC-SR04 cannot tell you — use two or three with staggered pings, and give each its own 60 ms slot so they do not hear each other.

When to stop using an HC-SR04

Troubleshooting table

Frequently asked questions