The course
The lessons, in order. Each hands you a small simulated robot and one idea to write in Python, and every piece you finish joins your own mybot library.
The whole course is in beta. Every lesson is new and has not been fully playtested yet.
Motion
0 of 5- 01Differential drive betaFeel how a two-wheeled robot steers by spinning each wheel at a different speed, then write a Python drive function that rolls straight, spins in place, and parks on a goal.
- 02aFollow the line betaWrite your first line follower in Python: read a sensor offset and nudge the wheels to bring a simulated robot back to the line, wobbling all the way, on purpose.
- 02bSmooth it out betaReplace fixed-nudge steering with proportional control and tune the Kp gain in your code until the robot stops wobbling and glides along the line.
- 03Damp it with D betaAdd derivative control to a hot proportional gain (a shock absorber on the correction) and build the PIDController class that later lessons import from your own library.
- 04Zero the drift betaHold a heading against a steady side wind with your own PID controller: P and D settle a few degrees short, and the integral term winds that leftover error out.
Sensing
0 of 2- 05Dead reckoning betaWrite the dead-reckoning integrator a robot uses to guess its own position from commanded wheel speeds, then watch a calibrated wheel slip the encoders never see peel that guess away from the truth.
- 06Sense and avoid betaSteer toward a goal using three distance rays, and break the dead-ahead tie so the robot commits to a side instead of plowing into the crate ahead.
Planning
0 of 2- 07Plan the route betaWrite the heuristic that turns Dijkstra's flood into A*: your one-line distance guess collapses the search from the whole grid to a beeline for the goal.
- 08Follow the route betaImplement pure pursuit in Python: steer along the arc to a lookahead point on the route, then tune the lookahead until the corners glide instead of ring.
Integration
0 of 2- 09One thing at a time betaPure reaction can't do "in order": give the robot a memory with a state machine that latches from waypoint A to B to done instead of orbiting forever.
- 10The gauntlet betaThe capstone: import the pure pursuit, sensing, and state-machine pieces you built into one controller and drive a crate-strewn route clean.
Trust Issues
0 of 3- 11Trust, but verify betaWrite the exponential moving average that smooths a noisy sensor, then tune the gain so it kills the jitter without lagging behind the real signal.
- 12Two liars, one truth betaWrite the classic complementary filter: fuse a drifting integrated heading with a noisy absolute reading, and tune the blend until it beats both.
- 13The kidnapped robot betaFix your dead reckoning with a beacon: fuse a noisy fix into your odometry and tune how much you trust it, the measurement update behind every localizer.
Perception
0 of 2- p1The camera under the line betaThe line offset you have trusted since lesson 02 was a camera all along. Read a strip of raw floor brightness and rebuild that number yourself, then drive the same course on it.
- p2Drive at what you can see betaRead a 2D patch of floor brightness, find the crate in it, and turn its position into a heading. Blob detection, then drive on the answer.
State Estimation
0 of 3- e1The drift that never stops betaWheel slip is back and position fixes are not enough: learn why one landmark can never expose a heading lie, and correct your heading against a second tower.
- e2The confident liar betaA sensor can be confidently wrong: add validation gating to your estimator so multipath phantom fixes bounce off while honest, noisy fixes keep correcting you.
- e3Navigate on your estimate betaThe capstone of state estimation: drive pure pursuit on your own corrected estimate with the true pose hidden, and bring the real robot home on a slipping drivetrain.