Measuring Ultrasonic Sensor Distance: HC-SR04 vs Waterproof JSN-SR04T

The Physics: How Ultrasonic Sensor Distance is Calculated

Ultrasonic distance measurement relies on Time-of-Flight (ToF) acoustics. The sensor’s piezoelectric transducer acts as both a speaker and a microphone. When triggered, it emits a short burst of eight 40kHz ultrasonic pulses—a frequency well above human hearing. These sound waves travel through the air at roughly 343 meters per second, strike a target object, and bounce back to the transducer.

The sensor’s internal timing circuit measures the exact microsecond duration between the initial trigger pulse and the returning echo. Because the sound wave had to travel to the object and back, the total transit time is double the actual distance. By halving the time and multiplying it by the speed of sound, the microcontroller calculates the physical gap between the transducer face and the target.

Hardware Decision Tree: Which Transceiver Do You Actually Need?

Not all 40kHz transceivers are built for the same environment. The open-mesh HC-SR04 is a bench favorite, but it fails rapidly in high-humidity or outdoor applications because condensation shorts the exposed solder joints on the transducer mesh. Here is how to select the right hardware for your build.

Wiring, Pinouts, and Logic Level Shifting

A common misconception is that these sensors output an analog voltage proportional to distance. They do not. The output of the HC-SR04 and JSN-SR04T is a digital 5V pulse. The microcontroller triggers the sensor, and the sensor responds by holding the Echo pin HIGH (5V) for a duration in microseconds that exactly matches the transit time.

The Math: Converting Raw Microseconds to Centimeters

When you call a function like pulseIn() on your microcontroller, it returns a raw integer representing microseconds (µs). To convert this raw reading to a physical unit, we use the speed of sound.

At standard room temperature (20°C / 68°F), sound travels at roughly 343 meters per second, which translates to 0.0343 centimeters per microsecond. Because the sound makes a round trip, we divide by 2.

Base Formula:
distance_cm = (duration_us * 0.0343) / 2

Calibration and Scaling:
The speed of sound is not a fixed constant; it scales with ambient air temperature. If your sensor is measuring an outdoor water tank in winter versus summer, your readings will drift by up to 4% if you ignore temperature. The calibrated speed of sound formula is:
Speed (cm/µs) = (331.4 + (0.606 * Temperature_Celsius)) / 10000

For high-precision liquid level sensing, pipe a DS18B20 waterproof temperature probe into your ESP32, calculate the dynamic speed of sound on every loop, and apply it to the divisor. For indoor room-mapping robots, the static 0.0343 constant is perfectly adequate.

Interference, Blind Spots, and Acoustic Shadows

Ultrasonic sensors do not emit a tight laser beam; they project a conical acoustic field (typically 15° to 30° wide). This physics reality introduces three specific failure modes you must design around:

• The Blind Spot: The transducer cannot listen while it is ringing (emitting). The HC-SR04 has a minimum blind spot of ~2cm. The JSN-SR04T has a much larger blind spot of 20cm to 25cm. If your target enters this zone, the sensor will output a maximum-range ghost reading (usually 400cm+).
• Acoustic Shadows and Angles: If sound hits a smooth surface at an angle greater than 45°, it reflects away from the transducer (specular reflection) rather than bouncing back. The sensor will read 'no obstacle' even if a wall is directly in front of it.
• Soft Target Absorption: 40kHz sound waves are heavily absorbed by porous materials. A sensor that easily detects a wooden door at 4 meters might fail to detect a foam cushion or heavy fabric curtain at 1 meter.
• Cross-Talk: If you mount multiple ultrasonic sensors on a single robot, they will trigger each other's echo pins. You must fire them sequentially in code, waiting for the echo timeout of Sensor A before triggering Sensor B.

ESP32 Implementation and Edge-Case Debugging

Below is a production-ready implementation for the ESP32 DevKit V1. It includes the voltage divider assumption, a timeout to prevent the code from hanging if no echo returns, and a median filter to discard acoustic ghost readings.

Wiring Steps:

1. Connect JSN-SR04T 5V pin to ESP32 VIN (or external 5V supply).
2. Connect GND to ESP32 GND.
3. Connect Trig directly to ESP32 GPIO 5.
4. Connect Echo through a 1kΩ resistor to ESP32 GPIO 18. Connect a 2kΩ resistor from GPIO 18 to GND.

ESP32 Arduino IDE Code:

#include <Arduino.h>

// Pin Definitions (ESP32 DevKit V1)
const int TRIG_PIN = 5;
const int ECHO_PIN = 18;

// Sensor Constants
const float SPEED_OF_SOUND_CM_US = 0.0343; // at 20C
const int MAX_DISTANCE_CM = 400;
const long MAX_TIMEOUT_US = (MAX_DISTANCE_CM * 2) / SPEED_OF_SOUND_CM_US;

// Median filter array to drop ghost readings
long readings[5];
int readIndex = 0;

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

long getMedianDistance() {
  // 1. Trigger the 40kHz burst
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);

  // 2. Read the echo pulse width with a hard timeout
  long duration = pulseIn(ECHO_PIN, HIGH, MAX_TIMEOUT_US);
  
  // 3. Handle timeout (returns 0 if no echo within range)
  if (duration == 0) {
    return -1; // Indicates out-of-range or blind spot
  }

  // 4. Raw to Unit Math
  long distance_cm = (duration * SPEED_OF_SOUND_CM_US) / 2;
  
  // 5. Push to filter array
  readings[readIndex] = distance_cm;
  readIndex = (readIndex + 1) % 5;

  // 6. Simple bubble sort for median extraction
  long sorted[5];
  memcpy(sorted, readings, sizeof(readings));
  for(int i=0; i<4; i++) {
    for(int j=i+1; j<5; j++) {
      if(sorted[j] < sorted[i]) {
        long temp = sorted[i];
        sorted[i] = sorted[j];
        sorted[j] = temp;
      }
    }
  }
  return sorted[2]; // Return the median value
}

void loop() {
  long dist = getMedianDistance();
  
  if(dist == -1) {
    Serial.println("Status: Out of Range / Timeout");
  } else {
    Serial.printf("Ultrasonic Sensor Distance: %ld cm\n", dist);
  }
  
  // Wait 60ms to prevent acoustic cross-talk and ring-over
  delay(60);
}

For deeper insights into managing ultrasonic noise in multi-sensor arrays, refer to the Arduino pulseIn() documentation for timing specifics, and consult Texas Instruments' ultrasonic sensing application notes for advanced analog front-end design if you decide to build a custom transceiver circuit from raw piezo elements.