Build a mini robotBeginnerLesson 2647 min read

Meet your virtual robot

Every robot runs the same loop: sense, decide, act. Meet a small two-wheel robot that lives in your browser, and drive it to a goal.

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

Speed

Lesson in motion

In 60 seconds

Meet your virtual robot

Every robot runs the same loop: sense, decide, act. Meet a small two-wheel robot that lives in your browser, and drive it to a goal.

1/5

In simple words

Think of riding a bicycle in a busy market. Your eyes look ahead, your brain decides "slow down, go left", and your legs and hands do it. Then you look again. You do this many times every second. A robot does exactly the same: it senses, it decides, it acts, and then it starts again.

A robot is a machine that can notice the world around it and move or act by itself. A washing machine follows a fixed program. A robot vacuum cleaner is different: it feels a wall, decides to turn, and turns. That loop of sense, decide, act is the heart of every robot, from a toy car to a factory arm.

1
Sense
Read the sensors: Is there a line under me? How far is the wall?
2
Decide
Your code turns those readings into a choice: go straight, turn, stop.
3
Act
The motors spin the wheels at the speeds you chose.
4
Repeat
Do it again, many times per second. Small, frequent corrections beat big, rare ones.

Why start with a virtual robot?

Real parts cost money, can break and take time to wire. A simulator is a small program that pretends to be the robot and its room. You can crash it a hundred times for free, change one number and try again in a second. Real robotics teams do this too. But a simulator is always simpler than the real world, so later we test on real hardware as well.

Your robot

It lives in a square room, 200 cm by 200 cm, seen from above. x goes to the right, y goes up.
It has two wheels, 10 cm apart, and is round, 5 cm in radius. A third free-rolling wheel (a caster) keeps it balanced.
heading is the direction it faces, in radians: 0 means facing right, and it grows as the robot turns left (anticlockwise). A full turn is about 6.28 radians; a right angle is about 1.57.
Each step is one tenth of a second. At full speed a wheel moves 20 cm per second.

Steering with two wheels

This robot has no steering wheel. It turns by running its two wheels at different speeds. This is called differential drive, and many small robots and robot vacuum cleaners use it.

Left wheel	Right wheel	What the robot does
Forward, same speed	Forward, same speed	Drives straight
Slow	Fast	Curves to the left
Fast	Slow	Curves to the right
Backward	Forward	Spins on the spot, to the left
Stopped	Stopped	Stands still

Python: how wheel speeds become motionpython

# Wheel speeds go from -1 (full backward) to 1 (full forward).
VMAX, BASE, DT = 20.0, 10.0, 0.1     # top speed cm/s, wheel gap cm, seconds per step

for left, right in [(1, 1), (0.3, 0.8), (0.8, 0.3), (-0.5, 0.5), (0, 0)]:
    forward = (left + right) / 2 * VMAX           # cm per second, straight ahead
    turn = (right - left) * VMAX / BASE           # radians per second, + means left
    print(f"left={left:5}  right={right:5}  ->  forward {forward:5.1f} cm/s,"
          f" turn {turn:5.1f} rad/s ({turn * DT:.2f} rad per step)")

What you write: the decide function

In every lab of this track you write one function, decide(s). The simulator calls it once per step. s is a dictionary of sensor readings. Your function returns two numbers: the left and right wheel speeds. The simulator moves the robot and tells you if it crashed.

The shape of every decide functionpython

def decide(s):
    # s["x"], s["y"], s["heading"]: where the robot is (only the simulator knows this exactly)
    # s["left"], s["right"]: 1 if that line sensor sees black tape, else 0
    # s["offset"]: how far the tape is to the left (+) or right (-), in cm
    # s["distance"]: cm to the nearest thing straight ahead (max 100)
    # s["step"]: which step this is: 0, 1, 2 ...
    return 0.5, 0.5          # (left wheel, right wheel), each from -1 to 1

print(decide({"step": 0}))

Note

In this first lab the robot knows its exact position (x, y, heading). Real small robots usually do not: wheels slip and small errors add up. That is why the next lessons use sensors that look at the world instead.

Do this

A virtual robot cannot hurt anyone. A real one can pinch fingers in its wheels, fall off a table or knock things over. From lesson 6 on, we always test real robots on the floor, with the wheels lifted first.

Try this. Before you open the lab, predict: if the left wheel is at 0.2 and the right wheel at 0.6, will the robot curve left or right? Then run the code above with those numbers.

Watch and read more

Lab

A decide function that turns your virtual robot towards a goal, drives there and stops.

~20 min

The problem

This runs in your browser. The robot starts at (30, 30) facing right. The goal is at (160, 160).

Run the starter. The robot drives straight into the wall. Look at the picture.
Change decide so the robot turns towards the goal, drives there and stops within 10 cm of it, without touching a wall.
Two ways to do it: (a) use s["step"]: spin for a few steps with (-0.2, 0.2) (each step then turns 0.08 radians), then drive, then return (0, 0); or (b) each step, work out the angle to the goal with np.arctan2 and steer towards it.
Write one sentence: why would way (a) be harder 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()
# -------------------------------------------------------------------------------------------------

GOAL = (160, 160)                     # where we want to go, in cm

def decide(s):
    # s["x"], s["y"], s["heading"] tell you where the robot is. s["step"] counts steps.
    # Return (left_wheel, right_wheel), each from -1 to 1.
    return 0.5, 0.5                   # TODO: turn towards GOAL, drive there, then stop

path, crashed = simulate(decide, start=(30, 30, 0.0), steps=400)
gap = np.hypot(path[-1, 0] - GOAL[0], path[-1, 1] - GOAL[1])
print(f"crashed={crashed}, ended at {path[-1].round(1)}, {gap:.1f} cm from the goal")
show(path, obstacles=[(GOAL[0], GOAL[1], 3)])

Output

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

You are done when

The robot reaches the goal and stops, without hitting a wall
The code uses either step counting or the angle to the goal, and the learner can explain which
The picture shows a sensible path, not a lucky zig-zag
The sentence notes that on a real robot, wheels slip and timing varies, so counted steps drift

Hard questions

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

Q1Your step-counting solution works in the simulator. Why might the real robot miss the goal by a lot?Reveal

Counting steps assumes each step moves and turns the robot by exactly the same amount. Real wheels slip, motors are not identical, batteries get weaker and the floor is uneven. Small errors in the first turn grow as the robot drives further. Real robots correct themselves using sensors that look at the world: a line, a wall or a camera.

Q2When you steer by the angle to the goal, why must you "wrap" the angle difference into the range -π to π?Reveal

Angles repeat every full turn. If the goal is at +3.1 radians and the robot faces -3.1, the raw difference is 6.2, which would make it spin almost a full turn left, while the goal is really just 0.08 radians to the right. Wrapping, for example (err + np.pi) % (2 * np.pi) - np.pi, gives the short way round.

Please sign in to continue.

Questions people ask

Do I need to know Python already?

A little helps: variables, if and functions. The labs are short and you only change one small function. If you are new, try the lab anyway and read the error messages slowly; they usually say which line is wrong.

Why radians and not degrees?

Python's maths functions such as np.cos and np.arctan2 use radians. One full turn is 2π radians, about 6.28. To convert, multiply degrees by π/180, or use np.radians(90).

Is this how real robot software works?

The loop is the same. Real software adds many things: reading sensors at different speeds, safety checks, logging and handling errors. But "read sensors, decide, set motors, repeat" is the core of most small robots.

Can the simulator be wrong?

Yes. It is a simple model: no wheel slip, no bumps, perfect motors. Code that works here is a good start, not a guarantee. The lesson Simulation and sim-to-real explains this gap in more depth.

Lesson test

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

Meet your virtual robot

Meet your virtual robot

Sense

Decide

Act

Repeat

Why start with a virtual robot?

Your robot

Steering with two wheels

What you write: the decide function

Watch and read more

The problem

Practice lab

You are done when

Hard questions

Questions people ask