Robotics lessons & courses

By the end of this path you will be able to describe a robot's three-pillar anatomy, select appropriate sensors for a given task, choose and size the right motor type, write a basic closed-loop controller on a microcontroller, and explain why loop rate and latency matter in real systems.

By the end of this cursus you will be able to model a pinhole camera, calibrate it with OpenCV, recover stereo depth, downsample and register LiDAR point clouds with ICP, implement a Kalman filter predict-update cycle from scratch, and explain how ORB-SLAM3 and Cartographer solve the full SLAM problem including loop closure and pose-graph optimisation.

Build a complete kinematic toolbox for serial robot arms. You will attach coordinate frames to every link using homogeneous transforms, compute end-effector pose from joint angles with DH-parameter-based forward kinematics, invert that map analytically and numerically to find joint angles from a desired pose, and differentiate FK to get the Jacobian for velocity control and singularity analysis.

Build a complete understanding of robot control from first principles. By the end of this path you will be able to design and implement feedback loops, tune PID controllers for real actuators, model multi-joint systems in state space, apply pole placement and LQR, and generate smooth trajectories that a robot arm or mobile robot can track with minimal error.

Go from first principles to a working ROS navigation stack. You will model any robot as a point in configuration space, implement and compare Dijkstra, A*, PRM, RRT, and RRT*, and wire together a global planner, local planner, and AMCL localizer for a real mobile robot.

Open-loop control is a guess; closed-loop control is a conversation. Learn why feedback transforms an unreliable robot into a reliable one, how the read-compute-actuate cycle works, what microcontrollers and single-board computers each do best, and why loop timing is just as critical as the algorithm running inside it.

A robot is only as good as what it can measure. Explore the full sensor toolkit — encoders, IMUs, ultrasonic rangefinders, LiDAR, cameras, and force/torque sensors — and learn the four metrics that determine whether a sensor is fit for purpose: resolution, range, noise, and sampling rate.

Strip any robot to its bones and you find three things: sensors that gather data, a controller that thinks, and actuators that move. Learn how these pieces fit together through the Sense-Plan-Act paradigm, why reactive control sometimes beats planning, and what makes a Roomba and a welding arm both qualify as robots.

Every robot motion — spinning a wheel, bending a joint, squeezing a gripper — starts with an actuator. Learn the key differences between DC, stepper, and servo motors; how gears trade speed for torque; how PWM lets a microcontroller dial motor power; and where hydraulics and pneumatics step in when electricity isn't enough.

When grids fail in high dimensions, random sampling saves you. Understand why PRM builds reusable roadmaps, how RRT grows a tree toward the goal, what probabilistic completeness really means, and how RRT* achieves asymptotic optimality.

Discretise C-space into a grid, then search it intelligently. Understand Dijkstra's optimality guarantee, how A* accelerates it with admissible heuristics ($f=g+h$), why consistency matters, and where greedy search goes wrong.

Understand why every motion planner secretly works in configuration space: how robots become points, obstacles inflate, and why high-dimensional C-spaces make naive search intractable.

Trace the full perceive-plan-act loop on a mobile robot: AMCL localization feeds a global costmap, a global planner (A*/NavFn) sets the course, and DWA or TEB local planners execute it — with recovery behaviors when things go wrong.

The chicken-and-egg problem of robot autonomy: to localise you need a map; to build a map you need a pose. Covers front-end matching, back-end pose-graph optimisation, loop closure, and visual vs LiDAR SLAM systems.

How LiDAR fires pulses and measures time-of-flight to build a 3D point cloud; data structures, voxel downsampling, ICP registration, ground segmentation, and an honest comparison with cameras for robot perception.

Fuse noisy sensors over time with provably optimal estimates. Covers the state and noise model, predict and update equations with the Kalman gain, why it's optimal for linear-Gaussian systems, and the Extended KF for nonlinear robots.

From photons to 3D geometry: the pinhole model, intrinsic matrix K, lens distortion, feature matching, stereo depth, and where CNNs help (and fail) in robot perception pipelines.

Connect joint velocities to end-effector velocity through the Jacobian matrix. Learn how to build J, spot singularities where det J = 0, invert J with the pseudoinverse for velocity control, and measure manipulability — with NumPy code for the 2-link arm.

Flip the FK problem: given a desired end-effector pose, find the joint angles that achieve it. Master analytical closed-form IK for the 2-link arm, the elbow-up/elbow-down duality, atan2 arithmetic, and the basics of numerical IK via the Jacobian.

Translate a list of joint angles into an end-effector pose. Learn the four Denavit-Hartenberg parameters, build per-link transforms, multiply them into T_0^n, and implement FK for a 2-link planar arm in NumPy.

Master how roboticists describe rigid-body pose. Build rotation matrices from scratch, pack them into 4x4 homogeneous transforms, and compose multiple frames with NumPy to track every link in a robot arm.

Learn how to generate smooth robot trajectories — trapezoidal velocity profiles, cubic and quintic polynomials — and how to combine feedforward and feedback to track them with minimal error on real arms and mobile robots.

Move beyond single-input PID to the state-space framework: the state vector, matrix dynamics, controllability, pole placement via state feedback, and LQR — the tool that scales to full robot arms and drones.

Master the proportional-integral-derivative controller: what each term fixes, the PID equation, integral windup, a discrete Python implementation, and a Ziegler-Nichols tuning guide for real loops.

Understand why feedback beats open-loop, how the classic closed-loop architecture works, and what the key performance metrics — rise time, overshoot, settling time, steady-state error — actually mean for a real system.