Robotics is not a single topic but a tightly coupled collection of subfields. A robot exists in a physical world, so we must model its body, sensors, computation, and interaction. The unifying loop from Lesson 4 (Sense–Think–Act) can be expanded into core subfields:

flowchart TD
  P["Physical robot (mechanics + actuators)"] --> S["Sensing"]
  S --> E["Estimation / Perception"]
  E --> D["Decision / Planning"]
  D --> C["Control"]
  C --> A["Actuation"]
  A --> P
  SW["Software & embedded systems"] --- S
  SW --- E
  SW --- D
  SW --- C
  HRI["Human–robot interaction + safety"] --- D
  HRI --- C
        

Each subfield is defined by the mathematical objects it studies:

• Mechanisms & Morphology: configuration \( \mathbf{q} \in \mathbb{R}^n \): joint variables describing the robot’s shape.
• Dynamics & Control: state \( \mathbf{x} = [\mathbf{q}^\top, \dot{\mathbf{q}}^\top]^\top \): and inputs \( \boldsymbol{\tau} \): forces/torques.
• Perception & Estimation: observations \( \mathbf{z} \): sensor outputs linked to state via measurement models.
• Planning & Autonomy: objective/cost functions over trajectories.
• Software/Systems: computational graphs, timing, middleware, safety layers.

The mechanical side covers how robots are built and how their geometry constrains motion. Even at an introductory level, two key mappings appear everywhere:

(a) Configuration space. A robot with \( n \): joints has a configuration vector \( \mathbf{q} = (q_1, \dots, q_n)^\top \in \mathbb{R}^n \):. The set of all feasible configurations is the configuration space \( \mathcal{Q} \subseteq \mathbb{R}^n \):. Constraints (joint limits, collisions) define \( \mathcal{Q} \):

\[ \mathcal{Q} = \{\mathbf{q}\in\mathbb{R}^n \mid \mathbf{q}_{\min} \le \mathbf{q} \le \mathbf{q}_{\max},\; \phi(\mathbf{q}) \le 0 \}. \]

Here \( \phi(\mathbf{q}) \): is a constraint function (e.g., collision metric), and inequalities are elementwise.

(b) Forward kinematic mapping. A task-space variable \( \mathbf{y} \in \mathbb{R}^m \): (e.g., end-effector position) is a function of configuration:

\[ \mathbf{y} = f(\mathbf{q}). \]

Differentiating gives the velocity relationship:

\[ \dot{\mathbf{y}} = \mathbf{J}(\mathbf{q})\dot{\mathbf{q}}, \quad \mathbf{J}(\mathbf{q}) = \frac{\partial f}{\partial \mathbf{q}}. \]

Proof (Jacobian maps joint to task velocities): For each component \( y_k = f_k(\mathbf{q}) \): the chain rule yields

\[ \dot{y}_k = \sum_{i=1}^n \frac{\partial f_k}{\partial q_i}\dot{q}_i. \]

Stacking \( k=1,\dots,m \): gives \( \dot{\mathbf{y}} = \mathbf{J}(\mathbf{q})\dot{\mathbf{q}} \): by definition of the Jacobian. This single linear map is foundational for control, planning, and perception later.

Actuation and power electronics sit next to mechanics. A simplified first-principles model of actuator output torque is often written as:

\[ \boldsymbol{\tau} = \mathbf{K}_t \mathbf{i} - \boldsymbol{\tau}_{\text{loss}}(\dot{\mathbf{q}}), \]

where \( \mathbf{i} \): motor currents and \( \mathbf{K}_t \): torque constants. Full motor modeling appears in Chapter 6.

Dynamics relates forces to motion; control chooses forces to achieve goals. A standard rigid-joint manipulator model is:

\[ \mathbf{M}(\mathbf{q})\ddot{\mathbf{q}} + \mathbf{C}(\mathbf{q},\dot{\mathbf{q}})\dot{\mathbf{q}} + \mathbf{g}(\mathbf{q}) = \boldsymbol{\tau}. \]

Here \( \mathbf{M}(\mathbf{q}) \): is a symmetric positive-definite inertia matrix, \( \mathbf{C}(\mathbf{q},\dot{\mathbf{q}}) \): Coriolis/centrifugal terms, and \( \mathbf{g}(\mathbf{q}) \): gravity.

Since you already know Linear Control, note that around an equilibrium \( (\mathbf{q}_0,\dot{\mathbf{q}}_0) \): you can linearize into state-space form:

\[ \dot{\mathbf{x}} = \mathbf{A}\mathbf{x} + \mathbf{B}\mathbf{u},\quad \mathbf{x} = \begin{bmatrix}\delta\mathbf{q}\\ \delta\dot{\mathbf{q}}\end{bmatrix},\; \mathbf{u}=\delta\boldsymbol{\tau}. \]

Lyapunov stability lens (control-theoretic core): if a candidate energy-like function \( V(\mathbf{x}) \): satisfies

\[ V(\mathbf{x}) > 0 \text{ for } \mathbf{x}\neq \mathbf{0},\quad V(\mathbf{0})=0,\quad \dot{V}(\mathbf{x}) \le 0, \]

then the equilibrium is stable. This idea returns in later autonomy chapters to justify safe behavior.

Sensors convert physical quantities into data streams. Perception interprets these streams and estimation infers hidden robot/world state. The generic measurement model is:

\[ \mathbf{z}_k = h(\mathbf{x}_k) + \mathbf{v}_k,\quad E[\mathbf{v}_k]=\mathbf{0},\; \operatorname{Cov}(\mathbf{v}_k)=\mathbf{R}. \]

Even without full probabilistic robotics yet, you can view \( h \): as the sensor physics, and \( \mathbf{R} \): as a compact way to describe noise energy.

A minimal deterministic estimator is least squares:

\[ \hat{\mathbf{x}} = \arg\min_{\mathbf{x}} \|\mathbf{z} - h(\mathbf{x})\|^2. \]

This optimization viewpoint links perception to planning and control through shared numerical tools.

Planning chooses actions/trajectories that satisfy constraints. A common abstraction is to search for a trajectory \( \mathbf{q}(t) \): minimizing a cost:

\[ \min_{\mathbf{q}(t)}\; J = \int_{0}^{T} \ell(\mathbf{q}(t),\dot{\mathbf{q}}(t),\boldsymbol{\tau}(t))\,dt + \Phi(\mathbf{q}(T)) \]

subject to dynamics and constraints:

\[ \mathbf{M}(\mathbf{q})\ddot{\mathbf{q}} + \mathbf{C}(\mathbf{q},\dot{\mathbf{q}})\dot{\mathbf{q}} + \mathbf{g}(\mathbf{q}) = \boldsymbol{\tau},\quad \mathbf{q}(t)\in\mathcal{Q}. \]

At the task level, planning also appears as graph search on discrete state sets:

\[ \pi^\star = \arg\min_{\pi} \sum_{k=0}^{N-1} c(x_k,u_k), \]

where \( \pi \): is a policy that selects actions \( u_k \): to move between states \( x_k \):. Detailed algorithms arrive in Chapter 18.

Robotics software must tie continuous physics to discrete computation in real time. A robot software stack typically separates:

• Drivers: talk to sensors/actuators.
• Middleware: message passing, timing, safety.
• Applications: perception, planning, control nodes.

The mathematical heart here is timing and causality. If a controller runs every \( T_s \): seconds, then a discrete-time model reads:

\[ \mathbf{x}_{k+1} = F(\mathbf{x}_k,\mathbf{u}_k),\quad k=0,1,2,\dots \]

Stability and performance depend on the sampling rate \( f_s = 1/T_s \):, motivating real-time design (Chapter 10).

A robotics major is usually built as a layered curriculum, because each layer provides mathematical tools for the next. A standard structure is:

flowchart TD
  L0["Math + programming foundation"] --> L1["Mechanisms + actuators + sensors"]
  L1 --> L2["Perception basics + coordinate frames"]
  L2 --> L3["Kinematics + dynamics + control"]
  L3 --> L4["Planning + autonomy concepts"]
  L4 --> L5["Systems integration labs + capstone"]
        

In this course, you are at the start of Layer 1. We introduce concepts without heavy derivations in the early chapters, then gradually add formal models and computation:

1. Chapters 1–5: What robots are, how they’re built, and basic mechanism intuition.
2. Chapters 6–9: Actuators, sensors, and spatial representations.
3. Chapters 10–13: Embedded computing, software stacks, and simulation.
4. Chapters 14–18: HRI, safety, and autonomy survey.
5. Chapters 19–20: Integration lab and capstone design.

The structure reflects a dependency graph: you can’t safely design autonomy without knowing sensing limits; you can’t control motion without modeling actuators and mechanical constraints.

This descriptive lesson only samples tools. Later chapters will go deeper.

Python (scientific + robotics)

# Mechanical/perception/planning toolchains often start from NumPy/SciPy
import numpy as np

# Simple "configuration" and Jacobian numeric example
q = np.array([0.2, -0.4, 0.1])          # joint vector
J = np.array([[1.0, 0.2, 0.0],          # toy Jacobian
              [0.0, 1.0, 0.3]])
qd = np.array([0.5, 0.0, -0.2])         # joint velocities
yd = J @ qd                              # task velocity

print("q =", q)
print("yd =", yd)

# Typical robotics libraries you will see later:
# - rclpy (ROS2 Python)
# - opencv-python (vision)
# - pinocchio / roboticstoolbox / drake (modeling)
      

C++ (real-time + high-performance)

#include <iostream>
#include <Eigen/Dense>   // core robotics linear algebra

int main() {
  Eigen::Vector3d q(0.2, -0.4, 0.1);
  Eigen::Matrix<double,2,3> J;
  J << 1.0, 0.2, 0.0,
       0.0, 1.0, 0.3;
  Eigen::Vector3d qd(0.5, 0.0, -0.2);
  Eigen::Vector2d yd = J * qd;

  std::cout << "q = " << q.transpose() << std::endl;
  std::cout << "yd = " << yd.transpose() << std::endl;

  // Later chapters: rclcpp (ROS2), MoveIt, Pinocchio, Drake, Gazebo plugins.
  return 0;
}
      

Java (less common, but used in some stacks and teaching)

import java.util.Arrays;

public class RobotSubfieldsDemo {
    public static void main(String[] args) {
        double[] qd = {0.5, 0.0, -0.2};
        double[][] J = {
            {1.0, 0.2, 0.0},
            {0.0, 1.0, 0.3}
        };
        double[] yd = new double[2];
        for(int r=0; r<2; r++){
            for(int c=0; c<3; c++){
                yd[r] += J[r][c]*qd[c];
            }
        }
        System.out.println("yd = " + Arrays.toString(yd));

        // Typical Java robotics ecosystems:
        // - rosjava (ROS1-era), PX4 Java MAVLink tools, Android-based robots.
    }
}
      

MATLAB / Simulink (modeling + control prototyping)

% Toy Jacobian mapping in MATLAB
q  = [0.2; -0.4; 0.1];
J  = [1.0 0.2 0.0;
      0.0 1.0 0.3];
qd = [0.5; 0.0; -0.2];
yd = J*qd

% MATLAB ecosystems you will meet later:
% - Robotics System Toolbox (rigidBodyTree, sensors, planners)
% - Simulink for real-time control blocks
      

Notice the same math object \( \mathbf{J}\dot{\mathbf{q}} \): appears in every language. Robotics software is unified by shared mathematics more than by a single tool.

Problem 1 (Subfield Identification): Consider a mobile robot that uses a camera to detect obstacles, plans a path, and controls wheel torques. For each pipeline stage below, name the most relevant robotics subfield: (i) camera calibration and feature extraction, (ii) map building of obstacles from detections, (iii) shortest collision-free route, (iv) torque commands to track the route.

Solution:

• (i) Sensing/Perception (sensor modeling, vision features).
• (ii) Estimation/Perception (state/world inference from noisy data).
• (iii) Planning/Autonomy (trajectory/path optimization).
• (iv) Dynamics & Control (inputs to follow desired motion).

Problem 2 (Jacobian Velocity Mapping): Let \( \mathbf{y}=f(\mathbf{q}) \): with \( f:\mathbb{R}^n\to\mathbb{R}^m \): differentiable. Prove that small configuration perturbations \( \delta\mathbf{q} \): induce first-order task perturbations \( \delta\mathbf{y} \approx \mathbf{J}(\mathbf{q})\delta\mathbf{q} \):.

Solution: By first-order Taylor expansion,

\[ f(\mathbf{q}+\delta\mathbf{q}) = f(\mathbf{q}) + \frac{\partial f}{\partial \mathbf{q}}\delta\mathbf{q} + o(\|\delta\mathbf{q}\|). \]

Therefore the first-order change is \( \delta\mathbf{y} = f(\mathbf{q}+\delta\mathbf{q})-f(\mathbf{q}) \approx \mathbf{J}(\mathbf{q})\delta\mathbf{q} \):.

Problem 3 (Configuration-Space Constraints): A 2-joint planar arm has limits \( -\pi/2 \le q_1 \le \pi/2 \): and \( 0 \le q_2 \le \pi \):. Write the configuration space \( \mathcal{Q} \): explicitly and compute its area.

Solution:

\[ \mathcal{Q} = \{(q_1,q_2)\in\mathbb{R}^2 \mid -\pi/2 \le q_1 \le \pi/2,\; 0 \le q_2 \le \pi \}. \]

This is a rectangle in \( (q_1,q_2) \): space with side lengths \( \pi \): and \( \pi \):, so its area is \( \pi^2 \):.

Problem 4 (Linearization Reminder): Suppose a nonlinear robot model is \( \dot{\mathbf{x}}=F(\mathbf{x},\mathbf{u}) \): with equilibrium \( F(\mathbf{x}_0,\mathbf{u}_0)=\mathbf{0} \):. Show that the first-order perturbation dynamics are \( \delta\dot{\mathbf{x}}=\mathbf{A}\delta\mathbf{x}+\mathbf{B}\delta\mathbf{u} \): with correct definitions of \( \mathbf{A},\mathbf{B} \):.

Solution: Taylor expand around the equilibrium:

\[ F(\mathbf{x}_0+\delta\mathbf{x},\mathbf{u}_0+\delta\mathbf{u}) \approx F(\mathbf{x}_0,\mathbf{u}_0) + \frac{\partial F}{\partial \mathbf{x}}\Big|_0 \delta\mathbf{x} + \frac{\partial F}{\partial \mathbf{u}}\Big|_0 \delta\mathbf{u}. \]

Since \( F(\mathbf{x}_0,\mathbf{u}_0)=\mathbf{0} \):, we get \( \delta\dot{\mathbf{x}}=\mathbf{A}\delta\mathbf{x}+\mathbf{B}\delta\mathbf{u} \): where \( \mathbf{A}=\frac{\partial F}{\partial \mathbf{x}}\big|_0 \): and \( \mathbf{B}=\frac{\partial F}{\partial \mathbf{u}}\big|_0 \):.

Problem 5 (Curriculum Dependency Logic): Give a short argument (2–3 sentences) explaining why perception should be taught before high-level autonomy in a robotics major.

Solution: Autonomy chooses actions based on the robot’s belief about the world. Without understanding sensing and estimation limits (noise, drift, occlusions), autonomy would be designed under false assumptions and could be unsafe. Therefore perception is a prerequisite for reliable decision-making.

Robotics is organized around interacting subfields: mechanics/actuation, perception/estimation, planning/autonomy, and control, all supported by software and safety/HRI. Across these areas, the same mathematical primitives—configuration \( \mathbf{q} \):, state \( \mathbf{x} \):, measurements \( \mathbf{z} \):, and cost \( J \):—reappear. A university curriculum layers topics to respect these dependencies, which is exactly the order followed in this course.