Learning library

Robotics

Follow a robot from a sensor reading to a position estimate and a controlled movement. Start with the motion-and-communication route, then explore localization, mapping, and feedback. The full library also covers the geometry, planning, and dynamics behind those tasks.

148 lessons, in library order. Search within robotics.

Start here

Estimate and communicate a mobile robot's motion

Follow a robot from sensing to action, turn wheel measurements into a pose, then pass that estimate to another component.

  1. What is physical AI? Follow a robot from sensing to action

    Locate sensing, estimation, planning, and control in one robot's loop.

  2. Coordinate frames: read the same point from a robot and the world

    State which frame a measured position or motion uses.

  3. Configuration space: follow joint paths across angle boundaries

    Describe the robot's position and heading as a configuration.

  4. Differential-drive kinematics: from wheel rates to pose

    Convert two wheel speeds into forward motion and turning.

  5. Wheel odometry: turn encoder counts into a moving pose

    Accumulate encoder readings into a pose and expose calibration and slip errors.

  6. ROS 2 topics, services, and actions: choose the right exchange

    Choose an interface for the odometry stream, a reset request, and a navigation goal.

Planning a career change? The guide to becoming a robotics engineer connects these foundations to job requirements and portfolio projects.

Browse all 148 lessons below

Keep going with a focused path

Choose a question to follow. Each path connects a few lessons; you can return for the details when you need them.

Localize a mobile robotFollow wheel measurements into a pose, transform sensor points, then examine uncertainty, mapping, and drift.

Before you start: Basic coordinates and probability. Each lesson links the mathematics it uses.

  1. Coordinate frames: read the same point from a robot and the world

    State which frame a position or measurement belongs to.

  2. Wheel odometry: turn encoder counts into a moving pose

    Turn encoder readings into motion and see how errors accumulate.

  3. ROS 2 tf2: transform a laser point at the right time

    Connect a supplied odometry pose to a sensor-point transform at the measurement time.

  4. Kalman filter: predict position, then correct with measurements

    Combine prediction with a noisy measurement, then branch into a configured ROS odometry and IMU filter.

  5. SLAM in robotics: estimate a robot’s path and its map

    Connect joint estimation to a checked scan-to-map workflow, then explore navigation costs and path requests.

  6. Trajectory error metrics: compare full paths, frames, and drift

    Evaluate timestamped trajectory files and inspect how alignment can hide a clock error.

Connect software to controlled motionTrace message delivery, then connect feedback to a state-space controller.

Before you start: Basic algebra and rates of change; the state-space lessons also use matrix multiplication.

  1. Feedback control: measure speed and correct the error

    Separate the desired motion, measurement, and correction.

  2. ROS 2 topics, services, and actions: choose the right exchange

    Choose an interface for a sensor stream, a request, or an ongoing goal.

  3. ROS 2 QoS: fix a topic that delivers no messages

    Repair mismatched reliability settings, then branch into recording and replay with a checked clock source.

  4. State-space models: connect states, inputs, and outputs

    Describe state, input, and output, then branch into stability certificates or coupled control loops.

  5. Linear quadratic regulator: choosing feedback by cost

    Design feedback around a stated tradeoff between state error and control effort.

  6. LQG control: connect a Kalman estimate to LQR feedback

    Feed a Kalman estimate into an LQR controller and compare noisy feedback under matched disturbances.

  1. Foundations / 9 min read

    Vector spaces: build direction from addition and scaling

    Learn vector spaces through robot displacement. Explore span, linear independence, basis, and dimension with an interactive diagram, Python, and exercises.

  2. Foundations / 9 min read

    The dot product: angles, projections, and robot motion

    Learn the dot product with an interactive vector diagram, a worked projection example, and a robot heading calculation. Includes exercises and solutions.

  3. Foundations / 8 min read

    Conditional probability: reading a robot sensor

    Learn conditional probability with an interactive robot sensor example. Work through the formula, Bayes' rule, base rates, and common mistakes using counts.

  4. Foundations / 8 min read

    Gradient descent: learn the update, then test its limits

    Work through gradient descent by hand, then explore learning rates, overshoot, and stationary points in an interactive experiment with Python and exercises.

  5. Foundations / 9 min read

    Linear regression: fit a line and inspect its errors

    Fit linear regression to robot sensor readings. Work through least squares, residuals, and MSE, then test an outlier with Python and exercises.

  6. Foundations / 9 min read

    Bayesian inference: learning a robot's grasp success rate

    Learn Bayesian inference through a robot grasp example. Update a Beta prior with successes and failures, then distinguish uncertainty from prediction.

  7. Foundations / 9 min read

    Eigenvalues and eigenvectors: find the lines a matrix preserves

    Understand eigenvalues through 2D transformations. Test stretching, reversal, zero eigenvalues, rotation, and repeated values, then connect them to robot error dynamics.

  8. Foundations / 10 min read

    Tensors: read shapes, select values, and move axes

    Learn tensors through a robot image batch. Explore shape, indexing, slicing, and axis order, then compare reshape with transpose using a runnable Python example.

  9. Foundations / 10 min read

    Logistic regression: turn a score into a probability

    Explore logistic regression with synthetic robot observations. Calculate sigmoid probabilities and log loss, then change a threshold and inspect the confusion matrix.

  10. Foundations / 9 min read

    Markov chains: transitions and stationary distributions

    Learn Markov chains with a robot example. Explore transition matrices, stationary distributions, periodic chains, and absorbing states with an interactive model.

  11. Foundations / 9 min read

    Laplace distribution: model sensor error and tolerance

    Learn the Laplace distribution through sensor error. Explore location, scale, density, interval probabilities, and the link between absolute error and median fitting.

  12. Foundations / 11 min read

    Random forests: train different trees and combine their votes

    Build a small random forest from synthetic robot observations. Inspect learned splits, bootstrap samples, random feature choices, and individual tree votes.

  13. Foundations / 9 min read

    A map of machine learning: tasks, signals, and models

    Understand how supervised learning, self-supervision, reinforcement learning, NLP, and deep learning fit together through practical robot and language examples.

  14. Foundations / 10 min read

    NLP: turn robot commands into token probabilities

    Learn natural language processing through a small robot-command corpus. Compare tokenization, unigram and bigram counts, unseen contexts, embeddings, and evaluation.

  15. Foundations / 10 min read

    pandas: select, align, and check a table of robot readings

    Learn pandas Series and DataFrames through robot readings. Compare loc and iloc, inspect label alignment, handle missing values, and check grouped summaries and joins.

  16. Foundations / 9 min read

    Vector norms and normalization: L1, L2, and L∞

    Measure vectors with L1, L2, and infinity norms. Explore unit boundaries, normalize a robot displacement, and distinguish zero vectors from tiny nonzero inputs.

  17. Foundations / 10 min read

    Matrix multiplication: calculate entries and compose transformations

    Learn matrix multiplication through row-column dot products, compatible shapes, and a rotation-and-stretch experiment that shows why transformation order matters.

  18. Foundations / 11 min read

    Cross product: find a normal direction and calculate torque

    Calculate a three-dimensional cross product, follow the right-hand rule, and connect its magnitude to area. Explore signed torque with a movable lever arm and force.

  19. Foundations / 10 min read

    Matrix transpose and inverse: when do they agree?

    Transpose rectangular matrices, calculate a 2×2 inverse, and test when a transpose reverses a transformation. Explore rotations, reflections, and singular maps.

  20. Foundations / 11 min read

    Determinants: signed area, volume, and collapsed directions

    Calculate a determinant, see how its sign records orientation, and connect zero area to singular matrices. Learn why a small determinant alone does not imply poor conditioning.

  21. Foundations / 12 min read

    Rank and null space: reachable outputs and hidden input changes

    Use rank, column space, and null space to understand a linear map. Explore rank-nullity, unreachable targets, and families of solutions with a small matrix experiment.

  22. Foundations / 10 min read

    Projections and least squares: find the closest fit

    Project a vector onto a direction, measure its orthogonal residual, and connect that geometry to least squares, regression, and nonunique coefficients.

  23. Foundations / 12 min read

    Singular value decomposition: directions, gains, and low-rank approximation

    Build an SVD from orthogonal directions and nonnegative gains. See a circle become an ellipse, identify lost directions, and measure the error from keeping one singular component.

  24. Foundations / 11 min read

    Pseudoinverse: choose the smallest least-squares solution

    Understand the Moore–Penrose pseudoinverse through exact and inconsistent systems. Separate residual error from solution norm, inspect projectors, and see how an SVD cutoff changes the problem.

  25. Foundations / 10 min read

    Coordinate frames: read the same point from a robot and the world

    Convert a fixed landmark between robot and world coordinates. Learn frame conventions, translation and rotation, inverse transforms, and point versus displacement.

  26. Foundations / 12 min read

    Rotation matrices: turn vectors, track frames, and check the order

    Build rotation matrices that preserve length and handedness. Compare fixed-axis rotations in 3D, distinguish rotating a vector from changing its coordinates, and undo a rotation with its transpose.

  27. Foundations / 12 min read

    Homogeneous transformations: map sensor coordinates into the world

    Combine rotation and translation in one matrix. Follow a sensor-to-robot-to-world frame chain, distinguish points from displacements, and calculate the inverse.

  28. Foundations / 10 min read

    Euler angles and gimbal lock: when different angles mean the same orientation

    Explore roll, pitch, and yaw with full rotation matrices. Compare equivalent orientations at ±90° pitch and separate Euler angle rates from angular velocity.

  29. Foundations / 12 min read

    Axis-angle rotation: build Rodrigues’ formula from three vector terms

    Rotate a vector around any nonzero axis. Normalize the direction, follow Rodrigues’ parallel and perpendicular terms, and understand the equivalent descriptions at zero and 180 degrees.

  30. Foundations / 12 min read

    Unit quaternions: compose rotations and understand the sign

    Rotate vectors with Hamilton quaternions, check composition order, and see why q and minus q describe the same orientation. Includes an interactive experiment and Python.

  31. Foundations / 10 min read

    Derivatives and the chain rule: predict a small change

    Understand derivatives as local rates, compare secant and tangent slopes, and multiply the correct factors through nested functions. Test a smooth curve and a corner with an interactive experiment.

  32. Foundations / 13 min read

    Partial derivatives and gradients: predict a multivariable change

    Hold one input fixed to find a partial derivative, combine the partials into a gradient, and compare a directional derivative with the actual change from a finite step.

  33. Foundations / 13 min read

    Jacobian matrices: from joint rates to robot tip velocity

    Read a Jacobian by its rows and columns, calculate a two-link arm's tip velocity, and compare a local prediction with a finite move. Includes singularities and the multivariate chain rule.

  34. Foundations / 11 min read

    Hessians: measure curvature in every direction

    Differentiate a gradient to build the Hessian, calculate directional curvature, and classify stationary points. Explore coupled quadratics, saddles, and the limits of zero eigenvalues.

  35. Foundations / 13 min read

    Taylor expansion and linearization: predict locally and check the error

    Build constant, linear, and quadratic approximations around a chosen center. Compare their errors, calculate a Taylor remainder bound, and connect the same idea to gradients, Hessians, and Jacobians.

  36. Foundations / 12 min read

    Ordinary differential equations: turn a rate law into a time course

    Solve a cooling initial-value problem, compare its exact solution with Euler steps, and separate model behavior from numerical accuracy and stability.

  37. Foundations / 12 min read

    Numerical integration: compare drift, phase, and step cost

    Advance an oscillator with forward Euler, velocity-first symplectic Euler, and classical RK4. Compare each method with the analytic solution and separate energy drift, phase error, step cost, and stability.

  38. Foundations / 13 min read

    ODE stability: equilibria, attraction, and basins

    Classify equilibria of a nonlinear rate law, use a phase line to find basins of attraction, and compare exact trajectories without confusing model stability with numerical stability.

  39. Foundations / 12 min read

    Manifolds and tangent spaces: move along a constraint

    Use the unit circle to understand local coordinates and tangent vectors. Compare straight steps, exact rotation, and normalization, then examine why averaging headings and rotations needs care.

  40. Foundations / 13 min read

    Geodesics: shortest arcs and longer routes on a circle

    Compare a shortest circle arc, a longer constant-speed geodesic, and a straight chord. Work through angle wrapping, antipodal ties, coincident endpoints, and the metric that defines distance.

  41. Foundations / 12 min read

    Lie groups and Lie algebras: connect robot poses to local motions

    Use planar robot poses to understand SE(2), its tangent space se(2), and the Lie bracket. Compare motion order, shrink a commutator loop, and reproduce the calculations in Python.

  42. Foundations / 13 min read

    Exponential and logarithm maps: turn a body twist into a pose

    Exponentiate a constant planar body twist, calculate its coupled translation, and recover a chosen logarithm. Explore straight-motion limits, half-turn branch choices, and information lost in a full turn.

  43. Foundations / 13 min read

    Twists and screw axes: connect point velocities to rigid motion

    Build a six-component twist from a screw axis, calculate point velocities, and compare exact helical motion with a tangent prediction. Separate pitch, accumulated displacement, current rate, and pure translation.

  44. Foundations / 12 min read

    Adjoint transformations: express a twist in another frame

    Transform angular-first twists between body and space frames. Derive the origin-shift term, distinguish linear twist coordinates from point velocity, and check a planar example with an interactive adjoint matrix.

  45. Foundations / 14 min read

    Product of exponentials: build a robot arm’s forward kinematics

    Build a two-joint arm's tool pose from fixed home screw axes and matrix exponentials. Check the result against geometry, inspect multiplication order, and connect space and body formulas.

  46. Foundations / 14 min read

    Wrenches: combine force, moment, and power across frames

    Calculate a force's moment about a chosen origin, include a free couple, and transform a moment-first wrench between frames. Use a worked planar load to check the inverse-transpose rule and power invariance.

  47. Foundations / 14 min read

    Space and body Jacobians: map joint rates to rigid motion

    Build space and body Jacobians from joint screw axes, recover the physical tool velocity, and compare their ranks with a position-only task. Explore a planar two-link arm and verify its derivatives in Python.

  48. Foundations / 14 min read

    Robot statics: turn tool loads into holding torques

    Use virtual work and a Jacobian transpose to calculate a robot arm's joint loads. Distinguish external and holding torque, check space and body frames, and interpret zero-torque loads.

  49. Foundations / 13 min read

    Kinematic singularities: find the tip velocities an arm can produce

    Use a two-link robot arm to distinguish exact rank loss from near-singular conditioning. Calculate the minimum-norm joint rates for a requested tip velocity and identify the component the arm cannot produce.

  50. Foundations / 11 min read

    Manipulability: read a robot’s velocity ellipse

    Map a joint-rate budget into a robot’s possible tool velocities. Read the ellipse’s singular values, compare area with conditioning, and understand singular poses, units, and the limits of force duality.

  51. Foundations / 14 min read

    Numerical inverse kinematics: solve a tool position with local steps

    Use a position Jacobian and damped least squares to refine a two-joint arm toward a target. Inspect accepted steps, compare starting guesses, and distinguish convergence, a stalled solve, and unreachable geometry.

  52. Foundations / 14 min read

    Differential inverse kinematics: turn a tip-velocity command into a joint step

    Calculate damped joint rates for a robot tip-velocity command, measure the resulting speed and direction error, and compare an instantaneous prediction with one finite joint step.

  53. Foundations / 12 min read

    Kinematic redundancy: use the motion a task leaves free

    Split a three-link arm’s joint rates into a primary solution and null-space motion. Check the exact projector, compare damping leakage, and measure why a finite step can move a tool with zero initial velocity.

  54. Foundations / 12 min read

    Joint limits in inverse kinematics: solve a bounded velocity step

    Turn physical joint ranges and speed limits into bounds on a local inverse-kinematics command. Compare a constrained least-squares solution with clipping, and check the resulting finite arm position.

  55. Foundations / 13 min read

    Analytical inverse kinematics: find both arm configurations for a target

    Derive both joint-angle solutions for a two-link robot arm, check them with forward kinematics, and identify unreachable targets and merged boundary branches.

  56. Foundations / 11 min read

    Robot workspaces: derive the reachable position set

    Derive the exact position workspace of a two-link robot with elbow limits. Test targets against its annulus, recover a valid arm configuration, and separate position reach from orientation and path feasibility.

  57. Foundations / 13 min read

    Trajectory time scaling: choose when a robot follows its path

    Separate a robot’s geometric path from its timing. Compare cubic and quintic profiles, derive joint speed and acceleration through the chain rule, and choose a duration that meets explicit limits.

  58. Foundations / 13 min read

    Configuration space: follow joint paths across angle boundaries

    Represent a robot arm as a point in joint space, follow paths across periodic angle boundaries, and distinguish angular distance from workspace motion and collision clearance.

  59. Foundations / 11 min read

    Collision checking: test the motion between endpoints

    Check a translating disk against a circular obstacle, including every point between its endpoints. Derive the closest-point test, expose missed samples, and distinguish broad-phase box overlap from a collision.

  60. Foundations / 12 min read

    Trapezoidal velocity profiles: accelerate, cruise, and stop

    Build a rest-to-rest motion for one linear joint. Derive triangular and trapezoidal velocity profiles, calculate braking distance, and inspect exact position, velocity and acceleration within explicit limits.

  61. Foundations / 11 min read

    Dijkstra’s algorithm: find the lowest-cost route

    Trace Dijkstra’s algorithm through a weighted grid, update route estimates, and see why the goal must leave the priority queue before its cost is final. Reproduce a complete search in Python.

  62. Foundations / 12 min read

    A* search: guide the search with a lower bound

    Use A* to find a low-cost route across a weighted grid. Calculate g, h, and f, compare Manhattan distance with Dijkstra, and see how an overestimate can return a worse path.

  63. Foundations / 12 min read

    Rapidly exploring random trees: grow a collision-free path

    Build an RRT for a disk robot, check every new branch for collision, and connect the tree to a goal. Explore seeded sampling, step length, narrow passages, and the limits of a finite search budget.

  64. Foundations / 13 min read

    Probabilistic roadmaps: reuse a graph for new routes

    Build a probabilistic roadmap from collision-free samples, attach new start and goal queries, and search the same graph for routes. Explore neighbor counts, missed connections, and what a finite roadmap can prove.

  65. Foundations / 12 min read

    RRT*: improve a path by rewiring the tree

    Follow RRT* as it chooses cheaper parents, rewires nearby nodes, and updates every descendant's cost. Compare the first path with later improvements and understand what asymptotic optimality does and does not promise.

  66. Foundations / 12 min read

    Path smoothing: shorten a route with checked shortcuts

    Shorten a robot path by removing unnecessary waypoints while checking every replacement segment for collision. Compare length and clearance, trace accepted and rejected shortcuts, and separate a simpler path from smooth robot motion.

  67. Foundations / 14 min read

    Differential-drive kinematics: from wheel rates to pose

    Convert left and right wheel rates into robot speed, turning rate, and an exact constant-rate pose update. Explore straight travel, arcs, spins, and reverse motion, then check the limits of wheel odometry.

  68. Foundations / 12 min read

    Nonholonomic constraints: move sideways without sliding

    Derive a wheeled robot’s no-sideways-slip constraint and trace a feasible maneuver that changes its lateral position. Separate instantaneous velocity limits from reachable poses, and see why the motion rules depend on the robot.

  69. Foundations / 13 min read

    Dubins paths: shortest routes with a turning limit

    Connect two robot poses with forward motion and a minimum turning radius. Compare all six Dubins path families, calculate arc lengths, and see why matching position alone misses the heading constraint.

  70. Foundations / 14 min read

    Ackermann steering: calculate wheel angles and turning radius

    Derive the inner and outer front-wheel angles for ideal Ackermann steering. Connect bicycle steering, wheelbase, and track width to turning radius, reverse motion, and the rear axle's path.

  71. Foundations / 13 min read

    Wheel odometry: turn encoder counts into a moving pose

    Convert wheel encoder increments into a differential-drive robot's position and heading. Replay measured counts, calculate exact arc updates, and see how calibration errors and wheel slip change the estimate.

  72. Foundations / 12 min read

    Reeds–Shepp paths: shortest car routes with reverse gear

    Add reverse travel to a car with a minimum turning radius. Read signed motion primitives, calculate a three-arc turnaround, and compare complete Reeds–Shepp solutions with forward-only Dubins paths.

  73. Foundations / 12 min read

    Omnidirectional drives: move sideways with three omniwheels

    Derive the wheel speeds for a three-wheel Kiwi drive. Command forward, sideways, and turning motion, preserve direction when motors saturate, and integrate the resulting world path.

  74. Foundations / 14 min read

    Instantaneous center of rotation: find the center from a planar velocity

    Calculate a planar rigid body's instantaneous center of rotation from its linear and angular velocity. Check point velocities, move the reporting reference, and distinguish turning, translation, and rest.

  75. Foundations / 12 min read

    Skid steering: why turning requires wheel slip

    Derive why four fixed wheels must scrub sideways during a turn. Compare a chosen effective-track model with differential-drive odometry, calculate contact slip speeds, and distinguish equivalent side rotation centers from the body's turning center.

  76. Foundations / 13 min read

    Robot dynamics: separate the torques that move an arm

    Explore robot dynamics through a two-link arm's torque budget. Separate inertia, velocity coupling, gravity, and friction, then check holding torque, link mass, and mechanical power.

  77. Foundations / 16 min read

    Inverse dynamics: calculate the torque a robot’s motion needs

    Calculate joint torque from a robot arm’s pose, velocity, and requested acceleration. Account for gravity, coupling, friction, and a known tip force, then see how actuator limits change the resulting acceleration.

  78. Foundations / 14 min read

    Forward dynamics: predict an arm’s motion from joint torques

    Solve a robot arm’s joint accelerations from torque, configuration, and velocity. Replay gravity release and compensation with RK4, then check energy balance and step-size error.

  79. Foundations / 14 min read

    Dynamic parameter identification: learn a joint model from motion

    Fit dynamic parameters from a rotating joint's motion and torque data. Recover inertia, gravity mass moment, and damping, then test excitation, noise, and held-out predictions.

  80. Foundations / 12 min read

    Friction models: torque during motion and at rest

    Compare Coulomb, viscous, and Stribeck friction in a robot joint. Calculate resisting torque and power loss during motion, check static holding at zero speed, and see where friction compensation needs a better model.

  81. Foundations / 15 min read

    Actuator dynamics: from motor voltage to joint torque

    Explore actuator dynamics with a DC motor’s current rise, back EMF, and geared load. Compare finite inductance with a reduced model, calculate reflected rotor inertia, and check torque, steady speed, and energy balance.

  82. Foundations / 14 min read

    Joint flexibility: model the twist between motor and load

    Explore joint flexibility with two rotary inertias joined by a spring and damper. Calculate transmitted torque, loaded deflection, elastic oscillation, and energy loss, then compare motor and load motion.

  83. Foundations / 13 min read

    Model uncertainty: bound a robot joint’s acceleration

    Turn uncertain inertia, damping, and disturbance torque into an acceleration range. Compare a nominal command with an actual model, handle negative acceleration correctly, and understand the assumptions behind a worst-case bound.

  84. Foundations / 14 min read

    Feedback control: measure speed and correct the error

    Explore feedback control with a robot joint speed model. Compare proportional correction with feedforward alone, calculate steady error, and test disturbances, sensor bias, and torque limits.

  85. Foundations / 14 min read

    Open-loop and closed-loop control: compare plans with position feedback

    Explore open-loop and closed-loop control by moving an axis along a planned path. Calculate how gain errors, drift, initial position, and sensor bias change tracking, then connect or disconnect the feedback path.

  86. Foundations / 14 min read

    Transfer functions: predict joint speed from torque

    Derive a robot joint transfer function with the Laplace transform. Separate zero-state and natural responses, calculate a pole and time constant, and compare torque steps with pulses.

  87. Foundations / 15 min read

    Block diagrams: trace signals and derive the feedback loop

    Read control block diagrams by naming signals and checking each junction. Combine series and parallel paths, derive feedback transfer functions, and compare reference, disturbance, and sensor-error responses.

  88. Foundations / 13 min read

    Poles and zeros: connect root locations to a step response

    Explore poles and zeros by changing one numerator zero in a stable second-order system. Calculate inverse response, compare real and complex poles, and distinguish canceled factors from hidden internal modes.

  89. Foundations / 12 min read

    Stability criteria: find the feedback gain limit

    Connect the Routh-Hurwitz criterion, Nyquist stability test, and gain and phase margins. Find when a three-lag feedback system settles, sustains oscillation, or becomes unstable.

  90. Foundations / 12 min read

    Step response characteristics: measure rise, overshoot, and settling

    Read step response characteristics from an exact second-order model. Compare rise time, overshoot, settling time, and steady error without mistaking the end of a plot for the final value.

  91. Foundations / 13 min read

    PID control: build a command from error and measured motion

    Build a PID controller from proportional, integral, and derivative terms. Compare tracking and load rejection, calculate each command contribution, and check the stability limit of integral gain.

  92. Foundations / 13 min read

    PID tuning: calculate gains, then test the response

    Tune a PID controller against explicit response and effort targets. Convert Ziegler–Nichols settings into parallel gains, understand relay auto-tuning, and compare manual adjustments.

  93. Foundations / 11 min read

    Integral windup: what happens when the actuator runs out of effort

    Explore integral windup in a sampled PI controller. Compare requested effort, actuator limits, and integral memory as an impossible reference returns to a feasible value.

  94. Foundations / 11 min read

    Derivative kick and filtering: choose what D responds to

    Explain derivative kick and filtering with a target step and measured noise. Compare derivative on error with derivative on measurement, calculate filtered command peaks, and weigh noise gain against lag.

  95. Foundations / 12 min read

    Feedforward control: predict torque, then correct error

    Calculate model-based torque from a smooth speed reference, then add feedback correction. Compare feedforward, proportional feedback, and their combination under inertia error, drag error, and unknown external torque.

  96. Foundations / 12 min read

    Cascade control: let position request velocity and velocity request torque

    Build cascade control from nested position and velocity loops. Follow command units, compare finite inner dynamics with ideal velocity tracking, and calculate the effect of an opposing load.

  97. Foundations / 12 min read

    Bode plots and loop shaping: place gain and phase together

    Read Bode plots and shape a position-control loop with a lead controller. Calculate crossover and phase margin, compare closed-loop tracking, and check what the model leaves out.

  98. Foundations / 12 min read

    Control bandwidth: tracking speed and physical limits

    Calculate closed-loop bandwidth relative to DC gain, then compare sinusoidal tracking with the torque it requires. Separate bandwidth from loop crossover and account for resonance, delay, sampling, and noise.

  99. Foundations / 11 min read

    Controller discretization: sample, compute, and hold

    Explore controller discretization with exact held-input dynamics. Compare immediate and delayed commands, calculate discrete poles, and connect sample timing to control stability.

  100. Foundations / 13 min read

    ICP algorithm explained: align two scans step by step

    Learn how ICP aligns two point sets. Step through the lab, download the same data and Python solver, and compare a correct fit with misleading residuals.

  101. Foundations / 8 min read

    Moravec’s paradox: the hidden work of picking up a cup

    Follow one cup from perception to grasping and recovery. Learn what Moravec’s paradox means, check a grasp’s clearance, and assess a robot demonstration.

  102. Foundations / 16 min read

    Behavior cloning: learn robot actions from demonstrations

    Learn behavior cloning with an interactive robot example and downloadable Python exercise. Split episodes, fit a policy, and compare action error with rollouts.

  103. Foundations / 13 min read

    SLAM in robotics: estimate a robot’s path and its map

    Understand SLAM in robotics by solving a small landmark problem. Compare localization, mapping, and joint estimation, then see how anchoring and measurement weights change the answer.

  104. Foundations / 10 min read

    Loop closure in SLAM: why revisiting a place changes the map

    Follow a supplied loop measurement through a small SLAM graph. See how its weight changes the whole route, and why a false revisit can lower cost while increasing error.

  105. Foundations / 12 min read

    Sim-to-real transfer: train for a model that changes

    Explore sim-to-real transfer by fitting a policy across actuator models. Test unseen gains, compare goal error and effort, and distinguish simulation checks from hardware evidence.

  106. Foundations / 9 min read

    What is physical AI? Follow a robot from sensing to action

    Follow a mobile robot from sensing to action. Compare physical AI and embodied AI, locate learned and classical methods, and calculate how measurement bias changes a stop.

  107. Foundations / 10 min read

    Covariance and uncertainty ellipses: read the shape of error

    Read a covariance matrix as a geometric description of spread. Rotate an uncertainty ellipse, compare a Gaussian model with a finite sample, and calculate what a 95% contour means.

  108. Foundations / 12 min read

    Kalman filter: predict position, then correct with measurements

    Work through a scalar Kalman update, then estimate position and velocity from noisy readings. Explore missing measurements, covariance, and a biased sensor that defeats the filter’s assumptions.

  109. Foundations / 11 min read

    Vision-language-action models: from observations to robot commands

    Learn how vision-language-action models connect images and instructions to robot actions. Compare token and continuous outputs, then inspect how units, frames, and timing change a synthetic command.

  110. Foundations / 11 min read

    Diffusion Policy: generate robot actions by denoising

    See how Diffusion Policy represents several possible actions, learns to remove noise, and executes action chunks. Follow an exact teaching denoiser and separate sampling steps from robot time.

  111. Foundations / 10 min read

    ROS 2 topics, services, and actions: choose the right exchange

    Choose topics for streams, services for short requests, and actions for goals with progress and results. Follow odometry, a reset, and a navigation cancellation.

  112. Foundations / 12 min read

    Visual odometry vs SLAM: motion, maps, and metric scale

    Compare visual odometry with SLAM, understand what local maps and loop closures add, and use a pinhole-camera inspector to see why monocular images cannot establish metric scale alone.

  113. Foundations / 18 min read

    Trajectory error metrics: compare full paths, frames, and drift

    Compare ATE, RPE, alignment, and timing with an interactive trajectory lab and downloadable Python evaluator. Inspect timestamp matches, missing coverage, and a misleading zero-error fit.

  114. Foundations / 10 min read

    Robot autonomy and teleoperation: who makes each decision?

    Compare direct teleoperation, supervisory control, shared autonomy, and bounded task autonomy. Follow one grasping task, calculate communication delay, and read intervention records.

  115. Foundations / 12 min read

    A 2D lidar scan model: ranges, rays, and visible surfaces

    Turn lidar angles and ranges into points, find the nearest visible surface with ray casting, and distinguish a missing return from an invalid reading. Inspect occlusion and coordinate frames in an interactive room.

  116. Foundations / 11 min read

    Occupancy grid mapping: update free, occupied, and unknown space

    Build a small occupancy grid from supplied range readings. Follow free-space and hit updates, calculate log odds, and distinguish unseen cells from conflicting evidence.

  117. Foundations / 13 min read

    Particle filter localization: predict, weight, and resample

    Estimate a robot's position with weighted particles. Follow motion prediction, sensor likelihoods, effective sample size, and systematic resampling, then test an initial belief that misses the robot entirely.

  118. Foundations / 13 min read

    Extended Kalman filter: localize a robot with range and bearing

    Predict a robot's nonlinear motion, linearize with Jacobians, and correct its pose from a known landmark. Inspect angle wrapping, covariance, and a poor initial heading that challenges the local approximation.

  119. Foundations / 13 min read

    Pose-graph optimization: fit robot positions and headings together

    Optimize a small planar pose graph with real nonlinear updates. Calculate relative-pose residuals, anchor the world frame, and compare measurement fit with error against a synthetic reference.

  120. Foundations / 12 min read

    ICP failure cases: when a smaller residual gives the wrong pose

    Diagnose ICP failure cases with repeated geometry, partial overlap, and unmatched points. Compare the fitting residual with a known pose error, change the starting estimate, and see which evidence each metric uses.

  121. Foundations / 13 min read

    Behavior cloning covariate shift: when actions change the inputs

    Follow behavior cloning covariate shift through a frozen policy and a two-state motion model. Compare held-out expert actions with learner-state errors, inspect visited states, and test a policy class that can represent the expert.

  122. Foundations / 14 min read

    Robot data leakage: split demonstrations by episode

    Compare framewise and episodewise evaluation, then inspect downloadable train, validation, and final-test manifests with training-only preprocessing.

  123. Foundations / 12 min read

    DAgger imitation learning: label the states your policy visits

    Run DAgger imitation learning one round at a time. Collect expert labels on learner rollouts, retrain on the growing dataset, and compare equal label budgets.

  124. Foundations / 17 min read

    Robot policy evaluation: success, failure, and episode counts

    Evaluate robot policies with declared task rules and matched trials. Inspect a downloadable learned policy, shifted dynamics, failures, timeouts, and uncertainty.

  125. Foundations / 12 min read

    Robot learning generalization: what is actually unseen?

    Map the conditions a robot policy saw during training. Compare familiar-value recombinations, unseen axis values, and extrapolation with two fitted policies and an explicit condition grid.

  126. Foundations / 13 min read

    Imitation learning: compare methods by data and expert access

    Compare imitation-learning methods by their data, learned quantities, and need for expert or environment access. Locate behavior cloning, DAgger, inverse RL, and GAIL.

  127. Foundations / 12 min read

    Domain randomization: break a training shortcut

    Train two policies with the same labels and example count, then randomize one nuisance feature. Inspect the learned coefficients and compare frozen familiar and shifted tests to see what domain randomization changes.

  128. Foundations / 12 min read

    Open-loop vs closed-loop simulation: what replay can test

    Run the same robot policy on recorded observations and in an interactive simulation. Compare proposed actions, executed motion, and the claims each test supports.

  129. Foundations / 12 min read

    Robot foundation models: what transfers across robots?

    Examine what robot foundation models transfer across tasks, scenes, and robot bodies. Compare dated RT-X, Octo, and OpenVLA papers, then calculate how evaluation weights change a ranking.

  130. Foundations / 12 min read

    Behavior cloning from observation: infer missing actions

    Learn an inverse model from the learner’s own actions, infer missing expert labels, and test a cloned policy. See how poor exploration and sensing errors change the result.

  131. Foundations / 13 min read

    World models for robotics: learn dynamics, then plan

    Fit a small action-conditioned world model, use it to choose a plan, and check what actually happens. See how perfect training predictions can hide a poor decision.

  132. Foundations / 14 min read

    Robotics simulation: choose the model for the question

    Choose robotics simulation models by the question they can answer. Separate kinematics, force dynamics, numerical error, sensing, and hardware validation with a worked cart example.

  133. Foundations / 13 min read

    State-space models: connect states, inputs, and outputs

    Build a cart state-space model from Newton’s law. Read A, B, C, and D, separate initial motion from force response, and choose position, velocity, or acceleration as the output.

  134. Foundations / 14 min read

    Controllability and observability: move and reveal state

    Find which states an actuator can reach and which a sensor can reveal. Use exact cart motion, two held commands, matrix rank, and indistinguishable initial states.

  135. Foundations / 11 min read

    Pole placement: calculate state-feedback gains

    Use pole placement to calculate position and velocity gains for a cart. Verify the closed-loop matrix, compare exact responses, and inspect the force each design requires.

  136. Foundations / 11 min read

    Luenberger observer: estimate velocity from position

    Build a Luenberger observer for a cart with a position sensor. Calculate observer gains, follow estimation error, and see why a small position residual can hide a velocity error.

  137. Foundations / 12 min read

    Linear quadratic regulator: choosing feedback by cost

    Calculate LQR feedback for a cart, connect Q and R to position, velocity, and force, and separate accumulated cost from exact future cost.

  138. Foundations / 12 min read

    Integral action in state space: remove a load offset

    Add an integral state to a cart controller, calculate three feedback gains, and compare constant-load tracking with reference feedforward. See why stable dynamics, accurate sensing, and sufficient force still matter.

  139. Foundations / 9 min read

    ROS 2 QoS: fix a topic that delivers no messages

    Reproduce a ROS 2 reliability mismatch, inspect the publisher and subscriber profiles, and restore delivery. Run the checked Jazzy example in one isolated container.

  140. Foundations / 12 min read

    LQG control: connect a Kalman estimate to LQR feedback

    Control a cart from noisy position readings. Connect Kalman filtering to LQR, compare matched disturbances, and test what changes when the model is wrong.

  141. Foundations / 11 min read

    ROS 2 tf2: transform a laser point at the right time

    Connect an odometry message to a transform tree, convert a timestamped laser point, and reproduce missing-frame and extrapolation errors in ROS 2 Jazzy.

  142. Foundations / 9 min read

    Lyapunov stability: prove convergence with a function

    Build a Lyapunov function, check its derivative, and prove convergence. See why a failed candidate can coexist with a stable system.

  143. Foundations / 10 min read

    Multivariable control: manage coupling between outputs

    Move one output without disturbing another. Compare independent feedback with matrix decoupling, then test model mismatch and large actuator commands.

  144. Foundations / 10 min read

    ROS 2 bag: record, replay, and check the clock

    Record six stamped points, inspect their saved contents, and replay them into a ROS 2 node. Reproduce a clock that stays at zero while messages still arrive.

  145. Foundations / 13 min read

    robot_localization in ROS 2: configure an odometry and IMU filter

    Run the ROS 2 EKF with supplied wheel odometry and IMU data. Select measurement fields, check frames and covariance, and see how a biased gyro changes the estimated path.

  146. Foundations / 14 min read

    SLAM Toolbox in ROS 2: build a map from laser scans

    Run SLAM Toolbox on supplied laser scans and odometry. Reproduce a missing-transform failure, repair the frame tree, and inspect the map produced by the real ROS node.

  147. Foundations / 11 min read

    Nav2 costmap inflation: turn obstacles into navigation costs

    Run a Nav2 costmap on a saved occupancy grid. Compare two inflation radii, inspect raw cell costs, and separate robot size from a preference for distance from obstacles.

  148. Foundations / 11 min read

    Nav2 path planning: request a route and diagnose no path

    Run the real Nav2 planner server on a saved map. Request a path between supplied poses, inspect the returned geometry, and diagnose a free goal that the planner cannot reach.