Interfacing the Sonar Sensor HC-SR04: Pinout, Math, and ESP32 Code

The sonar sensor HC-SR04 is the undisputed workhorse of hobbyist and prototyping distance measurement, typically costing between $1.50 and $3.00 per unit. However, getting reliable, jitter-free readings on modern 3.3V microcontrollers like the ESP32 requires more than just copying a basic tutorial. You must understand its digital pulse output, implement proper logic-level translation, and apply the correct time-of-flight math to convert raw microsecond readings into physical distance units.

How the HC-SR04 Ultrasonic Sonar Sensor Actually Works

The HC-SR04 relies on a 40 kHz piezoelectric transmitter to emit an eight-cycle ultrasonic acoustic burst. When this sound wave strikes a solid object, it reflects back to the onboard receiver transducer. The sensor's internal timing circuit measures the exact time-of-flight (ToF) between the initial trigger pulse and the returning echo, holding a digital pin HIGH for the duration of that round trip.

Because the speed of sound in dry air at 20°C is approximately 343 meters per second, your microcontroller can calculate the physical distance by halving the total travel time (since the sound travels to the object and back). This acoustic time-of-flight principle makes the HC-SR04 completely immune to ambient light, object color, and transparency—solving the exact failure modes that plague infrared time-of-flight sensors like the VL53L0X when scanning dark or clear surfaces.

HC-SR04 Specifications and ESP32 Wiring Table

Before writing any code, you must address the hardware reality: the HC-SR04 is a 5V device. While it will accept a 3.3V trigger signal from an ESP32 without issue, its Echo pin outputs a 5V TTL pulse. Feeding 5V directly into an ESP32 GPIO pin will eventually degrade or destroy the silicon. You must use a voltage divider or a dedicated logic level shifter.

Below is the exact wiring matrix for connecting the sensor to an ESP32 DevKit V1. We use a simple resistor voltage divider to step the 5V Echo signal down to a safe ~3.3V.

Translating the Echo Pulse: The Raw-to-Distance Math

A common point of confusion for beginners is what the sensor actually outputs. The HC-SR04 does not output an analog voltage that scales with distance, nor does it use a current loop or I2C/SPI data packets. The output is strictly a digital 5V TTL pulse. The width of that pulse, measured in microseconds (µs), is your raw data point.

To convert that raw microsecond reading into centimeters or inches, we use the speed of sound. At 20°C in dry air, sound travels at 343 meters per second, which translates to 0.0343 cm/µs. Because the sound makes a round trip, we must divide the total distance by two.

• Distance (cm) = (Pulse Width in µs × 0.0343) / 2
• Simplified Divisor (cm) = Pulse Width in µs / 58.3
• Simplified Divisor (inches) = Pulse Width in µs / 148

Calibration and Temperature Scaling

Hardcoding the '58' divisor works fine for indoor room-temperature projects. But if you are deploying this sensor in an unheated garage, a humid greenhouse, or an outdoor enclosure, the speed of sound changes. The speed of sound in air increases by approximately 0.606 m/s for every 1°C increase in temperature. For precision applications, you should dynamically calculate the divisor using the formula: v = 331.3 + (0.606 × Temperature_in_C). The code block in the next section implements this exact scaling.

Step-by-Step ESP32 Wiring and Code Implementation

Follow these steps to get your sensor running with temperature-compensated math and timeout protection.

1. Build the Voltage Divider: Solder or breadboard a 1kΩ resistor inline with the HC-SR04 Echo pin, and connect a 2kΩ resistor from the junction to GND. Wire the junction to ESP32 GPIO 18.
2. Connect Power and Trigger: Wire VCC to the ESP32 VIN (5V), GND to GND, and Trig directly to GPIO 5.
3. Upload the Firmware: Copy the C++ code below into your Arduino IDE. Ensure your board manager is set to the ESP32 Dev Module.

#define TRIG_PIN 5
#define ECHO_PIN 18
#define TEMP_C 20.0  // Adjust this to your ambient environment temperature
#define TIMEOUT_US 30000 // ~5 meters max range timeout to prevent code hanging

void setup() {
  Serial.begin(115200);
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  
  // Ensure trigger pin is low on startup
  digitalWrite(TRIG_PIN, LOW);
  Serial.println("HC-SR04 Initialized. Waiting for readings...");
}

void loop() {
  // 1. Send the 10µs Trigger Pulse
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);

  // 2. Read the Echo Pulse Width (with timeout safety)
  long duration = pulseIn(ECHO_PIN, HIGH, TIMEOUT_US);
  
  // 3. Calculate Temperature-Compensated Speed of Sound (m/s)
  float speedOfSound = 331.3 + (0.606 * TEMP_C); 
  
  // 4. Convert to cm/µs and calculate one-way distance
  float distanceCm = (duration * (speedOfSound / 10000.0)) / 2.0;
  
  // 5. Output Results
  if (duration == 0) {
    Serial.println("Error: Out of range or timeout (No echo received).");
  } else if (distanceCm < 2.0) {
    Serial.println("Warning: Inside 2cm blind zone.");
  } else {
    Serial.print("Raw Pulse: ");
    Serial.print(duration);
    Serial.print(" µs | Distance: ");
    Serial.print(distanceCm, 2);
    Serial.println(" cm");
  }
  
  // Wait 60ms before next reading to prevent acoustic echo overlap
  delay(60);
}

Real-World Interference and Calibration Fixes

When you move from a clean workbench to a real-world deployment, the HC-SR04 will encounter physical and electrical interference. Here is how to diagnose and fix the most common failure modes.

1. Acoustic Crosstalk in Sensor Arrays

If you are building a rover or drone with multiple HC-SR04 sensors, firing them simultaneously will cause 'crosstalk'—Sensor A will read the echo bounce from Sensor B's transmit burst, resulting in wildly inaccurate, short distance spikes. The Fix: Never trigger multiple sensors at the exact same millisecond. Stagger your trigger pulses in code by at least 50ms to 100ms, allowing the acoustic energy to dissipate before the next sensor fires.

2. Power Rail Brownouts and Jitter

The HC-SR04 draws a sudden 15mA spike when the piezoelectric transmitter fires. If your 5V power rail is weak (common when powering the ESP32 and sensor directly from a cheap USB wall wart), this spike causes a micro-brownout. The sensor's internal logic resets, resulting in a dropped reading or a stuck HIGH echo pin. The Fix: Solder a 100µF electrolytic capacitor directly across the VCC and GND pins on the sensor's PCB. This provides local energy storage to handle the transmit spike without pulling down the main rail.

3. Soft Targets and Angular Deflection

Ultrasonic waves behave like light when hitting angled surfaces. If the sonar sensor HC-SR04 is pointed at a wall at a 45-degree angle, the sound wave will deflect away from the receiver rather than bouncing straight back. Similarly, acoustic foam, heavy curtains, or thick clothing will absorb the 40 kHz frequency rather than reflecting it. The Fix: If your application requires detecting soft or highly angled targets, the HC-SR04 is the wrong tool. Switch to an infrared time-of-flight sensor (like the STMicroelectronics VL53L1X) or a millimeter-wave radar module (like the LD2410), which are immune to acoustic absorption and angular deflection.

For further reading on ESP32 GPIO tolerances and safe voltage translation, refer to the official Espressif ESP32 Datasheet. Understanding the physical limitations of acoustic time-of-flight will save you hours of debugging phantom readings in your embedded projects.