MUJOCO · REAL PHYSICS

Full Autonomy in Python

Combine perception and control into one control(obs) that reliably drives the differential-drive rover to the goal pad within tolerance on real MuJoCo physics, fixing a partial starter controller.

01Challenge

A partial controller is pre-loaded: it runs, but it drives straight at full throttle and never reads the bearing. The pad is off to the side at (1.2, 1.2), so the rover sails past it and the run times out short of goal. That failure is the whole lesson: a real controller has to fold what it senses (goal_bearing, goal_dist) back into what it commands (left, right) every single tick. The question the miss forces: what is the one closed loop that turns toward the pad AND closes the distance, in one control(obs)?

02Model

The rover already runs your control(obs) fifty times a second on real physics, but right now it only knows one move: drive straight. The pad is off to the side, so straight is exactly wrong; it glides past and the clock runs out.

Every autonomous robot closes one loop: sense, then act, on the same beat. Here the senses are two numbers in obs: goal_bearing, how far off your nose is from the pad, and goal_dist, how far is left. Acting is one pair, (left, right). Steer by feeding bearing into the difference between the wheels: positive bearing means the pad is to your left, so spin the right wheel faster and you rotate toward it. Drive by feeding distance into the common forward push, easing off as you arrive so you settle on the pad instead of skating over it. Turn and drive aren't two behaviors fighting. They're one command, (fwd - turn, fwd + turn), recomputed every tick. That single line is the whole of autonomy.

Perception + control as one mode-switching policy.

03Guided practice

Step A (read the contract): obs gives you obs['goal_bearing'] (rad, + = pad is LEFT) and obs['goal_dist'] (m). control(obs) must return (left, right), each in [-1.0, 1.0]. Step B (steer): turn = clip(K * obs['goal_bearing'], -1, 1) with K around 1.5, proportional, so it turns hard when badly aimed and eases as it lines up. Step C (drive + settle): pick a forward push fwd (about 0.5), and slow it (about 0.2) once obs['goal_dist'] is small so you settle on the pad; optionally set fwd = 0 while |bearing| is large so you rotate before committing. Step D (combine): return (fwd - turn, fwd + turn), one line, every tick, and watch the rover curve onto the pad inside the time budget.

04Feedback

PASS WHEN control(obs) folds goal_bearing into a turn term and goal_dist into a forward term, returns (left, right) in range each tick, and the rover reaches the goal pad within 0.2 m inside the 12.0 s budget.

If your run fails, check:

FAIL: the rover drove past and timed out short of the pad. control(obs) ignores obs['goal_bearing']. Add a turn term (e.g. turn = 1.5 * obs['goal_bearing']) and return (fwd - turn, fwd + turn).
FAIL: the rover spins in place and never closes the distance. fwd is 0 (or turn saturates both wheels the same way). Keep a positive forward push so it translates while it steers.
FAIL: the rover steered AWAY from the pad. Your turn sign is flipped. Positive goal_bearing means the pad is to the LEFT, so the RIGHT wheel must go faster: (fwd - turn, fwd + turn).
FAIL: the rover reached the pad but skated over it without settling. Ease the forward push (e.g. fwd = 0.2 once obs['goal_dist'] is small) so it stops inside the tolerance ring.

05Retrieve & space

From 2.1: obs['goal_bearing'] and obs['goal_dist'] are the perception outputs you filtered. Name which is steering input and which is throttle input. (bearing -> steer, dist -> drive.)
From 2.2: the turn term turn = K * goal_bearing is which controller term, and what does raising K do? (Proportional / P; sharper turn, risks overshoot.)
Sign check: goal_bearing = +0.4 means the pad is to your ____, so the ____ wheel must spin faster. (LEFT; RIGHT.)

06Mastery & project

One control(obs) reaches the goal pad within 0.2 m inside 12.0 s on the seeded course and held-out goals, by combining a proportional turn on goal_bearing with a distance-eased forward push, returning a single in-range (left, right) per tick (L3: fuse perception and control into one closed loop on real physics).

IS the first half of the capstone: a complete autonomous rover whose control(obs) closes the perceive->act loop on real MuJoCo physics, and the direct input to 5.2, which profiles and optimizes this exact control loop toward the metal.

GO FURTHER · THE LIVE PLAYGROUND

Pilot the rover you automated ↗ — drive the same MuJoCo rover yourself
Race your controller in the Arena ↗ — code-to-compete on the board

← Async Tasks & the Real-Time Loop Optimize the Critical Loop to the Metal →

MUJOCO · REAL PHYSICS

Full Autonomy in Python

Fix the partial controller: fold goal_bearing and goal_dist into one control(obs) that steers and drives the rover onto the green pad on real MuJoCo physics.

You read

obs each tick: goal_dist, goal_bearing, range, heading, t

You change

the numbers and rules inside control(obs)

Fixed

the sense → decide → act loop, the rover, and the physics