Robotics

A plain-language introduction to what a robot actually is: a machine that senses the world, decides what to do and acts on it. And how that differs from an ordinary machine.

Robotics is the field that designs, builds and programs robots. See how mechanical engineering, electronics and computing overlap. And what appears only where they meet.

From the word “robot” in a 1921 play to today's warehouse fleets and walking machines. The milestones that shaped modern robotics and why each one mattered.

Every robot, however different, is built from the same subsystems: sensors, controller, actuators, transmission, power and frame. Learn what each does and how they connect.

The single loop that runs inside every robot: sense the world, decide what to do, act, then sense again. Learn why it must repeat, how fast and what breaks when it doesn't.

Degrees of freedom count the independent ways a robot can move. Learn the six DOF of a rigid body, how joints supply them and why six is the magic number for an arm.

The five classic arm layouts (Cartesian, cylindrical, spherical, SCARA and articulated) plus parallel robots. And the reachable workspace each geometry carves out of space.

What payload, reach, repeatability, accuracy, resolution and cycle time actually mean on a robot datasheet. Plus why repeatability and accuracy are not the same number.

Not every automated machine is a robot. Learn the line between fixed automation that repeats one motion and a robot that senses, adapts and can be reprogrammed.

Robots already work in factories, hospitals, farms and homes. Explore the real questions they raise about safety, accountability, work and fairness, beyond Asimov's three laws.

Robots come in families defined by the job they do. Learn the main ways of classifying them: by mobility, by application, by autonomy. Plus why shape follows task.

The six-axis arm is the workhorse of manufacturing. Learn its anatomy, its work envelope, the numbers that define it and the jobs it is bought to do.

Robots that move their whole base must know where they are. Learn the AGV/AMR distinction, the localisation problem and what changes when a robot leaves its pedestal.

Humanoids copy the human body to fit a world built for humans. Learn how bipedal balance actually works, why hands are so hard and when the human form is worth its cost.

How a quadcopter lifts, steers and stays upright: the four rotor speeds, the fast attitude loop and the payload-versus-endurance trade that shapes every drone.

Legs need only footholds, so they cross ground that stops wheels. Learn gaits, support polygons, static versus dynamic stability and the real cost legs impose.

A cobot is an arm engineered to share a workspace with people. Learn the four collaborative modes, the layered safety that makes them possible and what they trade away.

Two families that break the usual rules: many simple robots following local rules and machines that move by deforming rather than by rotating rigid joints.

How a physical thing, whether a temperature, a force or an angle, becomes a number a robot can use, and what the words sensor and transducer actually mean.

A tour of the sensors a robot actually carries, what each one measures and the two rules that decide which sensor belongs on which robot.

Range, sensitivity, resolution, accuracy, precision, linearity, hysteresis, drift and response time: the numbers on a sensor datasheet and the errors they are describing.

Robots sense two different things: their own body, and the world around it. Here is why that split decides drift, calibration and every localisation system.

Potentiometers, LVDTs, resolvers and synchros, Hall-effect and inductive proximity sensors: the devices that tell a robot how far something has moved.

The sensor inside almost every robot joint. Learn how an optical encoder counts, how quadrature gives direction and the difference between incremental and absolute.

Accelerometers, gyroscopes and magnetometers: what each really measures, why each one alone is useless and how fusing them gives a robot a sense of up.

Two cheap ways to measure how far away something is: time of flight with sound and triangulation with light. Each is defeated by completely different things.

How a spinning laser turns a room into an array of distances, what a LaserScan message actually contains and the surfaces that make LiDAR quietly fail.

What a camera actually gives a robot is a grid of numbers with the depth thrown away. Here are the four ways robots get that depth back.

Strain gauges, Wheatstone bridges, load cells, piezoelectric sensors and six-axis force-torque units: how a robot feels what it is pushing against.

Amplifiers, filters, sampling and analog-to-digital conversion: the electronics between a sensor and your code, and the errors each step introduces.

How several imperfect sensors become one good estimate: weighting by uncertainty, the predict and correct loop and what Kalman and particle filters actually do.

The three actuator families (electric, hydraulic and pneumatic) and the handful of properties that decide which one a robot should use.

The most common actuator in robotics. How current becomes torque, why a stalled motor overheats and what PWM and an H-bridge really do.

Two ways to send a motor to a position. A servo measures where it is and corrects itself, while a stepper counts its steps and trusts them.

Cylinders driven by oil or by air. Learn why oil makes an actuator stiff and strong, why air makes it springy and which jobs each one still owns.

Why robot joints need gearboxes: gear ratios, planetary and harmonic drives, belts and screws, backlash and when to skip the gears entirely.

Every robot is rigid links joined by joints. Meet the six basic joints, see why robots use just two of them and learn what a joint's limits really do.

Open and closed chains, serial and parallel robots and the Grübler–Kutzbach formula that counts a mechanism's freedoms before you build it.

The wheel types mobile robots use and the drives built from them: differential, Ackermann, skid-steer, tracked and omnidirectional.

The tool on the end of the arm decides what a robot can do. Learn the main gripper types, how to size grip force and where gripping goes wrong.

Where a robot's energy comes from and where it goes: battery chemistry, capacity and C-rate, voltage rails and the power budget that sets runtime.

Every robot carries a dozen coordinate frames. Learn what a frame is, how to name them without getting confused and the one rule that makes chaining transforms safe.

How nine numbers describe an orientation, why each column is just one axis written in another frame and how to turn a point without doing any trigonometry in your head.

Packing a turn and a shift into one 4 × 4 box, why the odd bottom row of zeros and a one is there and how chaining transforms walks you from a robot's base to its fingertips.

The four numbers that describe any joint of any robot arm, how to place link frames the same way every time and how a D–H table becomes a chain of transformation matrices.

Given the joint angles, where is the hand? This is the direction of robot kinematics that always has exactly one answer, and this lesson shows how to work it out.

Given where the hand must go, what should the joints do? The harder direction, with several answers, sometimes none at all and two very different ways to find them.

The matrix that links joint speeds to tool speed, how the same matrix maps forces backwards and what happens at a singularity where the arm loses a direction it can move.

Turning a path into a timed motion: joint space against Cartesian space, cubic polynomials, trapezoidal speed profiles with rounded corners and via points.

The torque each motor must produce to make a motion happen: inertia, gravity, Coriolis and friction, plus why heavy fast arms need all four and small slow ones do not.

The difference between commanding a machine and controlling one. What feedback buys, how to read a step response, and why every real loop is fighting delay.

The family of controllers a robot can use, from on/off and PID through feedforward, cascade, state feedback and MPC to impedance control, and what each one is for.

The controller that runs most of the machines in the world. What each of the three terms does, how to tune them in the order that works, and the traps that ruin PID loops.

Turning wheel speeds into robot motion and back again: the differential drive equations, the instantaneous centre of rotation, dead reckoning, and why odometry always drifts.

Finding a collision-free path from here to there: configuration space, the algorithms that search it, and why sampling beats exhaustive search once an arm is involved.

Knowing where you are while building the map at the same time: particle filters, scan matching, loop closure, and why odometry alone can never be enough.

Putting localisation, planning and control together into a robot that gets from A to B on its own: the layered stack, the costmaps, and what to do when it gets stuck.

The field that studies robots and people together: its three levels of interaction, the roles a human can play and why it borrows as much from psychology as it does from engineering.

How a robot's shape sets expectations before it does anything: anthropomorphic, zoomorphic and functional forms, affordances, design patterns and the uncanny valley.

How distance and orientation carry meaning: Hall's four zones, the real shape of personal space, O-space and F-formations, and how a robot should approach, pass and stand near somebody.

Gaze, gesture, posture, touch and timing: the channels that carry most of the meaning in an interaction, and how a robot can use each one on purpose.

The spoken language pipeline inside a robot, why conversation is harder than recognition, grounding and repair, and where large language models change the picture.

How robots show and read emotion: basic emotion models, the valence and arousal space, the expression channels that need no face, and the ethics of a machine that appears to feel.

What makes people trust a robot the right amount, the four collaborative safety modes of ISO/TS 15066, and why acceptance turns on much more than whether the robot works.

Where humans and robots actually work together today: manufacturing, healthcare, education, service, search and rescue and the home, and what each one demands.

ROS is not an operating system. Find out what it really is: a middleware, a build system and a huge ecosystem, plus the problem it exists to solve.

Why ROS was rewritten: no more master, DDS underneath, quality of service, real-time support and security. What changed and what it means for your code.

The layers under your code: rclpy, rcl, rmw and DDS. How discovery works without a master, and why executors decide when your callbacks actually run.

The unit of ROS software: one process, one job. Learn how to structure a robot as nodes, how to name and namespace them, and how to inspect a running system.

The publish/subscribe backbone of ROS. Named channels carrying typed data, why decoupling matters, and the standard message types you will use every day.

Request and response, when a node needs an answer. How services differ from topics, when to use them, and the blocking trap that catches everyone once.

For tasks that take time: send a goal, watch the progress, cancel if you change your mind. The pattern behind navigation, trajectory execution and grasping.

Configuration without recompiling. How ROS 2 parameters work, how to load them from YAML, and how to react when one changes at runtime.

ROS 2's QoS policies, from reliability and durability to history and depth: what each one trades away, and why a mismatched pair means no messages at all.

Three ways to get a working ROS 2 onto your machine, what sourcing the setup script really does, and the command-line tools you will use every day.

How ROS 2 code is organised and built: the workspace layout, package manifests, colcon, and the overlay that lets your code shadow the distribution's.

The first real ROS 2 program: two nodes, one topic. Timers, callbacks, QoS, entry points and the mistakes that stop the two from finding each other.

Defining your own .msg, .srv and .action files, building an interfaces package, and using the generated types from Python nodes.

Starting thirty nodes with one command. Python launch files, arguments, namespaces, parameter loading, and composing launch files from launch files.

ROS 2's transform system: a timestamped tree of every frame on the robot and how to ask where anything was at any moment in the recent past.

The XML file that tells ROS what your robot looks like: links, joints, visual and collision geometry, inertia, and why xacro is essential for anything real.

Gazebo, Webots, CoppeliaSim, Isaac Sim, MuJoCo, PyBullet, RoboDK and MATLAB: what each simulator is built for and how to choose between them.

Running your robot before it exists: worlds, physics, plugins, the ros_gz bridge and the settings that decide whether a simulation is useful or quietly misleading.

Seeing what the robot thinks. Displays, fixed frames, the difference between RViz and a simulator, and how to publish your own markers.

The framework between your ROS nodes and the motors: hardware interfaces, the controller manager, the real-time loop and the standard controllers you get for free.

The ROS 2 navigation stack in practice: what each server does, the behaviour tree that coordinates them, the costmap layers, and how to bring it up on a real robot.

The manipulation stack for ROS 2: the planning scene, motion planners, collision checking, the Setup Assistant, and planning in joint and Cartesian space from Python.

The classic first robot, built properly: an IR sensor array, a PD controller, calibration, and the failure cases that separate a demo from a robot that works.

A robot that drives around a room without a map: reactive avoidance, potential fields, and the local-minimum trap every reactive robot falls into.

Assemble a complete differential-drive robot in ROS 2, from URDF and ros2_control through simulation and SLAM to Nav2, in the order that actually works.

The canonical manipulation task, done properly: perception, grasp selection, approach and retreat, MoveIt, and the failure handling that makes it repeatable.

Getting images into OpenCV with cv_bridge, camera calibration, depth cameras and point clouds, fiducial markers, and putting a detection into the robot's frame.

Where learned components actually earn their place: object detection, reinforcement learning for control, imitation learning, and large language models as task planners.

Where robots actually work today, across manufacturing, logistics, agriculture, medicine, construction, inspection and space, and what each sector's constraint really is.

What is genuinely changing, from learned control to foundation models to cheaper hardware, what is still hard and how to tell a real advance from a good video.