Arduino - HC-SR04 Ultrasonic Sensor

The HC-SR04 Ultrasonic Sensor is a device that uses ultrasonic sound to measure distances. When it works - it is very cool.

This page exists because it DOESN'T work .. without a little help :)

Background

There are several common sonar devices used with Arduinos to measure distance.

Device	Connector	Trigger and Sense	Price
PING))) ultrasonic rangefinder	3 pins	shared pin	$30	A single pin is used for both input and output, direction reversed as required
HC-SR04 ultrasonic rangefinder	4 pins	separate pins	<$1 from China	Unfortunately, some of these have a small design problem (feature) "Fix" (actually, a work around) described below
Grove ultrasonic rangefinder	4 pins	shared pin	~$14	Their library reads echo using pulseIn

The example code, available from the Arduino IDE via

File / Examples / 06.Sensors / Ping

is for the PING))) ultrasonic rangefinder - besides power and ground, it uses a single Arduino pin and changes it from input to output as required. While the Grove device has 4 pins, their library is similar to what is used for the PING))) 3-pin device.

Code for the HC-SR04 is similar, but uses 2 separate Arduino pins. For example

Unfortunately, there appear to be 2 different versions of the HC-SR04

One that automatically times out if the reflection (echo) is never detected
And one that doesn't !

They both have the same part number and the only way (that I know of) to tell them apart is to test them. (Well .. the price may be an indicator - perhaps the really cheap ones are being dumped for a reason .. or not. Who knows?) The point of this page is to explain this issue and to provide a "fix".

Basic operation

The HC-SR04 Ultrasonic Sensor (ranging module) connector has 4 pins

Power, Ground, Trigger (input), Echo (output)

When a trigger is received, the HC-SR04 produces 8 pulses at 40 KHz and sets the echo output high. When an echo is received, the echo output goes low. Assuming that you know the speed of sound (which is affected by air pressure, temperature, and humidity), it is possible to use the length of time that the echo output is high to compute the distance to a reflecting surface.

Using the example software (linked to above), the distance to an object is displayed in the serial monitor. To display the monitor, from the Arduino IDE menu select

Tools / Serial Monitor

or click the magnifying glass icon in the upper right of the IDE.

The software displays the distance between the sensor and some object. Unfortunately, the values are not very accurate because both programs use integer math and do not provide a way to adjust the values for the local speed of sound. This is, of course, acceptable for examples, but is something you should be aware of so you can "fix" it for your application (as required, or not).

NewPing Library

The NewPing Library for Arduino uses separate trigger and echo pins (required for the HC-SR04). Instead of using pulseIn() to read the echo, the library uses timer interrupts and masked digital I/O (presumably to make the code faster).

Download the zip file
Un-zip it

Copy (or move) the NewPing directory to the Arduino libraries directory

C:\downloads\Arduino\arduino-1.0.5-windows\arduino-1.0.5\libraries\NewPing

Restart the IDE (to create the following menu selection)

This procedure automatically places the provided examples under

File / Examples / NewPing

To test a sensor

Use File / Examples / NewPing / NewPingExample
Set the trigger and echo pins
Compile and load the sketch
Open the serial monitor

Note that the default comport baud rate is 115200 (the other programs use 9600) - if you see gibberish in the serial monitor, this is probably why.

Unfortunately, this program suffers from the same problem as the other example programs.

Failure

Nominally, the HC-SR04 works as expected. The problem occurs when no echo is received.

Using the example software linked to above, objects a foot or two away are easily detected. However, when you point the sensor at an object more than 9 or 10 feet away - the echo is simply so weak that it is not detected. In that case, the software displays zero (no signal detected). The same thing happens if you cover the transmitter with your hand (makes testing easier), or do something else to keep a reflection from being detected.

The problem occurs when you now place an object back within the range of the sensor - you still get zeroes. Just zeroes. Until you manually reset the sensor.

I originally thought that this was simply a defective sensor .. until an internet search revealed that it is a fairly common problem. The only suggested solution was to use a transistor (driven by the Arduino) to cycle power to the device - a kludge at best! But it does work.

Using an oscilloscope, I verified that the ping pulses were not being generated when the next trigger occurred. Apparently, with some devices, the next trigger resets the unit, a ping is sent, and the device continues to work normally (as advertised in the provided documentation). However, with the devices I bought, the next trigger does not reset the device. (Very frustrating!)

One way to "fix" the problem (and to verify that a ping pulse is not being generated) is to just snap your fingers. The receiver will detect the snap and finish its timeout (send the echo line LOW). After that, the sensor will work as expected until another pulse is not detected.

Solution

There are several "solutions" to this problem. Cycling power and snapping your fingers have already been mentioned. The simplest is to modify the software to

Assume that the echo pin is high (the code example below actually tests for it)
Configure the Arduino to drive the pin
Drive the echo pin low
Configure the Arduino to listen to the echo pin
Proceed with the pulses and timing used in the (failing) examples

To be explicit

int  inputPin = 8;   // Echo    pin on D8
int outputPin = 7;   // Trigger pin on D7
int distance  = -1;  // just a flag so it won't be zero the first time

void setup()
{
 Serial.begin(9600);
 pinMode( inputPin,  INPUT);
 pinMode(outputPin, OUTPUT);
}

void loop()
{
 if (distance == 0) {                   // only when there was no echo
   pinMode(inputPin, OUTPUT);
   digitalWrite(inputPin, LOW); 
   delayMicroseconds(10);               // shorter periods are not reliable
   pinMode(inputPin, INPUT);
   delayMicroseconds(10);
   distance = digitalRead(inputPin);    // the echo pin should now be low
   if (distance == 1){
     Serial.println("echo still high"); // mainly for debug 
      delay(500);
   }
 }

 delayMicroseconds(2);
 digitalWrite(outputPin, HIGH); // Pulse for 10 盜 to trigger ultrasonic sensor
 delayMicroseconds(10);
 digitalWrite(outputPin, LOW); 
 distance = pulseIn(inputPin, HIGH, 20000); // Read receiver pulse time
 distance= distance/58;                     // Transform pulse time to distance
 Serial.println(distance);                  // Output distance 
 delay(50); 
}

This code is modified from the examples

The delay period at the end of the loop is 50 milliseconds - 100 or more in other examples
The pulseIn timeout is 20,000 microseconds - 1 second (default) in most examples

Documentation

This pdf provides a general description of the HC-SR04. However, the translation is pretty bad - for instance,

The module is not suggested to connect directly to electric, if connected electric, the GND terminal should be connected the module first, otherwise, it will affect the normal work of the module.

What I think this really means is

The module should not be connected to a system which currently has power supplied. However, if you do, be sure to make the GND connection first.

I have repeated that particular example here because I have seen it, copied exactly, on numerous ebay offers of the device. In addition, one way to "fix" the problem (as mentioned above) is to cycle the power (disconnect and then reconnect the power) to the device.

Schematics

I was able to find 2 reverse engineered schematics

These are the main differences

The pullup resistors on trig and echo were removed
The pullup on the reset pin was removed
The power to the pulse driver is always on

The heart of the sensor is the EM78P153 8-bit microprocessor.

Timing

Using a dual trace oscilloscope, I measured the following timing.

The trigger pulse is 15 us wide - the code says it should be 10 us

  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

The echo pin goes high after the eighth pulse is sent - which is 4.5 ms after the trigger goes low

The echo is high for 800 us for 5.25 inches (which displays as 5 in in the terminal)

800 us / 2 / (73.746 us/in) = 5.42 in

800 us / 2 / (74     us/in) = 5.41 in  (close enough, but reported as just 5 in)

To create a brighter scope trace,

Change the 100 ms delay in the main code loop to 10 ms
Change the pulseIn timeout from the default (one second) to 1000 us. This timeout is too short for actual use, but produces good scope traces.

duration = pulseIn(echoPin, HIGH);         // Default timeout is one second
duration = pulseIn(echoPin, HIGH, 1000);   // 1000 us works pretty good for test

References

2 videos - useful, but do not fix the reset problem

The 1st develops the basic code to use the device
The 2nd uses the device to measure distance

Arduino Robots - How to use Ping Ultrasonic Sensor

This code always writes the echo pin low .. even though it is always configured as an input. As far as I know, that does nothing except to disable the internal pull up resistor which is off by default anyway.

Speed of sound - This depends on air pressure, temperature, and humidity

hyperphysics provides a formula and a javascript calculator
Google provides "speed of sound at sea level = 340.29 m / s"

340 m/s * 100 cm/m * 1 s/ 10^6 microseconds = 0.034 cm/us

Author: Robert Clemenzi