We model any engineered physical agent as a controlled dynamical system with state \( x(t) \in \mathbb{R}^n \), input \( u(t) \in \mathbb{R}^m \), output \( y(t) \in \mathbb{R}^p \), and disturbances \( w(t) \). A general nonlinear form is

\[ \dot{x}(t) = f(x(t),u(t),w(t)), \qquad y(t) = h(x(t),u(t)) . \]

The controller uses sensor measurements to select actions: \( u(t)=\pi(\cdot) \). What distinguishes robots, automation, and mechatronic systems is not the plant alone, but the structure and capability of \( \pi \) and the sensing/actuation envelope.

Definition (Automation). An automated system executes a fixed physical or logical procedure with a controller \( \pi_A \) designed for a narrowly defined operating set \( \Omega \subset \mathcal{X}\times\mathcal{E} \) (state–environment pairs). The policy class is constrained, typically time-scheduled or event-triggered but not task-reconfigurable:

\[ u(t)=\pi_A(y(t),t;\theta_A), \qquad \theta_A\ \text{constant after deployment}. \]

Definition (Mechatronic System). A mechatronic system is an integrated electromechanical device in which sensing, actuation, embedded computation, and control are co-designed to realize a specific function. Formally, it is a closed-loop system \( \Sigma_M \) with \( u(t)=\pi_M(y(t);\theta_M) \), where \( \theta_M \) may be tunable but the task space is fixed.

Definition (Robot). A robot is a mechatronic agent with (i) embodied actuation that can produce multiple motion primitives, (ii) multi-modal sensing of self and environment, and (iii) task-level reprogrammability. Formally, a robot admits a policy family indexed by goals \( g \in \mathcal{G} \):

\[ u(t)=\pi_R(y(t),g,t;\theta_R), \qquad \mathcal{G}\ \text{nontrivial and extensible}. \]

Here “nontrivial” means that varying \( g \) changes the mapping from perception to action, not merely a scalar setpoint.

Let \( \mathcal{T} \) denote the set of tasks a system can realize. We model a task as a specification on trajectories: \( \tau = \{x(t),u(t)\}_{t\ge 0} \) belonging to a feasible set \( \Phi \subset \mathcal{X}^{\mathbb{R}_+}\times\mathcal{U}^{\mathbb{R}_+} \).

Define the task capacity as the cardinality or measure of feasible tasks: \( C_T = \mu(\mathcal{T}) \). While exact measures are hard, comparisons are meaningful:

• Automation: \( C_T \) is small and fixed at design time.
• Mechatronics: \( C_T \) can include parametric variations but within one function family.
• Robots: \( C_T \) expands by reprogramming or learning new goals \( g \).

A second criterion is the information dependency between sensed environment \( E \) and actions \( U \). Let \( I(E;U) \) be mutual information under the deployed policy.

\[ I(E;U)=\int\!\!\int p(e,u)\log\frac{p(e,u)}{p(e)p(u)}\,de\,du . \]

Intuitively, if actions barely change with the environment then \( I(E;U) \approx 0 \) and the system is closer to pure automation. Robots typically require substantial coupling: \( I(E;U) \gg 0 \) because sensing informs adaptive action.

Proposition (Robot–automation separation by information). Suppose two policies \( \pi_1,\pi_2 \) share the same plant. If \( I_{\pi_1}(E;U)=0 \) for all admissible environment distributions \( p(e) \), then \( \pi_1 \) is environment-independent and cannot realize tasks whose specification requires environment-conditioned actions. Hence its task capacity satisfies \( C_T(\pi_1) \le C_T(\pi_2) \) for any policy with \( I_{\pi_2}(E;U) > 0 \).

Proof. If \( I(E;U)=0 \), then \( p(u|e)=p(u) \) almost everywhere. Thus the closed-loop action sequence is statistically identical for all environments. Any task requiring distinct actions under distinct environments (i.e., two environments \( e_1\neq e_2 \) such that feasibility of trajectories depends on choosing different \( u(t) \)) cannot be satisfied. Therefore the feasible task set for \( \pi_1 \) is a subset of that for any environment-dependent policy, giving the inequality on capacities. ∎

Consider a discrete-time representation with sampling time \( T_s \):

\[ x_{k+1}=f_d(x_k,u_k,w_k),\qquad y_k=h_d(x_k). \]

Let the controller be decomposed into perception \( \rho \), decision \( \delta \), and actuation command \( \alpha \):

\[ \hat{s}_k=\rho(y_{0:k}),\quad a_k=\delta(\hat{s}_k,g),\quad u_k=\alpha(a_k). \]

Automation often collapses these layers (minimal internal state), e.g., \( u_k = K y_k \) or a finite timed script. Mechatronic systems keep feedback but with a single fixed goal family. Robots require a nontrivial internal state estimate and goal-conditioned decision.

flowchart TD
  S["Physical Plant"] --> Y["Sensors -> y_k"]
  Y --> P["Perception rho"]
  P --> D["Decision delta (uses goal g)"]
  D --> A["Actuation alpha -> u_k"]
  A --> S
        

flowchart LR  
  subgraph Types
    T1["Automation: \ndelta fixed or time-scripted"]
    T2["Mechatronics: \ndelta fixed goal family"]
    T3["Robots: delta goal-conditioned \n& environment-adaptive"]
  end
        

The diagram emphasizes that all three classes can be closed-loop systems. The difference is the richness of \( \rho,\delta \) and the size of the feasible goal set \( \mathcal{G} \).

Suppose tasks are encoded as reference trajectories \( r_g(t) \). In linear control notation:

\[ \dot{x}=Ax+Bu,\qquad y=Cx, \]

and a tracking controller \( u=K(x-r_g) \). If the system can only track a single trajectory family \( r_{g_0}(t) \), then it is automation/mechatronics. If we can change \( g \) to select new trajectories spanning a nontrivial subspace \( \mathcal{R}=\text{span}\{r_g\} \), it moves toward robotics.

Criterion (Reprogrammability rank). Let \( \{r_{g_1},\dots,r_{g_q}\} \) be achievable references. Define \( \text{rank}(\mathcal{R}) = \dim\text{span}\{r_{g_i}\} \). Then:

• Automation: \( \text{rank}(\mathcal{R}) = 1 \).
• Mechatronics: \( 1 < \text{rank}(\mathcal{R}) \ll n \) but within one function family.
• Robots: \( \text{rank}(\mathcal{R}) \) large, and new \( r_g \) added by software.

This bridges directly to control: a robot is not “more controlled”; it is controlled with a broader, goal-indexed reference set.

We implement a simple rule-based classifier using the criteria above. Features: \( c_T \) (normalized task capacity proxy), \( i_{EU} \) (estimated mutual information proxy), and \( r_R \) (reprogrammability rank proxy).

5.1 Python (NumPy)

import numpy as np

def classify_system(c_T, i_EU, r_R,
                    th_c=0.3, th_i=0.2, th_r=2):
    """
    c_T: task capacity proxy in [0,1]
    i_EU: normalized environment-action coupling proxy in [0,1]
    r_R: reprogrammability rank proxy (integer >=1)
    """
    if c_T < th_c and i_EU < th_i and r_R == 1:
        return "Automation"
    if c_T >= th_c and i_EU >= th_i and r_R >= th_r:
        return "Robot"
    return "Mechatronic System"

examples = [
    ("CNC line",        0.1, 0.05, 1),
    ("Active suspension",0.4, 0.15, 2),
    ("Mobile robot",    0.7, 0.6, 5),
]

for name, cT, iEU, rR in examples:
    print(name, "->", classify_system(cT, iEU, rR))
      

Robotics-related libraries you will later meet (not required yet): roboticstoolbox-python, pinocchio, pybullet. For now, NumPy suffices.

5.2 C++ (Standard Library)

#include 
#include 

std::string classifySystem(double cT, double iEU, int rR,
                           double th_c=0.3, double th_i=0.2, int th_r=2){
    if(cT < th_c && iEU < th_i && rR == 1) return "Automation";
    if(cT >= th_c && iEU >= th_i && rR >= th_r) return "Robot";
    return "Mechatronic System";
}

int main(){
    std::cout << "CNC line -> " << classifySystem(0.1, 0.05, 1) << "\n";
    std::cout << "Active suspension -> " << classifySystem(0.4, 0.15, 2) << "\n";
    std::cout << "Mobile robot -> " << classifySystem(0.7, 0.6, 5) << "\n";
    return 0;
}
      

C++ robotics ecosystems (preview only): Eigen (linear algebra), Orocos/KDL and Pinocchio (kinematics/dynamics), ROS2 client libraries.

5.3 Java

public class SystemClassifier {

    public static String classifySystem(double cT, double iEU, int rR,
                                        double th_c, double th_i, int th_r) {
        if (cT < th_c && iEU < th_i && rR == 1) return "Automation";
        if (cT >= th_c && iEU >= th_i && rR >= th_r) return "Robot";
        return "Mechatronic System";
    }

    public static void main(String[] args) {
        System.out.println("CNC line -> " +
                classifySystem(0.1, 0.05, 1, 0.3, 0.2, 2));
        System.out.println("Active suspension -> " +
                classifySystem(0.4, 0.15, 2, 0.3, 0.2, 2));
        System.out.println("Mobile robot -> " +
                classifySystem(0.7, 0.6, 5, 0.3, 0.2, 2));
    }
}
      

Java robotics toolkits (preview): WPILib (education), ROS-Java bridges, and numerical libraries like EJML for matrices.

5.4 MATLAB / Simulink (Script-level)

function label = classifySystem(cT, iEU, rR)
    th_c = 0.3; th_i = 0.2; th_r = 2;
    if cT < th_c && iEU < th_i && rR == 1
        label = "Automation";
    elseif cT >= th_c && iEU >= th_i && rR >= th_r
        label = "Robot";
    else
        label = "Mechatronic System";
    end
end

disp("CNC line -> " + classifySystem(0.1, 0.05, 1));
disp("Active suspension -> " + classifySystem(0.4, 0.15, 2));
disp("Mobile robot -> " + classifySystem(0.7, 0.6, 5));
      

In Simulink, this classifier would be a small Stateflow chart or MATLAB Function block that receives proxies from perception and planning blocks (details later in the course).

Problem 1 (Information Criterion): Let a deployed system have policy \( u_k = \pi(y_k) \) and environment random variable \( E \). Show that if \( u_k \) is deterministic and independent of \( E \), then \( I(E;U)=0 \).

Solution: If \( U \) is independent of \( E \), by definition \( p(e,u)=p(e)p(u) \). Substituting into mutual information,

\[ I(E;U)=\int\!\!\int p(e)p(u)\log\frac{p(e)p(u)}{p(e)p(u)}\,de\,du =\int\!\!\int p(e)p(u)\cdot 0\,de\,du = 0. \]

Problem 2 (Reprogrammability Rank): Consider an LTI plant \( \dot{x}=Ax+Bu \) controlled by \( u=K(x-r_g(t)) \). Suppose achievable references are \( r_g(t)=\sum_{i=1}^q \gamma_i(g)\phi_i(t) \), where \( \{\phi_i\} \) are linearly independent signals. Prove that \( \text{rank}(\mathcal{R})=q \).

Solution: The set of achievable references is \( \mathcal{R}=\{\sum_{i=1}^q \gamma_i\phi_i(t)\} \). As \( \phi_i \) are linearly independent, their span has dimension \( q \). Therefore the space of achievable references is a \( q \)-dimensional subspace, so \( \text{rank}(\mathcal{R})=\dim \text{span}\{\phi_i\}=q \). ∎

Problem 3 (Automation vs. Mechatronics): A thermostat regulating temperature via on/off hysteresis is a closed-loop system. Using the task-capacity definition, classify it and justify mathematically.

Solution: The thermostat realizes essentially one task family: maintain temperature near a fixed setpoint (possibly changing the scalar setpoint). The achievable reference set is \( \mathcal{R}=\{r(t)\equiv r_0 \mid r_0\in [r_{\min},r_{\max}] \} \), which has \( \text{rank}(\mathcal{R})=1 \) because all references are constant scalars. Thus \( C_T \) is low and fixed, so the system is automation, not a robot.

Problem 4 (Environment Coupling Proxy): A pick-and-place industrial arm repeats a fixed trajectory unless a proximity sensor triggers an emergency stop. Argue that its \( I(E;U) \) is small but nonzero, and classify it.

Solution: Actions follow a fixed script for almost all environments, except rare stop events. Hence \( p(u|e)\approx p(u) \) except on a small measure set where stop is triggered, giving small but nonzero mutual information. Task capacity remains fixed. Therefore it is best viewed as automation with safety feedback, not a robot.

We formalized automation, mechatronic systems, and robots as closed-loop dynamical systems distinguished by (i) size of achievable task sets, (ii) environment–action information coupling, and (iii) goal-conditioned reprogrammability rank. This removes the common misconception that “feedback” alone makes a system a robot. Next, we will study degrees of autonomy and intelligence in Lesson 3.