Build a mini robotBeginnerLesson 2657 min read

Sensors: how a robot notices the world

Line sensors see dark and light, ultrasonic sensors measure distance with sound, and every sensor is a bit noisy. Learn what each one really tells you.

✦ Ask the tutor 🧪 Lab · 20 min 📝 Lesson test

Speed

Lesson in motion

In 60 seconds

Sensors: how a robot notices the world

Line sensors see dark and light, ultrasonic sensors measure distance with sound, and every sensor is a bit noisy. Learn what each one really tells you.

1/3

In simple words

Close your eyes and walk slowly towards a wall with your hands out. Your fingers tell you "wall!" just in time. A bat does something cleverer: it makes a squeak and listens for the echo. The quicker the echo comes back, the closer the wall. Robots use both tricks: sensors that feel what is right under them, and sensors that measure distance with sound.

A sensor turns something in the world, like light, sound or pressure, into a number your code can read. A robot only knows what its sensors tell it. If the sensors are wrong or blind in some place, the robot is too.

Infrared (IR) line sensors

A small IR line sensor has a tiny light that shines invisible infrared light down at the floor, and a detector next to it. A white or light floor reflects a lot of light back. Black tape reflects much less. The module turns this into a signal: "light" or "dark". Put two of them side by side at the front of the robot, and it can tell if the tape is under the left sensor, the right sensor or both.

They work best very close to the floor, usually a few millimetres to about a centimetre. Check your module's datasheet.
Many modules have a small screw (a potentiometer) to set the light/dark threshold. Adjust it on your real floor.
Sunlight also contains infrared light and can confuse them. Test in the room where the robot will run.
Some modules give HIGH on black and LOW on white, others the opposite. Always test and print the reading first.

Ultrasonic distance sensors

A common ultrasonic sensor, the HC-SR04, has two round "eyes": one sends a short burst of sound too high for us to hear, the other listens for the echo. The board measures how long the echo took. Sound travels about 343 metres per second in air at room temperature, which is about 0.0343 cm per microsecond. The sound goes there and back, so:

Python: from echo time to distancepython

SPEED_OF_SOUND = 0.0343          # cm per microsecond, in air at about 20 °C

def echo_to_cm(echo_microseconds):
    return echo_microseconds * SPEED_OF_SOUND / 2   # divide by 2: there and back

for us in [580, 1166, 2915, 5830]:
    print(f"echo took {us:5} microseconds  ->  about {echo_to_cm(us):5.1f} cm")

It sees in a cone, not a thin line. Our virtual sensor copies this with three rays.
Soft things (cloth, a sofa) absorb sound and may give no echo. A wall at a sharp angle can bounce the sound away, so the sensor "sees" nothing.
Very close objects, closer than a few centimetres, are often not measured correctly.

Every sensor is noisy

Real readings jump around. A distance sensor pointed at a still wall might say 40, 41, 39, 40, then suddenly 250 because one echo was missed. If your robot believes that one bad number, it may speed up into the wall. A simple fix is to keep the last few readings and use the median (the middle value when sorted). One wild reading cannot move the median much.

Python: a median filter removes a wild readingpython

import numpy as np

rng = np.random.default_rng(7)
true_cm = np.linspace(80, 20, 30)                  # robot drives towards a wall
readings = true_cm + rng.normal(0, 1.5, 30)        # small noise
readings[[9, 20]] = [250, 3]                       # two wild readings (missed echo, glitch)

def median3(values, i):
    return float(np.median(values[max(0, i - 2): i + 1]))

for i in range(6, 24, 2):
    print(f"true {true_cm[i]:5.1f}   raw {readings[i]:6.1f}   median of last 3 {median3(readings, i):6.1f}")

Sensor	What it tells you	Common trouble
IR line sensor	Is the floor under me dark or light?	Sunlight, shiny floors, wrong height or threshold
Ultrasonic (HC-SR04)	How far is the nearest thing ahead, roughly?	Soft or angled surfaces, very close objects, missed echoes
Wheel encoder	How far has each wheel turned?	Wheel slip means the robot did not really move that far
Bump switch	Did I touch something?	Only tells you after the touch

Watch out

A sensor that is silent is not the same as "nothing there". Many ultrasonic codes return 0 or a large number when no echo comes back. Decide on purpose what your robot does then. A cautious robot slows down when it is unsure.

Try this. In the median code, change the wild reading at index 20 to 150. Does the median still hide it? What if two wild readings come one after the other?

Watch and read more

Lab

A decide function that uses the distance sensor to slow down and stop 10–30 cm from a wall, from any starting point.

~20 min

The problem

This runs in your browser. The robot faces a wall at the right side of the room. s["distance"] is the distance in cm from the middle of the robot to the nearest thing ahead (at most 100).

Run the starter. The robot crashes into the wall.
Change decide so the robot drives forward, slows down as the wall gets close, and stops with its middle 10–30 cm from the wall.
It must work from different starting points, so use the sensor, not a step count. The check also tries a start you cannot see.
Tip: a smooth rule is speed = (distance − 20) / 40, kept between 0 and 1 with np.clip. Explain in one sentence why slowing down is safer than stopping suddenly on a real robot.

Practice lab

Edit the code and run it. Python runs in your browser — nothing is sent to our server.

Ctrl + Enter to run

import numpy as np
# ---------- Mini robot simulator (the same in every lab; you do not need to change it) ----------
ARENA, BASE, VMAX, DT = 200.0, 10.0, 20.0, 0.1   # arena cm, wheel gap cm, top speed cm/s, seconds per step
def line_y(x):                                   # black tape on the floor: straight, then a wave
    return 100 + 25 * (1 - np.cos((np.asarray(x) - 20) / 25))
def hit(px, py, obstacles, r):                   # True where a point (plus radius r) touches a wall or obstacle
    bad = (px < r) | (px > ARENA - r) | (py < r) | (py > ARENA - r)
    for ox, oy, orad in obstacles:
        bad = bad | (np.hypot(px - ox, py - oy) < orad + r)
    return bad
def read_sensors(x, y, th, obstacles):
    s, c, n = {"x": x, "y": y, "heading": th}, np.cos(th), np.sin(th)
    for name, side in (("left", 2), ("right", -2)):  # two IR line sensors, 6 cm ahead, 4 cm apart
        s[name] = int(abs(y + 6 * n + side * c - line_y(x + 6 * c - side * n)) < 3)  # 1 = sees tape
    s["offset"] = float(y + 6 * n - line_y(x + 6 * c))  # line-position sensor: cm left (+) or right (-) of tape
    d = np.arange(0, 100.0)                          # ultrasonic sensor: 3 rays in a narrow cone, max 100 cm
    ends = [d[hit(x + d * np.cos(th + a), y + d * np.sin(th + a), obstacles, 0)] for a in (-0.2, 0, 0.2)]
    s["distance"] = float(min([e[0] if len(e) else 100.0 for e in ends]))
    return s
def simulate(decide, start=(20, 100, 0.0), steps=300, obstacles=()):
    x, y, th = start
    path, crashed = [(x, y)], False
    for t in range(steps):
        s = read_sensors(x, y, th, obstacles)
        s["step"] = t
        left, right = np.clip(decide(s), -1, 1) * VMAX   # wheel speeds: -1 full back ... 1 full forward
        th += (right - left) / BASE * DT
        x, y = x + (left + right) / 2 * np.cos(th) * DT, y + (left + right) / 2 * np.sin(th) * DT
        path.append((x, y))
        if hit(x, y, obstacles, 5):                    # the robot is a circle with radius 5 cm
            crashed = True
            break
    return np.array(path), crashed
def show(path, obstacles=(), line=False):          # draw the arena and the path
    import matplotlib.pyplot as plt
    ax = plt.figure(figsize=(4, 4)).gca()
    if line: ax.plot(np.arange(20, 190), line_y(np.arange(20, 190)), "k", lw=5, alpha=0.3)
    for ox, oy, orad in obstacles: ax.add_patch(plt.Circle((ox, oy), orad, color="tab:red"))
    ax.plot(path[:, 0], path[:, 1], "b-", path[-1, 0], path[-1, 1], "bo")
    ax.set_xlim(0, ARENA); ax.set_ylim(0, ARENA); ax.set_aspect("equal"); plt.show()
# -------------------------------------------------------------------------------------------------

def decide(s):
    # s["distance"]: cm from the middle of the robot to the nearest thing ahead (max 100)
    return 1.0, 1.0                   # TODO: slow down as the wall gets close, and stop before it

for start_x in (30, 80):
    path, crashed = simulate(decide, start=(start_x, 100, 0.0), steps=300)
    print(f"start x={start_x}: crashed={crashed}, stopped {200 - path[-1, 0]:.1f} cm from the wall")
show(path)

Output

No output. Add print(...) to see values.

You are done when

The robot stops 10–30 cm from the wall from every starting point
The decision uses s["distance"], not a count of steps
The speed goes down smoothly as the wall gets closer
The sentence explains that a real robot needs time and distance to stop

Hard questions

Try to answer before you reveal. If you can answer these, you understood the lesson.

Q1Your robot stops at 20 cm in the simulator. On the real robot it bumps the wall. Give two likely reasons.Reveal

First, a real robot does not stop instantly: it rolls on a little after the motors stop, more on a smooth floor or with a heavy battery. Second, the real sensor reads less often and can miss an echo, so the code may react late. Also, the real sensor measures from the front of the robot, not the middle. Slow down earlier and add a safety margin.

Q2Why might a robot that uses only one ultrasonic sensor still hit a chair leg?Reveal

The sensor sees in a cone straight ahead, and thin, round objects reflect little sound. A chair leg can be outside the cone when the robot turns, or too thin to give a clear echo. Real robots combine sensors: a bump switch, side sensors or a camera.

Please sign in to continue.

Questions people ask

Why does my IR sensor work at home but not at school?

The floor, the tape and the light are different. A shiny floor, bright sunlight from a window or a different tape can change the reading. Adjust the threshold on the new floor and test again.

Can the ultrasonic sensor see a thin stick or a chair leg?

Sometimes not. Thin or round objects reflect only a little sound back. For those, robots add other sensors, such as bump switches or an IR distance sensor, or a camera.

Is the median always better than the average?

For rare wild readings, yes, it is usually better. But the median of the last few readings reacts a little later to real changes. Use a short window, such as 3 or 5 readings, so the robot still reacts in time.

Does temperature change the ultrasonic reading?

Yes, a little. Sound travels a bit faster in warm air than in cold air. For a small robot avoiding walls the difference usually does not matter; for careful measuring it can.

Lesson test

5 questions. Get 3 right (60%) to pass and complete this lesson.