Robotics,
by hand.

A useful working definition: a robot is a programmable machine that perceives, plans, and acts to accomplish tasks in the physical world. The word "programmable" is doing real work here — a washing machine is not a robot, because its behavior is fixed at manufacture. A robot arm is, because its behavior at runtime is a function of sensor data.

The canonical breakdown of a robotic system is the sense–plan–act loop. Sensors turn physical phenomena into numbers (encoder counts, pixel intensities, IMU rates). A planner or controller turns those numbers into desired actions (joint torques, wheel velocities). Actuators turn commands back into physical phenomena (motion, force). Close the loop fast enough and you have autonomy.

Robots are commonly grouped by morphology — manipulators (robot arms, fixed or mobile), mobile bases (wheeled, tracked, legged), aerial vehicles (quadrotors, fixed-wing), underwater vehicles, and humanoids, which combine several of these. Each morphology comes with its own kinematic and control conventions, but the underlying mathematics is shared.

A manipulator with six or more revolute joints in a general arrangement can — in principle — reach any position and orientation within its workspace. Six is the magic number because pose in 3-D space has six parameters: three for position (x, y, z) and three for orientation (roll, pitch, yaw). Fewer DOF means a restricted set of achievable poses; more means redundancy, which brings extra capability (obstacle avoidance, joint-limit avoidance) but also harder inverse kinematics.

The first question is forward kinematics (FK). It has a unique answer — chain the per-link transformations together and read off the tool frame. The second is inverse kinematics (IK). It generally doesn't have a unique answer — multiple joint configurations reach the same pose (elbow-up vs. elbow-down, for instance), and some poses are unreachable.

For a planar 2-link arm with link lengths L₁, L₂ and joint angles θ₁, θ₂, the forward map is:

And the inverse, using the law of cosines:

The ± in acos is the elbow-up / elbow-down ambiguity. In the widget below, drag the red target anywhere inside the workspace annulus; the arm solves IK in real time. Targets outside the reach set leave the arm stretching toward them but unable to close the loop — geometry does not yield to wishful thinking.

When the Jacobian — the matrix mapping joint velocities to end-effector velocities — becomes rank-deficient, the arm hits a singularity. In our 2-link case this happens when the arm is fully extended (θ₂ = 0) or fully folded (θ₂ = ±π). At these configurations, some directions of motion require infinite joint velocities. Real robots stay away from singularities using damped-least-squares IK or velocity filtering.

For serial arms with more than a couple of joints, analytic IK gets messy. The standard bookkeeping device is Denavit–Hartenberg (DH) parameters — a convention that assigns a local frame to each link and describes each link with just four numbers (aᵢ, αᵢ, dᵢ, θᵢ). The full forward kinematics is then a product of 4×4 homogeneous transformation matrices, one per link.

Each Tᵢ,ⱼ is a 4×4 matrix combining a 3×3 rotation and a 3×1 translation. The top-left 3×3 block is the orientation of frame j expressed in frame i; the top-right 3×1 column is the origin of frame j in frame i. Multiplying them composes rigid transformations cleanly.

The overwhelmingly most common control law in robotics is PID — proportional, integral, derivative. Despite its age (roots in 18th-century governor theory) and simplicity, PID remains the default for joint-level control because it is easy to tune, computationally trivial, and has excellent stability properties for well-behaved plants.

Three terms, three intuitions:

Proportional pushes harder when the error is larger. Too much and you oscillate; too little and you never converge. Integral accumulates past error to kill steady-state offsets (gravity, friction, DC disturbances) — but it introduces phase lag and risks integral windup when the actuator saturates. Derivative reacts to the rate of change of error, adding damping and reducing overshoot — but it amplifies measurement noise, so it's typically filtered.

Play with the gains below. The plant is a simple mass with viscous damping m ẍ + c ẋ = u. The controller tries to drive position to the step reference of 1.0. Watch what happens with only P, only P+D, and the full three-term law.

PID is stateless with respect to the plant — it doesn't know anything about your robot. For multi-joint robots, the dynamics are coupled (moving joint 2 changes the inertia seen by joint 1) and nonlinear. Beyond PID, the common steps up the ladder are:

Feedforward + PID. Compute a model-based torque estimate (gravity, inertia, Coriolis) and let the PID correct the residual. The controller carries the nominal behavior; the feedback cleans up modeling error and disturbances.

Computed-torque control. Solve the full rigid-body dynamics M(q) q̈ + C(q,q̇) q̇ + g(q) = τ for the commanded torque given a desired acceleration. Linearizes and decouples the system in joint space; requires an accurate dynamic model.

Impedance / admittance control. Instead of regulating position, regulate the relationship between force and motion. The robot behaves as a programmable spring-mass-damper — essential for contact tasks (assembly, polishing, collaborative robotics).

MPC (Model Predictive Control). At every sample, solve a constrained optimization over a finite horizon, apply the first control, repeat. Handles constraints and previews natively at the cost of computation. Standard for legged locomotion and trajectory tracking under limits.

Motion planning splits into two closely related subproblems. Path planning asks for a collision-free sequence of configurations from start to goal — it's a geometric question about configuration space (C-space). Trajectory generation adds timing — velocities, accelerations, jerk — producing something the controller can actually track.

Classical grid search on the workspace (A*, Dijkstra) works for mobile robots in 2-D or 3-D but doesn't scale to high-DOF manipulators where C-space has as many dimensions as joints. That's the realm of sampling-based planners — RRT, PRM, and their optimal variants (RRT*, PRM*), which probe random configurations and only do collision checks as needed.

The grid below runs A* with a Manhattan heuristic. Click to place or remove obstacles. Drag start (green) or goal (amber). The planner replans live.

Once a path is in hand, it still needs to be made time-optimal or smooth before it gets handed to the controller. Common steps:

Smoothing. The raw output of a grid or sampling planner is jagged and has redundant waypoints. Shortcut smoothing — repeatedly try to replace two waypoints with a direct segment if collision-free — removes much of this.

Parameterization. Turn the geometric path into a time-parameterized trajectory respecting velocity, acceleration, and torque limits. TOPP-RA (time-optimal path parameterization via reachability analysis) is a modern standard.

Re-planning. In dynamic environments the plan goes stale as soon as it is produced. Reactive controllers (artificial potential fields, velocity obstacles, MPC with obstacle constraints) handle local deviations without re-running the global planner every tick.

Modern robotic perception is a stack. At the bottom: proprioceptive sensors tell the robot about itself — encoders report joint positions, IMUs report angular rate and linear acceleration, force/torque sensors report contact loads. These are cheap, fast (kHz rates), and low-latency.

Above them: exteroceptive sensors tell the robot about the world — RGB cameras, depth cameras (stereo, ToF, structured-light), LiDAR, radar, ultrasonic. These are slower (typically 10–100 Hz), richer, and noisier, and they need careful extrinsic calibration against the robot's kinematic frame.

The job of the perception pipeline is not to produce raw data but to produce state estimates — compact representations of what the downstream planner needs to know. For a mobile robot, state is usually pose plus velocity. For a manipulator, it's joint configuration plus contact state. For a humanoid, it's both plus the world's geometry.

The canonical tool for combining noisy measurements with a motion model is the Kalman filter (and its nonlinear variants EKF, UKF, or particle filters). For mapping and localization simultaneously, SLAM (Simultaneous Localization and Mapping) algorithms build a map of the environment while also estimating the robot's pose within it — visual-inertial SLAM is currently the workhorse for low-cost systems.