Arduino with Ultrasonic Sensor Code: HC-SR04 & JSN-SR04T Guide

If you need reliable distance measurement for a robotics or automation project, the core arduino with ultrasonic sensor code relies on sending a 10-microsecond trigger pulse and measuring the echo return time using pulseIn(). The distance is calculated by multiplying the echo duration by the speed of sound (0.0343 cm/µs at 20°C) and dividing by two.

While basic tutorials show a three-line script, real-world environments introduce acoustic multipath echoes, USB voltage sag, and timing hangs. This guide provides production-ready code with timeout protection and median filtering, exact wiring tables, and a structured debugging framework for when your serial monitor spits out zeros.

Project Specs & Hardware Selection

Not all ultrasonic modules are created equal. The ubiquitous HC-SR04 is fine for indoor desktop projects, but it fails outdoors or in wet environments. Below is a data-dense comparison to help you select the right transducer for your specific build.

Pin Mapping & Wiring Rules

The standard HC-SR04 and JSN-SR04T both use a 4-pin interface. The critical hardware rule here is logic level matching. The Echo pin outputs the same voltage as the VCC pin. If you power the sensor with 5V, the Echo pin will output 5V. Feeding 5V into a 3.3V microcontroller pin (like the ESP32 or the Arduino R4 WiFi's 3.3V headers) will destroy the GPIO.

The Complete Arduino with Ultrasonic Sensor Code

Basic tutorials use a simple pulseIn() call, which will hang your microcontroller indefinitely if the sensor fails to return an echo (e.g., the sound wave scatters off an angled surface). The code below targets the Arduino Uno R3 and R4 and includes a strict 30,000-microsecond timeout (equivalent to ~5 meters) and a 3-sample median filter to reject acoustic ghosting.

/*
 * Robust Ultrasonic Distance Measurement
 * Target: Arduino Uno R3 / R4 (ATmega328P / RA4M1)
 * Sensor: HC-SR04 / JSN-SR04T (5V Logic)
 */

#define TRIG_PIN 9
#define ECHO_PIN 10
#define TIMEOUT_US 30000UL // 30ms timeout = ~5.1 meters max range
#define SPEED_OF_SOUND 0.03432 // cm per microsecond at 20°C

void setup() {
  Serial.begin(115200);
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  
  // Ensure Trigger pin is LOW on boot
  digitalWrite(TRIG_PIN, LOW);
  delay(100); // Let sensor stabilize
}

void loop() {
  float distance = getMedianDistance();
  
  if (distance < 0) {
    Serial.println("Error: Echo timeout - check wiring or sensor power");
  } else if (distance == 0) {
    Serial.println("Warning: Distance 0 cm - object inside blind zone");
  } else {
    Serial.print("Distance: ");
    Serial.print(distance, 2);
    Serial.println(" cm");
  }
  
  delay(60); // HC-SR04 needs ~60ms between reads to avoid echo overlap
}

// Function to get a single raw reading with timeout protection
float getRawDistance() {
  // 1. Clear the trigger pin
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  
  // 2. Send 10µs HIGH pulse
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  
  // 3. Read echo with timeout
  unsigned long duration = pulseIn(ECHO_PIN, HIGH, TIMEOUT_US);
  
  if (duration == 0) {
    return -1.0; // Timeout occurred
  }
  
  // Calculate distance (duration * speed / 2 for round trip)
  return (duration * SPEED_OF_SOUND) / 2.0;
}

// 3-sample median filter to reject acoustic multipath echoes
float getMedianDistance() {
  float samples[3];
  for (int i = 0; i < 3; i++) {
    samples[i] = getRawDistance();
    if (samples[i] < 0) return -1.0; // Abort if timeout
    delayMicroseconds(500); // Micro-delay between rapid bursts
  }
  
  // Simple sorting network for 3 elements
  if (samples[0] > samples[1]) { float t = samples[0]; samples[0] = samples[1]; samples[1] = t; }
  if (samples[1] > samples[2]) { float t = samples[1]; samples[1] = samples[2]; samples[2] = t; }
  if (samples[0] > samples[1]) { float t = samples[0]; samples[0] = samples[1]; samples[1] = t; }
  
  return samples[1]; // Return the median value
}

Debugging: When the Serial Monitor Fails

When your build fails, it rarely outputs a clean C++ compilation error; it outputs bad data. If your serial monitor is stuck, here are the first three things to check when it fails:

1. VCC Voltage Drop (USB Sag): The HC-SR04 draws a spike of ~15mA when firing the transducer burst. If your Arduino is powered via a weak USB hub, the 5V rail can dip to 4.2V, causing the sensor's internal oscillator to reset mid-flight. Measure the VCC pin with a multimeter during operation; it must stay above 4.8V.
2. Trigger Pulse Width: The sensor requires a minimum of 10µs HIGH pulse. If your code is interrupted by a high-priority timer or WiFi stack (on the R4 WiFi), the pulse might be cut short. Use an oscilloscope or logic analyzer to verify the TRIG pin holds HIGH for a full 10µs.
3. Acoustic Blanking Zone: Ultrasonic sensors have a physical blind zone (usually 2cm to 20cm depending on the model) where the transducer is still ringing from the transmit burst and cannot hear the echo. If an object is inside this zone, the sensor will output 0 or erratic maximums.

Ranked Causes for Common Serial Errors

Extending and Simplifying the Build

Depending on your project timeline and hardware constraints, you may want to abstract the timing math or add environmental compensation.

How to Simplify: The NewPing Library

If you do not want to manage pulseIn() timeouts and median filters manually, use the NewPing library. It handles the 60ms ping delay automatically and includes a built-in ping_median() function. However, note that NewPing disables timer interrupts during the ping, which can interfere with software serial or PWM motor control on the ATmega328P.

How to Extend: Temperature Compensation

The constant 0.03432 in our code assumes the ambient air is exactly 20°C (68°F). The speed of sound in air changes by roughly 0.6 m/s for every 1°C change in temperature. If your project operates in an unheated garage or an outdoor enclosure, your distance readings will drift by up to 5%.

Physics Formula:
Speed (cm/µs) = (331.3 + (0.606 * Temperature_C)) / 10000

To extend this build for industrial accuracy, wire an AHT20 or BME280 I2C temperature sensor to the Arduino's A4/A5 pins. Read the ambient temperature in the loop(), calculate the real-time speed of sound, and replace the hardcoded SPEED_OF_SOUND macro with a dynamic float variable. This single addition bridges the gap between a hobbyist toy and a professional-grade liquid level sensor.

For further reading on microcontroller timing functions, refer to the official Arduino pulseIn() documentation to understand how the underlying hardware timers count clock cycles during the echo phase.