Measuring distance with the HC-SR04

The HC-SR04 measures distance with sound. It sends a short burst of ultrasound and measures how long the echo takes to come back. The farther away the object is, the longer the wait.

#How an echo becomes a distance

Sound travels through air at about 343 m/s at 20 °C. When it hits a wall, part of it bounces back. If you know how long the sound was away, you know how far it went. Bats use the same idea to find their way in the dark.

The HC-SR04 uses sound at 40 kHz. People hear only up to about 20 kHz, so you hear nothing. Its two round "eyes" are a small speaker, marked T (transmitter), and a microphone, marked R (receiver).

#The four pins

The sensor is made for 5 V. Never connect VCC to the battery.

#One measurement, step by step

1. The Uno sets TRIG LOW for 2 microseconds (µs), so that the pulse starts from a clean LOW.
2. It sets TRIG HIGH for 10 µs and then LOW again. This pulse means "measure now".
3. The sensor sends a burst of eight pulses of 40 kHz sound.
4. As soon as the sound has left, the sensor sets ECHO HIGH.
5. When the echo comes back, the sensor sets ECHO LOW.
6. The length of the HIGH pulse on ECHO is the time the sound needed to reach the object and come back.

#The sketch

readDistanceCm() does steps 1 to 6 and turns the pulse into centimetres. median3() picks the middle one of three readings. loop() measures three times, 60 ms apart, and prints the middle value. setup() makes TRIG an output and ECHO an input, and starts Serial. The delay(60) at the end of loop() keeps the same pause between the last ping of one pass and the first ping of the next. The next sections explain each number.

#Why divide by 58?

At 343 m/s, sound travels 0.0343 cm in one microsecond. So one centimetre takes about 29 µs. But the sound must go there and back: 2 cm of travel for every centimetre of distance. So each centimetre of distance adds about 58 µs to the ECHO pulse:

distance in cm = ECHO pulse in µs / 58

In the sketch, us / 58 divides whole numbers, so the result is a whole number too. The part after the point is dropped: 1,199 / 58 gives 20, not 20.7. For a robot, steps of 1 cm are precise enough.

#pulseIn() and its 25 ms timeout

pulseIn(ECHO, HIGH, 25000UL) waits for ECHO to go HIGH, measures how long it stays HIGH, and returns that time in microseconds. UL marks 25000 as an unsigned long, the type of the timeout.

The third number is the timeout: 25,000 µs, or 25 ms. If the pulse has not ended by then, pulseIn() stops waiting and returns 0. Why 25 ms? An echo from 4 m, the sensor's limit, takes about 23 ms. So 25 ms covers every echo in range, with a small margin. Without a timeout, pulseIn() waits up to one second, and during that time the sketch does nothing else.

Even with the timeout, pulseIn() makes the sketch wait while the sound travels: about 6 ms for a wall 1 m away, and the full 25 ms when no echo comes. For a robot, such short waits are acceptable. Long waits are a problem, as the lesson Programs that never wait shows.

When nothing is within about 4 m, no echo ends the pulse in time, and pulseIn() returns 0. The sketch turns that into 400:

if (us == 0) return 400;
return us / 58;

400 means "nothing within about 4 m". It is a large number on purpose: a check such as distanceCm < 25 then treats "no echo" as "the way is clear".

#Why wait 60 ms between pings?

After a ping, the sound keeps bouncing around the room for a while. If the next ping starts too soon, an old echo from a far wall can arrive and look like a new, near one. So the sketch waits 60 ms between pings. In 60 ms, sound travels about 20 m. By then, the old echoes are too weak to fool the sensor.

#The median of three

Sometimes one reading is simply wrong. An echo gets lost and you read 400. Or an old echo arrives and you read too little. One wrong number can make a robot turn for no reason.

So the sketch measures three times, 60 ms apart, and keeps the middle value, called the median. median3() first checks whether b lies between a and c, in either order. If it does, b is the median. If not, it checks a in the same way. If neither is in the middle, c must be.

One wrong reading cannot get through, as long as the other two agree. An average, in contrast, is ruined by it. The price is speed: each printed result needs three pings, so a new line comes only four or five times a second, instead of about sixteen.

#What the sensor cannot see

• Too close or too far. It measures from about 2 cm to about 4 m. Closer than 2 cm, the readings are wrong.
• Beside the robot. It listens in a narrow cone, about 15 degrees wide. It sees what is ahead, not what is beside the robot. If two objects are in the cone, you get the nearer one.
• Soft surfaces. Curtains, sofas, foam and clothes absorb sound. The echo is weak or missing.
• Slanted surfaces. A wall met at a steep angle reflects the sound away, as a mirror reflects light. You read 400, or a distance that is too long if the sound comes back by another wall. The simulator's sensor also ignores a wall that it meets at a steep angle.
• Small or thin objects. A pen or a chair leg sends back too little sound and can be missed.

#Temperature

The speed of sound changes by about 0.6 m/s for every degree Celsius. The number 58 assumes about 20 °C. Here is what the sketch shows for a wall exactly 1 m away:

For a robot that avoids walls, a few centimetres do not matter. For a measuring tool that you use in winter and in summer, they do.

#Reading the Serial Monitor in the arena

Serial.begin(9600) in setup() opens the serial link at 9600 baud. Each pass of loop() then prints one line, such as Distance: 57 cm.

Start the robot in an arena and open the Serial Monitor. What you will see:

• A new line four or five times a second.
• The number is the distance to whatever is in front of the sensor.
• If nothing is within about 4 m, the line says Distance: 400 cm.
• The robot stands still, because this sketch never drives the motors.

The arena's live distance readout shows the distance too, so you can check the sketch's numbers against it. If every line says 400 although a wall is close, check the wiring. A sensor without power, or with a loose TRIG or ECHO wire, never answers. On a real robot, open the Serial Monitor in the Arduino IDE and choose 9600 baud, the same number as in Serial.begin().

#Next

The Obstacle avoider uses readDistanceCm() while the robot drives. The lesson Programs that never wait shows how it measures and moves at the same time. The Keep distance robot uses the same function to follow your hand.