Control & Estimation for a UAV or UGV, built from scratch.
Physical AI runs on control and estimation, the one layer most engineers only ever import. Then the estimator drifts the week of a demo, the issue thread goes unanswered, and there is nothing underneath to reason with. Over about 10 hours you build that layer yourself, alone, from scratch in Python: a drone that flies its own waypoint mission, an inverted pendulum that balances, and a Kalman filter that sees through noise. Yours to tune, debug, and defend. For the engineer building it alone. No ROS. No black boxes. No hardware to buy.
Autonomous machines are everywhere. Almost no one can build one from first principles.
Most engineers try to reach this by buying a kit, grinding a textbook, or cloning a repo. It rarely holds, and not because the material is hard: each piece is learned in isolation and never connected, so the first time the estimator drifts there is nothing to reason with. This course connects them.
Clones the repo, imports the library, runs the install script. When the sensor lies or the loop spirals, there is nothing to inspect but an issue thread nobody answers.
Knows a rotation is just a linear transformation, and edits the model directly. Commands the math, debugs it at 3am before a demo, and directs the AI that writes the boilerplate.
Fly a drone autonomously
Take off, hold altitude, fly a waypoint path, and return home on your own controller.
The core of delivery, inspection, and aerial mappingBalance the unstable
Hold an inverted pendulum upright, a system that falls the moment you stop controlling it.
The same control behind self-driving and legged robotsTrust a noisy sensor
Fuse accelerometer, magnetometer, and gyro into one attitude you can fly on.
How drones, AR/VR headsets, and phones know which way is upEstimate the unseen
Track a moving target through measurement noise, with no ground truth to lean on.
The math under navigation, radar, and every robot that localizesFive technologies build an autonomous machine. You learn exactly those five.
This is not a survey. The field decomposes into five core technologies, and the five levels of this course teach precisely those, in the order they depend on each other. The row below is the whole syllabus in miniature.
PID by feel, then the cascade of nested loops that makes a vehicle obey a waypoint.
→ taught in Levels 0 & 1Rotation matrices, SO(3), Euler conventions, and Rodrigues for gyro integration.
→ taught in Level 0DCM: turn a noisy accelerometer, magnetometer, and gyro into one estimate you can fly on.
→ taught in Level 2ẋ = Ax + Bu, pole placement, and LQR: one language for every linear system you meet.
→ taught in Level 3The Kalman filter and the EKF, written by hand, recovering the truth through noise.
→ taught in Level 49 reasons this is a foundation you own, not another tutorial you follow.
From dev setup and the math, through PID, rotations, fusion, and state-space, to the EKF. Nothing skipped.
Every level produces a running result and is the prerequisite for the next, so nothing ever appears out of nowhere.
Every concept runs the same loop: the math that governs it, the code that implements it, then a robot that either behaves or does not.
PID, DCM, LQR, and Kalman / EKF are written by hand in NumPy. No black-box libraries, and deliberately no ROS.
Every lab runs in the vrobots browser simulator, driven by your own Python. A laptop with a browser is the whole rig.
Trig, calculus, linear algebra, and statistics are rebuilt and tied to the robotics use that needs them, not proved in a vacuum.
Elliot Lee, founder of Ubicoders, who has shipped the flight-control, fusion, and estimation stacks you build here on real hardware.
The instructor is notified on every post and typically replies once or twice a day, and the certificate is verifiable.
Computer vision, 2D LiDAR SLAM, VIO, ROS 2, and PX4 are each a recombination of the PID, rotation, and EKF you now own.
Math → Code → connect with the Robots.
The same three-step loop on every concept, so you never watch without building, and every claim is settled by the robot rather than by the slide.
Understand the dynamics
No skipping the physics. Every concept opens with the equation that governs it, and the one assumption that will matter later.
Implement it, line by line
The equation becomes working code in a notebook, line by line, with nothing hidden behind an import.
Verify on the robot
Run it in the vrobots simulator, flip the sensor-noise toggle on, and see whether your math survives contact.
One connected climb: Level 0 → Level 4.
Each level ends with your own working code and is the prerequisite for the next, so nothing ever appears out of nowhere. About 10 hours of build-along video across five levels.
Setup & the math you actually need
Friction-free setup on any OS, then the intuition-first math each robotics topic actually needs, always tied to the use that needs it.
Foundations — the "combo keys"
The combo keys for the rest of your career: PID by feel, rotation you can build, and sensors you know better than to trust.
Autonomous drone control
Stack five nested loops into a controller that takes off, holds altitude, flies a waypoint square, and comes home.
Sensor fusion — DCM
Fuse accel, mag, and gyro into a stable estimate, then fly on that estimate with the noise switched on.
State-space methods
One language, ẋ = Ax + Bu, for free-fall, drone altitude, a car suspension, and a pendulum that balances.
The Kalman filter
The notorious interview topic, finally yours: a roughly 10-line filter that tracks through noise without ground truth, then the EKF.
The wrap-up then points forward: embedded systems, computer vision, 2D LiDAR SLAM, VIO, ROS 2, and PX4 / Pixhawk. Each one is a recombination of the PID, rotation, and EKF you now own, which is why they stop being intimidating.
Is this course for you?
✕ Not for you if…
✓ This IS for you if…
Prerequisites: comfort writing code in some language, and high-school math. Each topic's math is rebuilt inside the course as a fast, applied refresher, so rust is fine but a blank slate is not. Taught in Python, run in a browser simulator: no hardware to buy, and no ROS to install.
The system you can draw by the end.
By Level 4 you can explain an autonomous vehicle from the sensor to the trajectory, and draw it from memory. Here is the exact stack you build, block by block. Every box is your own code.
This is real: the cascade in mr_modules/controllers, imu/DCM.py, lv3_invpen_vr_ctrl.py, and lv4_a_kf_traj.ipynb. Files you write, not a diagram drawn for the brochure.
Eight modules, one connected path.
- 01Intro
- 02Backgrounds
- 03Course Guide (Download The Code Here)
- 04Which Code Environment?
- 05What is Conda? (Optional)
- 011) Python Basics 1
- 022) Trig. Functions
- 033) Calculus
- 044) Taylor Series & Fourier Series
- 055) Linear Algebra
- 011) Level Introduction
- 022) Virtual Robot Scripts
- 033) Realtime Graphing
- 044) Data Collection
- 055) Terminals in Virtual Robots
- 011) Introduction
- 022) Height (Altitude) Control 1
- 033) Height (Altitude) Control 2
- 044) Rate Control
- 055) Attitude Control
- 011) DCM Introduction
- 022) DCM Preview 1
- 033) DCM Preview 2
- 044) DCM Theory
- 055) DCM Code
- 011) State Space Introduction
- 022) State Space Control
- 033) State Space Multirotor 1
- 044) State Space Multirotor 2
- 055) Mass Spring Damper
- 011) Kalman Filter Introduction
- 022) Kalman Filter Code
- 033) Kalman Filter Theory
- 044) Extended Kalman Filter
- 011) Exit
- 022) Course Code Answer Pack
Module order matches the produced course. The full, current lesson list is on the course page itself.
What engineers say after finishing it.
Real reviews from the live course page, published as they were written.
There's a lot of information out there for Mechatronics & Robotics, but it's hard to find a comprehensive path. I searched Coursera & Alison and nothing comes close. When I got stuck on the WSL setup, Elliot responded on Discord quickly with personalized help and even updated the course instructions. That goes above and beyond.
Everything great in this course — all the math and real-time concepts are well explained. This makes for easy understanding and is unique compared to other courses out there.
Really good detailed explanation of different theoretical things and really good code explanation — not just the code, but the logic behind it. Planning on buying the new courses when they’re out :)
This course teaches a lot of hard math in simple words and in a small amount of time. You actually understand the material when you code your own robot — algorithms become fun. A perfect place to start.
Working examples of code while making the mathematics needed for robotic control practical and intuitive. The simulator was a helpful motivator and comprehension check.
The course provides everything you need to start your robotics career — even the holy grail that's often omitted: the basics of math, crucial to understand robotics. If you want to skyrocket your career but don't know where, don't wait.
Thank you for making this course so practically focused. It took me from an amateur to an intermediate level. Looking forward to the next one.
This course offers a no-fluff breakdown of the complex topics of robotics. A great way to get exposure to core robotics concepts.
Real slides, sims & the notebooks you build in.
Straight from the course. Every algorithm shown here is one you implement yourself and watch run.
Elliot Lee, autonomy engineer.
Founder of Ubicoders (AIR&H Aerospace Inc.) Elliot has been building drones that fly themselves since 2014: gesture-controlled multirotors in university research, deep-learning odometry in his graduate thesis, and Pixhawk autopilots for clients since. He learned control and estimation the hard way, piecing math, code, and physics together under real deadlines with nobody to ask. Robotics 101 is that path rebuilt as the MCP method, so you do not have to take the long way round.
“About 10 years ago, I thought I could dive right in by buying a robot kit… But I failed miserably. Then I turned to the textbooks, only to discover I couldn't apply them to real projects.”
“My first drone build flipped over, broke all its propellers, and almost hurt my face. That was the moment I realized I needed a proper education in control engineering — which became the MCP method.”
— verbatim, lessons ch01_01 & ch03_06
A real person answers.
Ask in the Robotics 101 Discord channel, or comment directly on the lesson. Every post notifies the instructor, and he typically replies once or twice a day. Reviewers call that help out by name, including one who had his WSL setup fixed and the course instructions updated because of it.
Proof of skill, not attendance.
A verifiable Certificate of Completion: evidence that you implemented the control and estimation core of an autonomous vehicle and validated it in simulation, not that you sat through the videos.
The questions engineers ask before enrolling.
The catch, answered plainly.
One payment. The whole stack. Yours for good.
The Physical AI wave runs on a control and estimation core, and that core is exactly what you leave with.
Own the layer everyone else imports.
The control and estimation core the whole field is built on, written by you. One-time payment, lifetime access, no hardware. Weigh it against the alternative: another month debugging an estimator you did not write, on a deadline that does not move.
Full lifetime access
- Lifetime access — learn entirely at your pace
- Every video lesson, from first principles to mastery
- All source code & course projects
Applicable sales tax / VAT is calculated at checkout based on your location.
Secure checkout via Paddle.com
Robotics 101 is the foundation the hard courses assume.
The course's own wrap-up points forward, and so does the ladder: computer vision, visual odometry, SLAM, ROS 2, and PX4 / Pixhawk. Each is a recombination of the PID, rotation, and EKF you now own.